@tanstack/ai-gemini 0.17.3 → 0.18.2

package/dist/esm/experimental/text-interactions/adapter.js

@@ -1,5 +1,6 @@
 import { EventType } from "@tanstack/ai";
 import { BaseTextAdapter } from "@tanstack/ai/adapters";
+import { parse } from "partial-json";
 import { createGeminiClient, generateId, getGeminiApiKeyFromEnv } from "../../utils/client.js";
 class GeminiTextInteractionsAdapter extends BaseTextAdapter {
   kind = "text";
@@ -130,8 +131,11 @@ class GeminiTextInteractionsAdapter extends BaseTextAdapter {
     });
     const request = {
       ...baseRequest,
-      response_mime_type: "application/json",
-      response_format: outputSchema
+      response_format: {
+        type: "text",
+        mime_type: "application/json",
+        schema: outputSchema
+      }
     };
     try {
       logger.request(
@@ -201,8 +205,7 @@ function buildInteractionsRequest(options) {
     store: modelOpts?.store,
     background: modelOpts?.background,
     response_modalities: modelOpts?.response_modalities,
-    response_format: modelOpts?.response_format,
-    response_mime_type: modelOpts?.response_mime_type
+    response_format: modelOpts?.response_format
   };
 }
 function convertMessagesToInteractionsInput(messages, hasPreviousInteraction) {
@@ -297,21 +300,13 @@ function messagesAfterLastAssistant(messages) {
   }
   return messages;
 }
-function safeParseToolArguments(raw, logger) {
-  if (!raw) return {};
+function parsePartialToolArguments(raw) {
+  if (!raw) return void 0;
   try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch (error) {
-    logger.errors(
-      "gemini-text-interactions.safeParseToolArguments parse failed",
-      {
-        error,
-        raw,
-        source: "gemini-text-interactions.chatStream"
-      }
-    );
-    return {};
+    const parsed = parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
 }
 const IMAGE_MIME_TYPES = [
@@ -492,6 +487,8 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
   let thinkingAccumulated = "";
   let reasoningMessageId = null;
   let hasClosedReasoning = false;
+  const indexToToolCallId = /* @__PURE__ */ new Map();
+  const argStringByToolCallId = /* @__PURE__ */ new Map();
   const closeReasoningIfNeeded = function* () {
     if (reasoningMessageId && !hasClosedReasoning) {
       hasClosedReasoning = true;
@@ -552,82 +549,132 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
   for await (const event of stream) {
     logger.provider(`provider=gemini-text-interactions`, { event });
     switch (event.event_type) {
-      case "interaction.start": {
+      case "interaction.created": {
         interactionId = event.interaction.id;
         yield* emitRunStartedIfNeeded();
         break;
       }
-      case "content.start": {
+      case "step.start": {
         yield* emitRunStartedIfNeeded();
-        break;
-      }
-      case "content.delta": {
-        yield* emitRunStartedIfNeeded();
-        const delta = event.delta;
-        switch (delta.type) {
-          case "text": {
+        const step = event.step;
+        const index = event.index;
+        switch (step.type) {
+          case "function_call": {
             yield* closeReasoningIfNeeded();
-            if (!hasEmittedTextMessageStart) {
-              hasEmittedTextMessageStart = true;
+            sawFunctionCall = true;
+            const toolCallId = step.id;
+            indexToToolCallId.set(index, toolCallId);
+            const initialArgs = step.arguments;
+            const state = {
+              name: step.name,
+              args: { ...initialArgs },
+              index: nextToolIndex++,
+              started: true,
+              ended: false
+            };
+            toolCalls.set(toolCallId, state);
+            argStringByToolCallId.set(
+              toolCallId,
+              Object.keys(initialArgs).length > 0 ? JSON.stringify(initialArgs) : ""
+            );
+            yield {
+              type: EventType.TOOL_CALL_START,
+              toolCallId,
+              toolCallName: state.name,
+              toolName: state.name,
+              // Bind the tool call to the same assistant message id the
+              // eventual TEXT_MESSAGE_START uses so the message id stays
+              // stable when a function_call arrives before any text (#477).
+              parentMessageId: messageId,
+              model,
+              timestamp,
+              index: state.index
+            };
+            if (Object.keys(initialArgs).length > 0) {
+              const argsJson = JSON.stringify(initialArgs);
               yield {
-                type: EventType.TEXT_MESSAGE_START,
-                messageId,
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId,
                 model,
                 timestamp,
-                role: "assistant"
+                delta: argsJson,
+                args: argsJson
               };
             }
-            textAccumulated += delta.text;
-            yield {
-              type: EventType.TEXT_MESSAGE_CONTENT,
-              messageId,
-              model,
-              timestamp,
-              delta: delta.text,
-              content: textAccumulated
-            };
             break;
           }
-          case "function_call": {
-            yield* closeReasoningIfNeeded();
-            sawFunctionCall = true;
-            const toolCallId = delta.id;
-            const deltaArgs = typeof delta.arguments === "string" ? safeParseToolArguments(delta.arguments, logger) : delta.arguments;
-            let state = toolCalls.get(toolCallId);
-            if (!state) {
-              state = {
-                name: delta.name,
-                args: { ...deltaArgs },
-                index: nextToolIndex++,
-                started: false,
-                ended: false
+          case "thought": {
+            if (thinkingStepId === null || reasoningMessageId === null) {
+              thinkingStepId = generateId(adapterName);
+              reasoningMessageId = generateId(adapterName);
+              yield {
+                type: EventType.REASONING_START,
+                messageId: reasoningMessageId,
+                model,
+                timestamp
+              };
+              yield {
+                type: EventType.REASONING_MESSAGE_START,
+                messageId: reasoningMessageId,
+                role: "reasoning",
+                model,
+                timestamp
+              };
+              yield {
+                type: EventType.STEP_STARTED,
+                stepName: thinkingStepId,
+                stepId: thinkingStepId,
+                model,
+                timestamp,
+                stepType: "thinking"
               };
-              toolCalls.set(toolCallId, state);
-            } else {
-              state.args = { ...state.args, ...deltaArgs };
-              if (delta.name) state.name = delta.name;
             }
-            if (!state.started) {
-              state.started = true;
+            for (const part of step.summary ?? []) {
+              if (part.type !== "text" || !part.text) continue;
+              thinkingAccumulated += part.text;
               yield {
-                type: EventType.TOOL_CALL_START,
-                toolCallId,
-                toolCallName: state.name,
-                toolName: state.name,
-                parentMessageId: messageId,
+                type: EventType.REASONING_MESSAGE_CONTENT,
+                messageId: reasoningMessageId,
+                delta: part.text,
+                model,
+                timestamp
+              };
+              yield {
+                type: EventType.STEP_FINISHED,
+                stepName: thinkingStepId,
+                stepId: thinkingStepId,
                 model,
                 timestamp,
-                index: state.index
+                delta: part.text,
+                content: thinkingAccumulated
+              };
+            }
+            break;
+          }
+          case "model_output": {
+            yield* closeReasoningIfNeeded();
+            for (const part of step.content ?? []) {
+              if (part.type !== "text" || !part.text) continue;
+              if (!hasEmittedTextMessageStart) {
+                hasEmittedTextMessageStart = true;
+                yield {
+                  type: EventType.TEXT_MESSAGE_START,
+                  messageId,
+                  model,
+                  timestamp,
+                  role: "assistant"
+                };
+              }
+              textAccumulated += part.text;
+              yield {
+                type: EventType.TEXT_MESSAGE_CONTENT,
+                messageId,
+                model,
+                timestamp,
+                delta: part.text,
+                content: textAccumulated
               };
             }
-            yield {
-              type: EventType.TOOL_CALL_ARGS,
-              toolCallId,
-              model,
-              timestamp,
-              delta: JSON.stringify(deltaArgs),
-              args: JSON.stringify(state.args)
-            };
             break;
           }
           case "google_search_call": {
@@ -635,7 +682,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.googleSearchCall",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -646,7 +693,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.googleSearchResult",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -657,7 +704,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.codeExecutionCall",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -668,7 +715,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.codeExecutionResult",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -679,7 +726,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.urlContextCall",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -690,7 +737,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.urlContextResult",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -701,7 +748,7 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.fileSearchCall",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
@@ -712,12 +759,83 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             yield {
               type: EventType.CUSTOM,
               name: "gemini.fileSearchResult",
-              value: delta,
+              value: step,
               model,
               timestamp
             };
             break;
           }
+          // Unhandled step types (user_input on GET timelines,
+          // mcp_server_*, google_maps_*, function_result) fall through
+          // to the observability default so SDK drift is visible.
+          case "user_input":
+          case "mcp_server_tool_call":
+          case "mcp_server_tool_result":
+          case "google_maps_call":
+          case "google_maps_result":
+          case "function_result":
+          default:
+            logger.provider(`gemini-text-interactions unhandled step.start`, {
+              step
+            });
+            break;
+        }
+        break;
+      }
+      case "step.delta": {
+        yield* emitRunStartedIfNeeded();
+        const delta = event.delta;
+        const index = event.index;
+        switch (delta.type) {
+          case "text": {
+            yield* closeReasoningIfNeeded();
+            if (!hasEmittedTextMessageStart) {
+              hasEmittedTextMessageStart = true;
+              yield {
+                type: EventType.TEXT_MESSAGE_START,
+                messageId,
+                model,
+                timestamp,
+                role: "assistant"
+              };
+            }
+            textAccumulated += delta.text;
+            yield {
+              type: EventType.TEXT_MESSAGE_CONTENT,
+              messageId,
+              model,
+              timestamp,
+              delta: delta.text,
+              content: textAccumulated
+            };
+            break;
+          }
+          case "arguments_delta": {
+            const toolCallId = indexToToolCallId.get(index);
+            if (!toolCallId) {
+              logger.provider(
+                `gemini-text-interactions arguments_delta for unknown step index`,
+                { index, delta }
+              );
+              break;
+            }
+            const state = toolCalls.get(toolCallId);
+            if (!state) break;
+            const fragment = delta.arguments ?? "";
+            const buffer = (argStringByToolCallId.get(toolCallId) ?? "") + fragment;
+            argStringByToolCallId.set(toolCallId, buffer);
+            const parsed = parsePartialToolArguments(buffer);
+            if (parsed) state.args = parsed;
+            yield {
+              type: EventType.TOOL_CALL_ARGS,
+              toolCallId,
+              model,
+              timestamp,
+              delta: fragment,
+              args: buffer
+            };
+            break;
+          }
           case "thought_summary": {
             const thoughtText = delta.content && "text" in delta.content ? delta.content.text : "";
             if (!thoughtText) break;
@@ -765,33 +883,62 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
             };
             break;
           }
-          // The following delta types are valid per the SDK type union
-          // but aren't yet translated by this adapter (output modalities
-          // text-only adapter shouldn't see, response-side function_result
-          // / mcp_server_*, thought_signature). Falling through to the
-          // observability default so SDK drift is visible.
+          // The remaining StepDelta variants (image/audio/video/document
+          // for output modalities a text adapter shouldn't see, tool
+          // call/result deltas which are surfaced via step.start in this
+          // adapter, thought_signature, annotation deltas, mcp/google
+          // maps variants) fall through to the observability default.
           case "image":
           case "audio":
           case "video":
           case "document":
-          case "function_result":
+          case "thought_signature":
+          case "text_annotation_delta":
+          case "code_execution_call":
+          case "code_execution_result":
+          case "url_context_call":
+          case "url_context_result":
+          case "google_search_call":
+          case "google_search_result":
+          case "file_search_call":
+          case "file_search_result":
           case "mcp_server_tool_call":
           case "mcp_server_tool_result":
-          case "thought_signature":
+          case "google_maps_call":
+          case "google_maps_result":
+          case "function_result":
           default:
             logger.provider(
-              `gemini-text-interactions unhandled content.delta type`,
+              `gemini-text-interactions unhandled step.delta type`,
               { delta }
             );
             break;
         }
         break;
       }
-      case "content.stop":
+      case "step.stop": {
+        const toolCallId = indexToToolCallId.get(event.index);
+        if (toolCallId) {
+          const state = toolCalls.get(toolCallId);
+          if (state && !state.ended) {
+            state.ended = true;
+            yield {
+              type: EventType.TOOL_CALL_END,
+              toolCallId,
+              toolName: state.name,
+              model,
+              timestamp,
+              input: state.args
+            };
+          }
+          indexToToolCallId.delete(event.index);
+        }
+        break;
+      }
       case "interaction.status_update": {
         break;
       }
-      case "interaction.complete": {
+      case "interaction.completed": {
         if (event.interaction.id) {
           interactionId = event.interaction.id;
         }
@@ -871,10 +1018,16 @@ async function* translateInteractionEvents(stream, model, runId, threadId, paren
   yield* closeOpenState();
 }
 function extractTextFromInteraction(interaction) {
+  if (typeof interaction.output_text === "string" && interaction.output_text) {
+    return interaction.output_text;
+  }
   let text = "";
-  for (const output of interaction.outputs ?? []) {
-    if (output.type === "text") {
-      text += output.text;
+  for (const step of interaction.steps) {
+    if (step.type !== "model_output" || !step.content) continue;
+    for (const part of step.content) {
+      if (part.type === "text") {
+        text += part.text;
+      }
     }
   }
   return text;