Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@ebfb681dc28c9870f426e091bf3002aa6546a94f

Author: github-actions[bot]

packages/agent-runtime/src/__tests__/stream-parser-tool-call-metadata.test.ts

@@ -0,0 +1,107 @@
+/**
+ * A native tool call's provider metadata (Gemini 3's thought signature) must
+ * reach the history's tool-call part, or the next request is refused with
+ * "Function call is missing a thought_signature" (HTTP 400).
+ */
+import { TEST_AGENT_RUNTIME_IMPL } from '@codebuff/common/testing/impl/agent-runtime'
+import { getInitialSessionState } from '@codebuff/common/types/session-state'
+import { describe, expect, it } from 'bun:test'
+
+import { mockFileContext } from './test-utils'
+import { processStream } from '../tools/stream-parser'
+
+import type { AgentTemplate } from '../templates/types'
+import type { StreamChunk } from '@codebuff/common/types/contracts/llm'
+import type { PromptResult } from '@codebuff/common/util/error'
+
+const template: AgentTemplate = {
+  id: 'test-agent',
+  displayName: 'Test Agent',
+  spawnerPrompt: 'Test agent',
+  model: 'gemini-3.5-flash-lite',
+  inputSchema: {},
+  outputMode: 'structured_output',
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: false,
+  mcpServers: {},
+  toolNames: ['end_turn'],
+  spawnableAgents: [],
+  systemPrompt: 'Test system prompt',
+  instructionsPrompt: 'Test instructions',
+  stepPrompt: 'Test step prompt',
+}
+
+async function historyAfter(chunks: StreamChunk[]) {
+  async function* stream(): AsyncGenerator<
+    StreamChunk,
+    PromptResult<string | null>
+  > {
+    for (const chunk of chunks) yield chunk
+    return { aborted: false, value: 'msg-id' }
+  }
+  const agentState = getInitialSessionState(mockFileContext).mainAgentState
+  agentState.messageHistory = []
+  await processStream({
+    ...TEST_AGENT_RUNTIME_IMPL,
+    sendAction: () => {},
+    agentContext: {},
+    agentState,
+    agentStepId: 'test-step-id',
+    agentTemplate: template,
+    ancestorRunIds: [],
+    clientSessionId: 'test-session',
+    fileContext: mockFileContext,
+    fingerprintId: 'test-fingerprint',
+    fullResponse: '',
+    localAgentTemplates: { 'test-agent': template },
+    messages: agentState.messageHistory,
+    prompt: 'test prompt',
+    repoId: undefined,
+    repoUrl: undefined,
+    runId: 'test-run-id',
+    signal: new AbortController().signal,
+    stream: stream(),
+    system: 'test system',
+    tools: {},
+    userId: 'test-user',
+    userInputId: 'test-input-id',
+    streamFinishReason: () => 'tool_calls',
+    onCostCalculated: async () => {},
+    onResponseChunk: () => {},
+  })
+  return agentState.messageHistory.flatMap((message) =>
+    message.role === 'assistant' && Array.isArray(message.content)
+      ? message.content.filter((part) => part.type === 'tool-call')
+      : [],
+  )
+}
+
+describe('processStream — tool-call provider metadata', () => {
+  it('stores the metadata a tool call arrived with on its history part', async () => {
+    const providerOptions = {
+      byok: {
+        extra_content: { google: { thought_signature: 'sig-A' } },
+        model: 'gemini-3.5-flash-lite',
+      },
+    }
+    const calls = await historyAfter([
+      {
+        type: 'tool-call',
+        toolCallId: 'provider-id',
+        toolName: 'end_turn',
+        input: {},
+        providerOptions,
+      },
+    ])
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).toMatchObject({ toolName: 'end_turn', providerOptions })
+  })
+
+  it('adds no metadata to a call that had none', async () => {
+    const calls = await historyAfter([
+      { type: 'tool-call', toolCallId: 'c1', toolName: 'end_turn', input: {} },
+    ])
+    expect(calls).toHaveLength(1)
+    expect(calls[0]).not.toHaveProperty('providerOptions')
+  })
+})

packages/agent-runtime/src/tool-stream-parser.ts

@@ -5,6 +5,7 @@ import {
 
 import type { StreamParserState } from './util/stream-xml-parser'
 import type { StreamChunk } from '@codebuff/common/types/contracts/llm'
+import type { ProviderMetadata } from '@codebuff/common/types/messages/provider-metadata'
 import type {
   PrintModeError,
   PrintModeText,
@@ -23,6 +24,7 @@ export async function* processStreamWithTools(params: {
       onTagEnd: (
         tagName: string,
         params: Record<string, any>,
+        providerOptions?: ProviderMetadata,
       ) => void | Promise<void>
     }
   >
@@ -34,6 +36,7 @@ export async function* processStreamWithTools(params: {
     onTagEnd: (
       tagName: string,
       params: Record<string, any>,
+      providerOptions?: ProviderMetadata,
     ) => void | Promise<void>
   }
   onResponseChunk: (chunk: PrintModeText | PrintModeError) => void
@@ -59,8 +62,9 @@ export async function* processStreamWithTools(params: {
   async function processToolCallObject(params: {
     toolName: string
     input: any
+    providerOptions?: ProviderMetadata
   }): Promise<void> {
-    const { toolName } = params
+    const { toolName, providerOptions } = params
     let { input } = params
 
     // AI SDK sometimes emits tool-call chunks with a raw JSON string as `input`
@@ -75,7 +79,7 @@ export async function* processStreamWithTools(params: {
     const processor = processors[toolName] ?? defaultProcessor(toolName)
 
     await processor.onTagStart(toolName, {})
-    await processor.onTagEnd(toolName, input)
+    await processor.onTagEnd(toolName, input, providerOptions)
   }
 
   function flush() {

packages/agent-runtime/src/tools/stream-parser.ts

@@ -36,6 +36,7 @@ import type {
   Message,
   ToolMessage,
 } from '@codebuff/common/types/messages/codebuff-message'
+import type { ProviderMetadata } from '@codebuff/common/types/messages/provider-metadata'
 import type { PrintModeEvent } from '@codebuff/common/types/print-mode'
 import type { Subgoal } from '@codebuff/common/types/session-state'
 import type { ProjectFileContext } from '@codebuff/common/util/file'
@@ -243,6 +244,10 @@ export async function processStream(
   const toolResultsToAddToMessageHistory: ToolMessage[] = []
   const toolCalls: (CodebuffToolCall | CustomToolCall)[] = []
   const toolCallsToAddToMessageHistory: (CodebuffToolCall | CustomToolCall)[] = []
+  // The provider metadata each native tool call arrived with (e.g. Gemini's
+  // thought signature), stored on its history part so the next request can
+  // replay it. Kept off the tool call itself, which also reaches clients.
+  const toolCallProviderOptions = new Map<string, ProviderMetadata>()
   const assistantMessages: Message[] = []
   // Inline agents replace the parent's history with their result. Track which
   // current-step messages they inherited so finalization does not append them
@@ -296,7 +301,11 @@ export async function processStream(
     const responseHandler = createResponseHandler()
     return {
       onTagStart: () => { },
-      onTagEnd: async (_: string, input: Record<string, string>) => {
+      onTagEnd: async (
+        _: string,
+        input: Record<string, string>,
+        providerOptions?: ProviderMetadata,
+      ) => {
         sawToolCall = true
         if (signal.aborted || followupSuggestionLimitHit) {
           return
@@ -325,6 +334,9 @@ export async function processStream(
           }
         }
         const toolCallId = generateCompactId()
+        if (providerOptions) {
+          toolCallProviderOptions.set(toolCallId, providerOptions)
+        }
         const isNativeTool = toolNames.includes(toolName as ToolName)
 
         // Check if this is an agent tool call that should be transformed to spawn_agents
@@ -743,7 +755,14 @@ export async function processStream(
       ...assistantMessages.filter(
         (message) => !claimedByInlineAgent.has(message),
       ),
-      ...filteredToolCalls.map((toolCall) => assistantMessage({ ...toolCall, type: 'tool-call' })),
+      ...filteredToolCalls.map((toolCall) => {
+        const providerOptions = toolCallProviderOptions.get(toolCall.toolCallId)
+        return assistantMessage({
+          ...toolCall,
+          type: 'tool-call',
+          ...(providerOptions ? { providerOptions } : {}),
+        })
+      }),
       ...toolResultsToAddToMessageHistory,
       ...errorMessages,
     ])

packages/llm-providers/src/openai-compatible/chat/convert-to-openai-compatible-chat-messages.ts

@@ -14,6 +14,31 @@ function getOpenAIMetadata(message: {
   return message?.providerOptions?.openaiCompatible ?? {}
 }
 
+/**
+ * The `extra_content` a tool call arrived with (Gemini's thought signature),
+ * when it was captured under this provider's name for this same model.
+ * Signatures are only valid for the model that produced them.
+ */
+function replayableExtraContent(
+  part: { providerOptions?: SharedV2ProviderMetadata },
+  options: { providerOptionsName?: string; modelId?: string } | undefined,
+): JSONValue | undefined {
+  if (!options?.providerOptionsName) return undefined
+  const namespace = part.providerOptions?.[options.providerOptionsName]
+  const extraContent = namespace?.extra_content
+  if (
+    extraContent == null ||
+    typeof extraContent !== 'object' ||
+    Array.isArray(extraContent)
+  ) {
+    return undefined
+  }
+  if (options.modelId !== undefined && namespace?.model !== options.modelId) {
+    return undefined
+  }
+  return extraContent
+}
+
 /** Approximate payload size of a file part's data, for placeholder text. */
 function filePartByteLength(data: unknown): number {
   let value = data
@@ -137,6 +162,7 @@ export function convertToOpenAICompatibleChatMessages(
           id: string
           type: 'function'
           function: { name: string; arguments: string }
+          extra_content?: JSONValue
         }> = []
 
         for (const part of content) {
@@ -173,13 +199,17 @@ export function convertToOpenAICompatibleChatMessages(
               break
             }
             case 'tool-call': {
+              const extraContent = replayableExtraContent(part, options)
               toolCalls.push({
                 id: part.toolCallId,
                 type: 'function',
                 function: {
                   name: part.toolName,
                   arguments: JSON.stringify(part.input),
                 },
+                ...(extraContent !== undefined
+                  ? { extra_content: extraContent }
+                  : {}),
                 ...partMetadata,
               })
               break

packages/llm-providers/src/openai-compatible/chat/openai-compatible-chat-language-model.ts

@@ -288,6 +288,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
           toolCallId: toolCall.id ?? generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments!,
+          ...toolCallExtraContentMetadata(
+            toolCall.extra_content,
+            this.providerOptionsName,
+            this.modelId,
+          ),
         })
       }
     }
@@ -376,6 +381,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
         name: string
         arguments: string
       }
+      extraContent?: unknown
       hasFinished: boolean
     }> = []
 
@@ -606,6 +612,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                       name: toolCallDelta.function.name,
                       arguments: toolCallDelta.function.arguments ?? '',
                     },
+                    extraContent: toolCallDelta.extra_content ?? undefined,
                     hasFinished: false,
                   }
 
@@ -637,6 +644,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                         toolCallId: toolCall.id ?? generateId(),
                         toolName: toolCall.function.name,
                         input: toolCall.function.arguments,
+                        ...toolCallExtraContentMetadata(
+                          toolCall.extraContent,
+                          providerOptionsName,
+                          modelId,
+                        ),
                       })
                       toolCall.hasFinished = true
                     }
@@ -652,6 +664,10 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                   continue
                 }
 
+                if (toolCallDelta.extra_content != null) {
+                  toolCall.extraContent = toolCallDelta.extra_content
+                }
+
                 if (toolCallDelta.function?.arguments != null) {
                   toolCall.function!.arguments +=
                     toolCallDelta.function?.arguments ?? ''
@@ -680,6 +696,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                     toolCallId: toolCall.id ?? generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments,
+                    ...toolCallExtraContentMetadata(
+                      toolCall.extraContent,
+                      providerOptionsName,
+                      modelId,
+                    ),
                   })
                   toolCall.hasFinished = true
                 }
@@ -730,6 +751,11 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
                 toolCallId: toolCall.id ?? generateId(),
                 toolName: toolCall.function.name,
                 input: toolCall.function.arguments,
+                ...toolCallExtraContentMetadata(
+                  toolCall.extraContent,
+                  providerOptionsName,
+                  modelId,
+                ),
               })
             }
 
@@ -773,6 +799,32 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
   }
 }
 
+/**
+ * A tool call's `extra_content`, kept so the next request can send it back.
+ * Gemini 3's OpenAI-compatible endpoint puts the call's thought signature at
+ * `extra_content.google.thought_signature` and refuses (HTTP 400) a follow-up
+ * whose replayed call lacks it. Like `reasoning_details`, it is tagged with
+ * the model that produced it and only replayed to that model.
+ */
+function toolCallExtraContentMetadata(
+  extraContent: unknown,
+  providerOptionsName: string,
+  modelId: string,
+): { providerMetadata?: SharedV2ProviderMetadata } {
+  if (
+    extraContent == null ||
+    typeof extraContent !== 'object' ||
+    Array.isArray(extraContent)
+  ) {
+    return {}
+  }
+  return {
+    providerMetadata: {
+      [providerOptionsName]: { extra_content: extraContent, model: modelId },
+    } as SharedV2ProviderMetadata,
+  }
+}
+
 /**
  * The slot of a streamed tool-call delta that carries no `index`. OpenAI
  * always sends one, but several OpenAI-compatible servers and proxies do not
@@ -848,6 +900,7 @@ const OpenAICompatibleChatResponseSchema = z.object({
                 name: z.string(),
                 arguments: z.string(),
               }),
+              extra_content: z.unknown().nullish(),
             }),
           )
           .nullish(),
@@ -908,6 +961,7 @@ const createOpenAICompatibleChatChunkSchema = <
                       name: z.string().nullish(),
                       arguments: z.string().nullish(),
                     }),
+                    extra_content: z.unknown().nullish(),
                   }),
                 )
                 .nullish(),