Extra content, thinking blocks, and thought signatures

How GoModel preserves provider replay state such as Gemini 3 thought signatures and Anthropic thinking blocks across turns, APIs, and providers

What extra content is

Some providers attach opaque state to a reply and expect it back, unchanged, on the next turn. Gemini 3 signs its function calls with a thought signature and rejects a history that replays the call without it. Anthropic requires the thinking blocks of an assistant turn, signatures included, in front of a tool-use turn that continues.

Such state has no OpenAI-compatible field, so GoModel carries it in one place: an extra_content object keyed by vendor.

{
  "role": "assistant",
  "tool_calls": [{
    "id": "call_1",
    "type": "function",
    "function": {"name": "get_weather", "arguments": "{\"city\":\"Kraków\"}"},
    "extra_content": {"google": {"thought_signature": "EvACCu0CARFNMg..."}}
  }]
}

GoModel stores nothing. The state travels inside the response to the client and comes back inside the client’s message history. Clients that copy assistant messages into the history verbatim, which is what the OpenAI, Anthropic, and Responses SDKs do, need no changes.

The shape matches Google’s own OpenAI-compatible endpoint, so clients built against it work unchanged.

Where it appears

API	Location
Chat Completions	tool_calls[].extra_content; on the assistant message for turn-wide state such as thinking blocks; also on streamed tool_calls and message deltas
Responses	function_call output items; reasoning output items; the assistant message item when a text-turn signature arrives while streaming
Anthropic Messages	tool_use content blocks. Thinking blocks use the dialect’s own signature and data fields instead.

State sits on the unit that maps to one provider part. A tool call becomes one Gemini part, so a per-call signature lives on the tool call. Thinking blocks belong to the whole assistant turn, so they live on the message.

Rules

• Every translation copies it through. Chat, Responses, and Anthropic Messages ingress, streaming, and the assistant-turn echo carry extra_content without looking inside.
• Only the owning provider sees its own vendor. Before a request leaves for a provider, GoModel drops every vendor object that provider does not own. A Gemini signature never reaches Anthropic or OpenAI, and a history that moved between providers does not fail on foreign fields.
• Only the owning adapter reads or writes inside it. Nothing else in the gateway interprets the contents.
• Echo it verbatim. Do not rewrite, reorder, or trim the member.

Thought signature preservation

Gemini 3 attaches an encrypted thoughtSignature to the function calls it emits. The next request must carry the same signature on the same call, or Gemini answers with HTTP 400 “Function call is missing a thought_signature”. One tool-call turn through Chat Completions looks like this. Only the fields that matter are shown.

1. The client asks a question with a tool available

   POST /v1/chat/completions
   {
     "model": "gemini-3.5-flash",
     "messages": [
       {"role": "user", "content": "What's the weather in Kraków?"}
     ],
     "tools": [{
       "type": "function",
       "function": {"name": "get_weather", "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}}
     }]
   }
   
2. Gemini replies with a function call and a signature

   GoModel translates the request into Gemini’s native generateContent shape. Gemini returns a functionCall part that carries the signature.

   {
     "candidates": [{
       "content": {
         "role": "model",
         "parts": [{
           "functionCall": {"name": "get_weather", "args": {"city": "Kraków"}},
           "thoughtSignature": "EvACCu0CARFNMg..."
         }]
       }
     }]
   }
   
3. GoModel returns the call with the signature under extra_content

   {
     "choices": [{
       "message": {
         "role": "assistant",
         "content": null,
         "tool_calls": [{
           "id": "call_1",
           "type": "function",
           "function": {"name": "get_weather", "arguments": "{\"city\":\"Kraków\"}"},
           "extra_content": {"google": {"thought_signature": "EvACCu0CARFNMg..."}}
         }]
       },
       "finish_reason": "tool_calls"
     }]
   }
   
4. The client runs the tool and sends the full history back

   The assistant message is appended as received, so extra_content comes along for free.

   POST /v1/chat/completions
   {
     "model": "gemini-3.5-flash",
     "messages": [
       {"role": "user", "content": "What's the weather in Kraków?"},
       {
         "role": "assistant",
         "content": null,
         "tool_calls": [{
           "id": "call_1",
           "type": "function",
           "function": {"name": "get_weather", "arguments": "{\"city\":\"Kraków\"}"},
           "extra_content": {"google": {"thought_signature": "EvACCu0CARFNMg..."}}
         }]
       },
       {"role": "tool", "tool_call_id": "call_1", "content": "{\"temp_c\": 18, \"sky\": \"cloudy\"}"}
     ],
     "tools": ["..."]
   }
   
5. GoModel replays the signature on the matching Gemini part

   {
     "contents": [
       {"role": "user", "parts": [{"text": "What's the weather in Kraków?"}]},
       {"role": "model", "parts": [{
         "functionCall": {"name": "get_weather", "args": {"city": "Kraków"}},
         "thoughtSignature": "EvACCu0CARFNMg..."
       }]},
       {"role": "user", "parts": [{
         "functionResponse": {"name": "get_weather", "response": {"temp_c": 18, "sky": "cloudy"}}
       }]}
     ]
   }
   

   Gemini accepts the replay and answers with text. GoModel returns a normal chat completion.

The same member appears on streamed tool_calls deltas, on Responses API function_call items, on Anthropic Messages tool_use blocks, and, for text-only turns, on the assistant message itself. On the Responses API a text-only turn’s signature rides on a reasoning output item ahead of the message, with no reasoning text of its own; echo the item back and the signature lands on the assistant turn. Only the first call of a parallel batch carries a signature. A flat thought_signature or thoughtSignature on the tool call is accepted too, so clients built against other gateways keep working.

When a Gemini 3 history contains a function call without any signature, because the conversation started on another provider or a client dropped the member, GoModel sends Google’s documented placeholder instead of surfacing the 400. Echo the real value whenever you have it; the placeholder costs reasoning continuity for that turn. See Gemini thought signatures for provider details.

Thinking blocks

Anthropic’s extended thinking returns thinking and redacted_thinking content blocks on an assistant turn. When that turn ends in a tool call, the follow-up request must replay those blocks, signatures included, ahead of the tool_use block. Through the Anthropic Messages API the flow is:

1. The client sends a history that contains thinking blocks

   POST /v1/messages
   {
     "model": "claude-sonnet-4-5",
     "max_tokens": 1024,
     "thinking": {"type": "enabled", "budget_tokens": 2048},
     "messages": [
       {"role": "user", "content": "What's the weather in Kraków?"},
       {"role": "assistant", "content": [
         {"type": "thinking", "thinking": "I should call the weather tool.", "signature": "EqQBCkYIBRgC..."},
         {"type": "tool_use", "id": "toolu_1", "name": "get_weather", "input": {"city": "Kraków"}}
       ]},
       {"role": "user", "content": [
         {"type": "tool_result", "tool_use_id": "toolu_1", "content": "weather service timed out", "is_error": true}
       ]}
     ],
     "tools": ["..."]
   }
   
2. GoModel keeps the blocks under extra_content.anthropic

   Internally the history is chat-shaped. The thinking blocks ride on the assistant message and is_error on the tool result. Neither has an OpenAI-compatible field, so both live under the anthropic vendor. is_error is only written when the result failed.

   [
     {"role": "user", "content": "What's the weather in Kraków?"},
     {
       "role": "assistant",
       "content": null,
       "tool_calls": [{"id": "toolu_1", "type": "function", "function": {"name": "get_weather", "arguments": "{\"city\":\"Kraków\"}"}}],
       "extra_content": {"anthropic": {"thinking_blocks": [
         {"type": "thinking", "thinking": "I should call the weather tool.", "signature": "EqQBCkYIBRgC..."}
       ]}}
     },
     {
       "role": "tool", "tool_call_id": "toolu_1", "content": "weather service timed out",
       "extra_content": {"anthropic": {"is_error": true}}
     }
   ]
   
3. Anthropic receives the blocks verbatim

   When the route lands on Anthropic, the thinking blocks are put back in front of the tool_use block exactly as sent, and is_error is restored on the tool_result. Any other provider receives the tool call and the result text only.

On the way back

Anthropic signs every thinking block it returns, and rejects a later turn that replays one without its signature:

400 messages.1.content.0.thinking.signature: Field required

So the blocks travel out to the client the same way they travel in. The Anthropic Messages API renders them as real content blocks, signature included, because that is what an Anthropic client echoes back:

{
  "content": [
    {"type": "thinking", "thinking": "I should call the weather tool.", "signature": "EqQBCkYIBRgC..."},
    {"type": "tool_use", "id": "toolu_1", "name": "get_weather", "input": {"city": "Kraków"}}
  ],
  "stop_reason": "tool_use"
}

Streaming emits the signature as a signature_delta inside the thinking block, before it closes, exactly as Anthropic does.

The other dialects have no thinking block, so they carry the same data under extra_content.anthropic.thinking_blocks — on the assistant message in Chat Completions, on the reasoning output item in the Responses API. Streaming chat deltas carry the value once the thinking block completes, before any text, and it is cumulative: the last one seen holds the whole turn.

{
  "role": "assistant",
  "content": "Let me look that up.",
  "reasoning_content": "I should call the weather tool.",
  "extra_content": {"anthropic": {"thinking_blocks": [
    {"type": "thinking", "thinking": "I should call the weather tool.", "signature": "EqQBCkYIBRgC..."}
  ]}}
}

reasoning_content stays what it has always been: the readable text, and nothing to replay. A redacted_thinking block has no readable text at all, so extra_content is the only thing that carries it.

Append the assistant turn to the history as received and the replay is automatic. Routing that history to another provider drops the member, as every foreign vendor object is dropped, and the conversation continues without it.

Moving a history between providers

A conversation may start on one provider and continue on another. The rule is simple: every vendor object that the target provider does not own is removed before dispatch, on every route, in every dialect.

History carries	Routed to	Provider receives
extra_content.google	gemini, vertex	the signature, replayed on the matching part
extra_content.google	any other provider	nothing; the member is dropped
extra_content.anthropic	anthropic	thinking blocks and is_error, restored in place
extra_content.anthropic	any other provider	nothing; the member is dropped

The client’s own history is never modified. The filtering happens on the copy GoModel sends upstream.

Vendor reference

Vendor	Providers	Members
google	gemini, vertex	thought_signature: the Gemini 3 signature of a function call or text turn.
anthropic	anthropic	thinking_blocks: the thinking and redacted_thinking blocks of an assistant turn, signatures included, written on responses and read back on requests; is_error: marks a tool result as failed, set by the Anthropic Messages API ingress.