fix(agent-sdk): support Gemini multi-turn tool calling via thought_signature

Preserve thought_signature across streaming and history replay, normalize AIGW tool names, prevent unknown placeholder tool loops, and add AIGW trace headers for gemini-3.5-flash.

Author: 刘宇阳

packages/agent-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

packages/agent-sdk/src/managers/aiManager.ts

@@ -5,6 +5,11 @@ import {
 } from "../services/aiService.js";
 import { getMessagesToCompress } from "../utils/messageOperations.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
+import {
+  extractToolCallMetadata,
+  isValidToolCallName,
+  normalizeToolCallName,
+} from "../utils/toolCallMetadata.js";
 import { calculateComprehensiveTotalTokens } from "../utils/tokenCalculation.js";
 import * as memory from "../services/memory.js";
 import * as fs from "node:fs/promises";
@@ -583,6 +588,19 @@ export class AIManager {
         }
       }
 
+      for (const toolCall of toolCalls) {
+        const metadata = extractToolCallMetadata(
+          toolCall as unknown as Record<string, unknown>,
+        );
+        if (metadata && toolCall.id) {
+          this.messageManager.updateToolBlock({
+            id: toolCall.id,
+            parameters: toolCall.function.arguments || "{}",
+            toolCallMetadata: metadata,
+          });
+        }
+      }
+
       if (result.finish_reason === "length" && toolCalls.length === 0) {
         this.messageManager.addErrorBlock(
           "AI response was truncated due to length limit. Please try to reduce the complexity of your request or split it into smaller parts.",
@@ -603,7 +621,23 @@ export class AIManager {
               return;
             }
 
-            const toolName = functionToolCall.function?.name || "";
+            const toolName = normalizeToolCallName(
+              functionToolCall.function?.name,
+            );
+            if (!isValidToolCallName(toolName)) {
+              const skipMessage =
+                "Skipped tool execution: model returned an empty or invalid tool name.";
+              this.logger?.warn(skipMessage, { toolId });
+              this.messageManager.updateToolBlock({
+                id: toolId,
+                parameters: functionToolCall.function?.arguments || "{}",
+                result: skipMessage,
+                success: false,
+                error: skipMessage,
+                stage: "end",
+              });
+              return;
+            }
             // Safely parse tool parameters, handle tools without parameters
             let toolArgs: Record<string, unknown> = {};
             const argsString = functionToolCall.function?.arguments?.trim();
@@ -678,7 +712,7 @@ export class AIManager {
 
               // Execute tool
               const toolResult = await this.toolManager.execute(
-                functionToolCall.function?.name || "",
+                toolName,
                 toolArgs,
                 context,
               );

packages/agent-sdk/src/managers/liveConfigManager.ts

@@ -19,7 +19,7 @@ import type { PermissionManager } from "./permissionManager.js";
 import {
   getProjectConfigPaths,
   getUserConfigPaths,
-} from "@/utils/configPaths.js";
+} from "../utils/configPaths.js";
 import type { HookValidationResult } from "../types/hooks.js";
 import { isValidHookEvent, isValidHookEventConfig } from "../types/hooks.js";
 import { ConfigurationService } from "../services/configurationService.js";

packages/agent-sdk/src/managers/mcpManager.ts

@@ -3,7 +3,7 @@ import { join } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ChatCompletionFunctionTool } from "openai/resources.js";
-import { createMcpToolPlugin, findToolServer } from "@/utils/mcpUtils.js";
+import { createMcpToolPlugin, findToolServer } from "../utils/mcpUtils.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
 import type {
   Logger,

packages/agent-sdk/src/managers/messageManager.ts

@@ -358,6 +358,7 @@ export class MessageManager {
       images: params.images,
       compactParams: params.compactParams,
       parametersChunk: params.parametersChunk,
+      toolCallMetadata: params.toolCallMetadata,
     });
     this.setMessages(newMessages);
     this.callbacks.onToolBlockUpdated?.(params);

packages/agent-sdk/src/services/aiService.ts

@@ -16,6 +16,12 @@ import {
   extendUsageWithCacheMetrics,
   type ClaudeUsage,
 } from "../utils/cacheControlUtils.js";
+import {
+  extractToolCallMetadata,
+  mergeToolCallMetadata,
+  applyToolCallMetadataToResult,
+  normalizeToolCallName,
+} from "../utils/toolCallMetadata.js";
 
 import * as os from "os";
 import * as fs from "fs";
@@ -94,13 +100,7 @@ function isGitRepository(dirPath: string): string {
 type OpenAIModelConfig = Omit<
   ChatCompletionCreateParamsNonStreaming,
   "messages"
-> & {
-  vertexai?: {
-    thinking_config: {
-      thinking_level: string;
-    };
-  };
-};
+>;
 
 /**
  * Get specific configuration parameters based on model name
@@ -124,14 +124,6 @@ function getModelConfig(
     config.temperature = undefined;
   }
 
-  if (modelName.startsWith("gemini-3")) {
-    config.vertexai = {
-      thinking_config: {
-        thinking_level: "minimal",
-      },
-    };
-  }
-
   return config;
 }
 
@@ -337,9 +329,9 @@ Today's date: ${new Date().toISOString().split("T")[0]}
       const resolvedMaxTokens = options.maxTokens ?? modelConfig.maxTokens;
 
       processedTools = tools;
-      console.log("当前采用的模型为", currentModel);
+      // console.log("当前采用的模型为", currentModel);
       if (isClaudeModel(currentModel)) {
-        console.log("走到了claude的处理", currentModel);
+        // console.log("走到了claude的处理", currentModel);
         openaiMessages = transformMessagesForClaudeCache(
           openaiMessages,
           currentModel,
@@ -423,7 +415,7 @@ Today's date: ${new Date().toISOString().split("T")[0]}
 
         if (!response?.choices?.[0]?.message) {
           console.error("callAgent 返回为空-原始 responese", response);
-          console.error("callAgent 返回为空-请求 messages", openaiMessages);
+          // console.error("callAgent 返回为空-请求 messages", openaiMessages);
           const errorMessage =
             (response as unknown as { error?: { message?: string } })?.error
               ?.message || "No response from AI";
@@ -659,6 +651,7 @@ async function processStreamingResponse(
       arguments: string;
     };
   }[] = [];
+  const toolCallMetadataById = new Map<string, Record<string, unknown>>();
   const additionalDeltaFields: Record<string, unknown> = {};
   let usage: CallAgentResult["usage"] = undefined;
   let finishReason: CallAgentResult["finish_reason"] = null;
@@ -740,11 +733,19 @@ async function processStreamingResponse(
           const toolCallDelta =
             rawToolCall as ChatCompletionChunk.Choice.Delta.ToolCall;
 
-          if (!toolCallDelta.function) {
+          const deltaMetadata = extractToolCallMetadata(
+            rawToolCall as unknown as Record<string, unknown>,
+          );
+
+          const rawRecord = rawToolCall as unknown as Record<string, unknown>;
+          const topLevelName =
+            typeof rawRecord.name === "string" ? rawRecord.name : undefined;
+
+          if (!toolCallDelta.function && !topLevelName) {
             continue;
           }
 
-          const functionDelta = toolCallDelta.function;
+          const functionDelta = toolCallDelta.function ?? {};
 
           let existingCall;
           let isNew = false;
@@ -756,7 +757,9 @@ async function processStreamingResponse(
                 id: toolCallDelta.id,
                 type: "function" as const,
                 function: {
-                  name: functionDelta.name || "",
+                  name: normalizeToolCallName(
+                    functionDelta.name || topLevelName,
+                  ),
                   arguments: "",
                 },
               };
@@ -771,32 +774,56 @@ async function processStreamingResponse(
             continue;
           }
 
-          if (functionDelta.name) {
-            existingCall.function.name = functionDelta.name;
+          if (deltaMetadata) {
+            const callId = existingCall.id || toolCallDelta.id;
+            if (callId) {
+              toolCallMetadataById.set(
+                callId,
+                mergeToolCallMetadata(
+                  toolCallMetadataById.get(callId),
+                  deltaMetadata,
+                )!,
+              );
+            }
           }
 
-          // Emit start stage when a new tool call is created and we have the tool name
-          if (onToolUpdate && isNew && existingCall.function.name) {
+          const previousName = existingCall.function.name;
+          const resolvedName = normalizeToolCallName(
+            functionDelta.name || topLevelName || previousName,
+          );
+          if (resolvedName) {
+            existingCall.function.name = resolvedName;
+          }
+
+          const nameJustResolved =
+            !normalizeToolCallName(previousName) &&
+            Boolean(existingCall.function.name);
+
+          // Emit start when a tool call first gets a resolvable name
+          if (
+            onToolUpdate &&
+            existingCall.function.name &&
+            (isNew || nameJustResolved)
+          ) {
             onToolUpdate({
               id: existingCall.id,
               name: existingCall.function.name,
-              parameters: "", // Empty parameters for start stage
-              parametersChunk: "", // Empty chunk for start stage
-              stage: "start", // New tool call triggers start stage
+              parameters: "",
+              parametersChunk: "",
+              stage: "start",
             });
-            isNew = false; // Prevent duplicate start emissions
+            isNew = false;
           }
 
           if (functionDelta.arguments) {
             existingCall.function.arguments += functionDelta.arguments;
           }
 
-          // Emit streaming updates for all chunks with actual content (including first chunk)
           if (
             onToolUpdate &&
             existingCall.function.name &&
             functionDelta.arguments &&
-            functionDelta.arguments.length > 0 // Only emit streaming for chunks with actual content
+            functionDelta.arguments.length > 0
           ) {
             onToolUpdate({
               id: existingCall.id,
@@ -828,7 +855,14 @@ async function processStreamingResponse(
   }
 
   if (toolCalls.length > 0) {
-    result.tool_calls = toolCalls;
+    result.tool_calls = toolCalls
+      .filter((toolCall) => normalizeToolCallName(toolCall.function.name))
+      .map((toolCall) =>
+        applyToolCallMetadataToResult(
+          toolCall,
+          toolCallMetadataById.get(toolCall.id),
+        ),
+      );
   }
 
   if (usage) {

packages/agent-sdk/src/tools/lsTool.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { minimatch } from "minimatch";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { isBinary, getDisplayPath } from "@/utils/path.js";
+import { isBinary, getDisplayPath } from "../utils/path.js";
 import {
   LS_TOOL_NAME,
   GLOB_TOOL_NAME,

packages/agent-sdk/src/types/messaging.ts

@@ -65,6 +65,8 @@ export interface ToolBlock {
   error?: string | Error;
   compactParams?: string; // Compact parameter display
   parametersChunk?: string; // Incremental parameter updates for streaming
+  /** Extra fields from API tool_calls (e.g. thought_signature for Gemini 3) */
+  toolCallMetadata?: Record<string, unknown>;
 }
 
 export interface ImageBlock {