copilot: an empty assistant message never enters the translation cache

A model that answers entirely through its tools ends the turn with an
empty assistant message, and the proxy reports it as a native item whose
single output_text carries "". The responses dialect trusted the
authoritative terminal list and cached that item verbatim. Replayed as
input on the next turn, it is refused: provider_error in under a second,
one event, no explanation, and the item is in the cache, so the aria can
never speak again. Aria 0c1faa2f went mute that way with four unanswered
messages behind it, and the only rescue was a fork taken before the
offending node.

The anthropic dialect has guarded this for a while (cacheableNativeBlock
drops a text block with no text, next to a comment about bricking an
aria). This brings the same rule to the native path here: strip the
text-free parts of a message item, drop the item when nothing is left,
and leave reasoning items alone, since their content is legitimately
empty and the payload rides in encrypted_content. Parts of a shape this
file does not recognize are kept, not guessed at.

The fingerprint goes to v5 so the arias already holding one are cured
rather than merely spared: a stale fingerprint clears the translation
log, and re-encoding from the fig IR drops the empty output node instead
of replaying it. The price is one uncached prompt per aria.

Author: gluck

internal/provider/copilot/responses.go

@@ -25,7 +25,12 @@ import (
 
 // v4: a tool round with nobody speaking carries its reminders inside the last
 // function_call_output instead of a user message of their own.
-const responsesFingerprintPrefix = "copilot-responses/v4"
+//
+// v5: text-free assistant message items are no longer cached. The bump is the
+// cure for the arias that already hold one: a stale fingerprint clears the
+// log, and re-encoding from the fig IR drops the item instead of replaying it
+// into a payload the proxy refuses. The price is one uncached prompt per aria.
+const responsesFingerprintPrefix = "copilot-responses/v5"
 
 type responseTokenSource interface {
 	Resolve() (string, error)

internal/provider/copilot/responses_stream.go

@@ -159,7 +159,9 @@ func (p *responsePartial) outputItems() []json.RawMessage {
 			continue
 		}
 		if part.raw != nil {
-			out = append(out, part.raw)
+			if vetted, ok := vetResponseMessageItem(part.raw); ok {
+				out = append(out, vetted)
+			}
 			continue
 		}
 		var item any
@@ -422,7 +424,12 @@ func (s *responseStreamState) reconcile(response *responseObject) error {
 			return fmt.Errorf("copilot responses: decode terminal item: %w", err)
 		}
 		if item.Type != "function_call" {
-			out = append(out, raw)
+			// The authoritative terminal list is trusted for everything
+			// except a message with nothing in it: that one item, replayed
+			// as input, gets the whole request refused.
+			if vetted, ok := vetResponseMessageItem(raw); ok {
+				out = append(out, vetted)
+			}
 			continue
 		}
 		if item.CallID == "" || item.Name == "" {
@@ -601,6 +608,78 @@ func safeResponseReason(reason string) string {
 	}
 }
 
+// vetResponseMessageItem drops the text-free parts of a native assistant
+// message, and the whole item when nothing is left.
+//
+// A model that says everything through its tools ends the turn with an empty
+// assistant message, and the proxy sends it as a native item with one
+// output_text whose text is "". Replayed as input, that item is refused:
+// provider_error inside a second, no stream, no explanation. The item is in
+// the translation cache by then, so every later turn carries it and the aria
+// cannot speak again. Reconstructed items were already filtered this way; this
+// closes the native path on the same rule.
+//
+// Reasoning items are not touched: their content is legitimately empty, the
+// payload rides in encrypted_content.
+func vetResponseMessageItem(raw json.RawMessage) (json.RawMessage, bool) {
+	var item struct {
+		Type    string            `json:"type"`
+		Content []json.RawMessage `json:"content"`
+	}
+	if json.Unmarshal(raw, &item) != nil || item.Type != "message" {
+		return raw, true
+	}
+	kept := make([]json.RawMessage, 0, len(item.Content))
+	for _, part := range item.Content {
+		if responsePartIsBlank(part) {
+			continue
+		}
+		kept = append(kept, part)
+	}
+	if len(kept) == 0 {
+		return nil, false
+	}
+	if len(kept) == len(item.Content) {
+		return raw, true
+	}
+	// Rebuild from the ORIGINAL part bytes: annotations, logprobs and any
+	// field this file has never heard of survive a partial prune.
+	var fields map[string]json.RawMessage
+	if json.Unmarshal(raw, &fields) != nil {
+		return raw, true
+	}
+	content, err := json.Marshal(kept)
+	if err != nil {
+		return raw, true
+	}
+	fields["content"] = content
+	out, err := json.Marshal(fields)
+	if err != nil {
+		return raw, true
+	}
+	return out, true
+}
+
+// responsePartIsBlank reports a message part that carries nothing a reader
+// could see. A part of an unknown shape is NOT blank: this prunes what it
+// recognizes and leaves everything else alone.
+func responsePartIsBlank(raw json.RawMessage) bool {
+	var part struct {
+		Type     string `json:"type"`
+		Text     string `json:"text"`
+		ImageURL string `json:"image_url"`
+	}
+	if json.Unmarshal(raw, &part) != nil {
+		return false
+	}
+	switch part.Type {
+	case "output_text", "text", "summary_text", "input_text", "refusal":
+		return strings.TrimSpace(part.Text) == "" && part.ImageURL == ""
+	default:
+		return false
+	}
+}
+
 // Keep the native item's other fields verbatim, but give a rejected call a
 // valid arguments object for replay. The sentinel retains the original bytes;
 // the agent refuses execution and sends INVALID_JSON on the original call_id.

internal/provider/copilot/responses_stream_test.go

@@ -257,3 +257,106 @@ func TestResponsesAbnormalTerminalPreservesAuthoritativeNativeOutput(t *testing.
 	require.Len(t, out.Output, 1)
 	require.Equal(t, string(native), string(out.Output[0]))
 }
+
+// A model that answers through its tools and then says nothing ends the turn
+// with an empty assistant message. Cached, it is replayed on every later turn,
+// and the proxy refuses the whole request: the aria goes mute for good. The
+// item must never reach the cache.
+func TestResponsesTextFreeAssistantItemNeverEntersTheCache(t *testing.T) {
+	reasoning := json.RawMessage(`{"type":"reasoning","id":"signed","encrypted_content":"opaque","content":[],"summary":[]}`)
+	empty := json.RawMessage(`{"type":"message","role":"assistant","id":"blank","content":[{"type":"output_text","text":"","annotations":[],"logprobs":[]}]}`)
+	call := json.RawMessage(`{"type":"function_call","call_id":"c1","name":"echo","arguments":"{}","status":"completed"}`)
+	server := newResponseServer(t, func(conn *websocket.Conn) {
+		defer conn.Close()
+		var req responseCreateRequest
+		if websocket.JSON.Receive(conn, &req) != nil {
+			return
+		}
+		_ = websocket.JSON.Send(conn, map[string]any{"type": "response.completed", "response": map[string]any{
+			"status": "completed", "output": []any{reasoning, empty, call},
+		}})
+	})
+	cache := store.NewMemLog[[]json.RawMessage]()
+	p := newResponsesTestProvider(server, cache)
+	bus := &responseTestBus{}
+	require.NoError(t, p.Send(context.Background(), provider.SendInput{AriaID: "blank", FigLog: newResponsesInputLog(t)}, bus))
+
+	require.Len(t, bus.cache, 1)
+	payload := bus.cache[0].Payload
+	require.Len(t, payload, 2, "the empty message is gone, reasoning and the call are not")
+	require.JSONEq(t, string(reasoning), string(payload[0]))
+	require.Contains(t, string(payload[1]), `"function_call"`)
+	for _, raw := range payload {
+		require.NotContains(t, string(raw), `"blank"`, "no trace of the text-free item")
+	}
+}
+
+func TestVetResponseMessageItemPrunesOnlyWhatItRecognizes(t *testing.T) {
+	for _, tc := range []struct {
+		name, raw, want string
+		keep            bool
+	}{
+		{
+			name: "text-free message is dropped whole",
+			raw:  `{"type":"message","role":"assistant","content":[{"type":"output_text","text":""}]}`,
+		},
+		{
+			name: "whitespace is not speech",
+			raw:  `{"type":"message","role":"assistant","content":[{"type":"output_text","text":"  \n "}]}`,
+		},
+		{
+			name: "a message with no content at all is dropped",
+			raw:  `{"type":"message","role":"assistant","content":[]}`,
+		},
+		{
+			name: "text survives verbatim",
+			raw:  `{"type":"message","role":"assistant","content":[{"type":"output_text","text":"ecco","annotations":[]}]}`,
+			want: `{"type":"message","role":"assistant","content":[{"type":"output_text","text":"ecco","annotations":[]}]}`,
+			keep: true,
+		},
+		{
+			name: "a mixed message keeps the spoken part with its fields",
+			raw:  `{"type":"message","role":"assistant","id":"m","content":[{"type":"output_text","text":""},{"type":"output_text","text":"ecco","annotations":["a"]}]}`,
+			want: `{"type":"message","role":"assistant","id":"m","content":[{"type":"output_text","text":"ecco","annotations":["a"]}]}`,
+			keep: true,
+		},
+		{
+			name: "reasoning keeps its empty content: the payload is encrypted",
+			raw:  `{"type":"reasoning","encrypted_content":"opaque","content":[],"summary":[]}`,
+			want: `{"type":"reasoning","encrypted_content":"opaque","content":[],"summary":[]}`,
+			keep: true,
+		},
+		{
+			name: "a part shape this file does not know is left alone",
+			raw:  `{"type":"message","role":"assistant","content":[{"type":"output_audio","text":""}]}`,
+			want: `{"type":"message","role":"assistant","content":[{"type":"output_audio","text":""}]}`,
+			keep: true,
+		},
+		{
+			name: "an image part is speech even with no text",
+			raw:  `{"type":"message","role":"assistant","content":[{"type":"input_text","text":"","image_url":"data:image/png;base64,AA"}]}`,
+			want: `{"type":"message","role":"assistant","content":[{"type":"input_text","text":"","image_url":"data:image/png;base64,AA"}]}`,
+			keep: true,
+		},
+		{
+			name: "undecodable bytes pass through untouched",
+			raw:  `not json`,
+			want: `not json`,
+			keep: true,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, ok := vetResponseMessageItem(json.RawMessage(tc.raw))
+			require.Equal(t, tc.keep, ok)
+			if !tc.keep {
+				require.Nil(t, got)
+				return
+			}
+			if tc.want == "not json" {
+				require.Equal(t, tc.want, string(got))
+				return
+			}
+			require.JSONEq(t, tc.want, string(got))
+		})
+	}
+}