@tanstack/ai-gemini 0.17.2 → 0.18.1

package/dist/esm/adapters/text.js

@@ -1,658 +0,0 @@
-import { FinishReason } from "@google/genai";
-import { EventType, normalizeSystemPrompts } from "@tanstack/ai";
-import { toRunErrorRawEvent } from "@tanstack/ai/adapter-internals";
-import { BaseTextAdapter } from "@tanstack/ai/adapters";
-import { convertToolsToProviderFormat } from "../tools/tool-converter.js";
-import { buildGeminiUsage } from "../usage.js";
-import { createGeminiClient, generateId, getGeminiApiKeyFromEnv } from "../utils/client.js";
-import { GEMINI_COMBINED_TOOLS_AND_SCHEMA_MODELS } from "../model-meta.js";
-class GeminiTextAdapter extends BaseTextAdapter {
-  kind = "text";
-  name = "gemini";
-  client;
-  constructor(config, model) {
-    super({}, model);
-    this.client = createGeminiClient(config);
-  }
-  async *chatStream(options) {
-    const mappedOptions = this.mapCommonOptionsToGemini(options);
-    const { logger } = options;
-    try {
-      logger.request(
-        `activity=chat provider=gemini model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
-        { provider: "gemini", model: this.model }
-      );
-      const result = await this.client.models.generateContentStream(mappedOptions);
-      yield* this.processStreamChunks(result, options, logger);
-    } catch (error) {
-      const rawEvent = toRunErrorRawEvent(error);
-      logger.errors("gemini.chatStream fatal", {
-        error,
-        source: "gemini.chatStream"
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        model: options.model,
-        timestamp: Date.now(),
-        message: error instanceof Error ? error.message : "An unknown error occurred during the chat stream.",
-        // Forward the provider's structured error body when present (see
-        // toRunErrorRawEvent); omitted otherwise.
-        ...rawEvent !== void 0 && { rawEvent },
-        error: {
-          message: error instanceof Error ? error.message : "An unknown error occurred during the chat stream."
-        }
-      };
-    }
-  }
-  /**
-   * Generate structured output using Gemini's native JSON response format.
-   * Uses responseMimeType: 'application/json' and responseSchema for structured output.
-   * The outputSchema is already JSON Schema (converted in the ai layer).
-   */
-  async structuredOutput(options) {
-    const { chatOptions, outputSchema } = options;
-    const { logger } = chatOptions;
-    const mappedOptions = this.mapCommonOptionsToGemini(chatOptions);
-    try {
-      logger.request(
-        `activity=chat provider=gemini model=${this.model} messages=${chatOptions.messages.length} tools=${chatOptions.tools?.length ?? 0} stream=false`,
-        { provider: "gemini", model: this.model }
-      );
-      const result = await this.client.models.generateContent({
-        ...mappedOptions,
-        config: {
-          ...mappedOptions.config,
-          responseMimeType: "application/json",
-          responseSchema: outputSchema
-        }
-      });
-      const rawText = this.extractTextFromResponse(result);
-      let parsed;
-      try {
-        parsed = JSON.parse(rawText);
-      } catch {
-        throw new Error(
-          `Failed to parse structured output as JSON. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? "..." : ""}`
-        );
-      }
-      return {
-        data: parsed,
-        rawText,
-        usage: result.usageMetadata ? buildGeminiUsage(result.usageMetadata) : void 0
-      };
-    } catch (error) {
-      logger.errors("gemini.structuredOutput fatal", {
-        error,
-        source: "gemini.structuredOutput"
-      });
-      throw new Error(
-        error instanceof Error ? error.message : "An unknown error occurred during structured output generation."
-      );
-    }
-  }
-  /**
-   * Extract text content from a non-streaming response
-   */
-  extractTextFromResponse(response) {
-    let textContent = "";
-    if (response.candidates?.[0]?.content?.parts) {
-      for (const part of response.candidates[0].content.parts) {
-        if (part.text) {
-          textContent += part.text;
-        }
-      }
-    }
-    return textContent;
-  }
-  async *processStreamChunks(result, options, logger) {
-    const model = options.model;
-    let accumulatedContent = "";
-    let accumulatedThinking = "";
-    const toolCallMap = /* @__PURE__ */ new Map();
-    let nextToolIndex = 0;
-    const runId = options.runId ?? generateId(this.name);
-    const threadId = options.threadId ?? generateId(this.name);
-    const messageId = generateId(this.name);
-    let stepId = null;
-    let reasoningMessageId = null;
-    let hasClosedReasoning = false;
-    let hasEmittedRunStarted = false;
-    let hasEmittedTextMessageStart = false;
-    let hasEmittedStepStarted = false;
-    for await (const chunk of result) {
-      logger.provider(`provider=gemini`, { chunk });
-      if (!hasEmittedRunStarted) {
-        hasEmittedRunStarted = true;
-        yield {
-          type: EventType.RUN_STARTED,
-          runId,
-          threadId,
-          model,
-          timestamp: Date.now(),
-          parentRunId: options.parentRunId
-        };
-      }
-      if (chunk.candidates?.[0]?.content?.parts) {
-        const parts = chunk.candidates[0].content.parts;
-        for (const part of parts) {
-          if (part.text) {
-            if (part.thought) {
-              if (!hasEmittedStepStarted) {
-                hasEmittedStepStarted = true;
-                stepId = generateId(this.name);
-                reasoningMessageId = generateId(this.name);
-                yield {
-                  type: EventType.REASONING_START,
-                  messageId: reasoningMessageId,
-                  model,
-                  timestamp: Date.now()
-                };
-                yield {
-                  type: EventType.REASONING_MESSAGE_START,
-                  messageId: reasoningMessageId,
-                  role: "reasoning",
-                  model,
-                  timestamp: Date.now()
-                };
-                yield {
-                  type: EventType.STEP_STARTED,
-                  stepName: stepId,
-                  stepId,
-                  model,
-                  timestamp: Date.now(),
-                  stepType: "thinking"
-                };
-              }
-              accumulatedThinking += part.text;
-              if (!reasoningMessageId) continue;
-              yield {
-                type: EventType.REASONING_MESSAGE_CONTENT,
-                messageId: reasoningMessageId,
-                delta: part.text,
-                model,
-                timestamp: Date.now()
-              };
-              yield {
-                type: EventType.STEP_FINISHED,
-                stepName: stepId || generateId(this.name),
-                stepId: stepId || generateId(this.name),
-                model,
-                timestamp: Date.now(),
-                delta: part.text,
-                content: accumulatedThinking
-              };
-            } else if (part.text.trim()) {
-              if (reasoningMessageId && !hasClosedReasoning) {
-                hasClosedReasoning = true;
-                yield {
-                  type: EventType.REASONING_MESSAGE_END,
-                  messageId: reasoningMessageId,
-                  model,
-                  timestamp: Date.now()
-                };
-                yield {
-                  type: EventType.REASONING_END,
-                  messageId: reasoningMessageId,
-                  model,
-                  timestamp: Date.now()
-                };
-              }
-              if (!hasEmittedTextMessageStart) {
-                hasEmittedTextMessageStart = true;
-                yield {
-                  type: EventType.TEXT_MESSAGE_START,
-                  messageId,
-                  model,
-                  timestamp: Date.now(),
-                  role: "assistant"
-                };
-              }
-              accumulatedContent += part.text;
-              yield {
-                type: EventType.TEXT_MESSAGE_CONTENT,
-                messageId,
-                model,
-                timestamp: Date.now(),
-                delta: part.text,
-                content: accumulatedContent
-              };
-            }
-          }
-          const functionCall = part.functionCall;
-          if (functionCall) {
-            const toolCallId = functionCall.id || `${functionCall.name}_${Date.now()}_${nextToolIndex}`;
-            const functionArgs = functionCall.args || {};
-            const partThoughtSignature = part.thoughtSignature || void 0;
-            let toolCallData = toolCallMap.get(toolCallId);
-            if (!toolCallData) {
-              toolCallData = {
-                name: functionCall.name || "",
-                args: typeof functionArgs === "string" ? functionArgs : JSON.stringify(functionArgs),
-                index: nextToolIndex++,
-                started: false,
-                // Only set thoughtSignature when present — under EOPT, the
-                // optional field cannot accept an explicit `undefined`.
-                ...partThoughtSignature !== void 0 && {
-                  thoughtSignature: partThoughtSignature
-                }
-              };
-              toolCallMap.set(toolCallId, toolCallData);
-            } else {
-              if (!toolCallData.thoughtSignature && partThoughtSignature) {
-                toolCallData.thoughtSignature = partThoughtSignature;
-              }
-              try {
-                const existingArgs = JSON.parse(toolCallData.args);
-                const newArgs = typeof functionArgs === "string" ? JSON.parse(functionArgs) : functionArgs;
-                const mergedArgs = { ...existingArgs, ...newArgs };
-                toolCallData.args = JSON.stringify(mergedArgs);
-              } catch {
-                toolCallData.args = typeof functionArgs === "string" ? functionArgs : JSON.stringify(functionArgs);
-              }
-            }
-            if (!toolCallData.started) {
-              toolCallData.started = true;
-              yield {
-                type: EventType.TOOL_CALL_START,
-                toolCallId,
-                toolCallName: toolCallData.name,
-                toolName: toolCallData.name,
-                parentMessageId: messageId,
-                model,
-                timestamp: Date.now(),
-                index: toolCallData.index,
-                ...toolCallData.thoughtSignature && {
-                  metadata: {
-                    thoughtSignature: toolCallData.thoughtSignature
-                  }
-                }
-              };
-            }
-            yield {
-              type: EventType.TOOL_CALL_ARGS,
-              toolCallId,
-              model,
-              timestamp: Date.now(),
-              delta: toolCallData.args,
-              args: toolCallData.args
-            };
-          }
-        }
-      } else if (chunk.data && chunk.data.trim()) {
-        if (!hasEmittedTextMessageStart) {
-          hasEmittedTextMessageStart = true;
-          yield {
-            type: EventType.TEXT_MESSAGE_START,
-            messageId,
-            model,
-            timestamp: Date.now(),
-            role: "assistant"
-          };
-        }
-        accumulatedContent += chunk.data;
-        yield {
-          type: EventType.TEXT_MESSAGE_CONTENT,
-          messageId,
-          model,
-          timestamp: Date.now(),
-          delta: chunk.data,
-          content: accumulatedContent
-        };
-      }
-      if (chunk.candidates?.[0]?.finishReason) {
-        const finishReason = chunk.candidates[0].finishReason;
-        if (finishReason === FinishReason.UNEXPECTED_TOOL_CALL) {
-          if (chunk.candidates[0].content?.parts) {
-            for (const part of chunk.candidates[0].content.parts) {
-              const functionCall = part.functionCall;
-              if (functionCall) {
-                const toolCallId = functionCall.id || `${functionCall.name}_${Date.now()}_${nextToolIndex}`;
-                const functionArgs = functionCall.args || {};
-                const argsString = typeof functionArgs === "string" ? functionArgs : JSON.stringify(functionArgs);
-                toolCallMap.set(toolCallId, {
-                  name: functionCall.name || "",
-                  args: argsString,
-                  index: nextToolIndex++,
-                  started: true
-                });
-                yield {
-                  type: EventType.TOOL_CALL_START,
-                  toolCallId,
-                  toolCallName: functionCall.name || "",
-                  toolName: functionCall.name || "",
-                  parentMessageId: messageId,
-                  model,
-                  timestamp: Date.now(),
-                  index: nextToolIndex - 1
-                };
-                let parsedInput = {};
-                try {
-                  const parsed = typeof functionArgs === "string" ? JSON.parse(functionArgs) : functionArgs;
-                  parsedInput = parsed && typeof parsed === "object" ? parsed : {};
-                } catch {
-                  parsedInput = {};
-                }
-                yield {
-                  type: EventType.TOOL_CALL_END,
-                  toolCallId,
-                  toolCallName: functionCall.name || "",
-                  toolName: functionCall.name || "",
-                  model,
-                  timestamp: Date.now(),
-                  input: parsedInput
-                };
-              }
-            }
-          }
-        }
-        for (const [toolCallId, toolCallData] of toolCallMap.entries()) {
-          let parsedInput = {};
-          try {
-            const parsed = JSON.parse(toolCallData.args);
-            parsedInput = parsed && typeof parsed === "object" ? parsed : {};
-          } catch {
-            parsedInput = {};
-          }
-          yield {
-            type: EventType.TOOL_CALL_END,
-            toolCallId,
-            toolCallName: toolCallData.name,
-            toolName: toolCallData.name,
-            model,
-            timestamp: Date.now(),
-            input: parsedInput
-          };
-        }
-        if (toolCallMap.size > 0) {
-          hasEmittedTextMessageStart = false;
-        }
-        if (finishReason === FinishReason.MAX_TOKENS) {
-          yield {
-            type: EventType.RUN_ERROR,
-            runId,
-            model,
-            timestamp: Date.now(),
-            message: "The response was cut off because the maximum token limit was reached.",
-            code: "max_tokens",
-            error: {
-              message: "The response was cut off because the maximum token limit was reached.",
-              code: "max_tokens"
-            }
-          };
-        }
-        if (reasoningMessageId && !hasClosedReasoning) {
-          hasClosedReasoning = true;
-          yield {
-            type: EventType.REASONING_MESSAGE_END,
-            messageId: reasoningMessageId,
-            model,
-            timestamp: Date.now()
-          };
-          yield {
-            type: EventType.REASONING_END,
-            messageId: reasoningMessageId,
-            model,
-            timestamp: Date.now()
-          };
-        }
-        if (hasEmittedTextMessageStart) {
-          yield {
-            type: EventType.TEXT_MESSAGE_END,
-            messageId,
-            model,
-            timestamp: Date.now()
-          };
-        }
-        yield {
-          type: EventType.RUN_FINISHED,
-          runId,
-          threadId,
-          model,
-          timestamp: Date.now(),
-          finishReason: toolCallMap.size > 0 ? "tool_calls" : "stop",
-          // RunFinishedEvent.usage is `usage?: {...}` (no `| undefined`) under
-          // exactOptionalPropertyTypes; only include it when usageMetadata is
-          // present rather than assigning an explicit `undefined`.
-          ...chunk.usageMetadata && {
-            usage: buildGeminiUsage(chunk.usageMetadata)
-          }
-        };
-      }
-    }
-  }
-  convertContentPartToGemini(part) {
-    switch (part.type) {
-      case "text":
-        return { text: part.content };
-      case "image":
-      case "audio":
-      case "video":
-      case "document": {
-        if (part.source.type === "data") {
-          return {
-            inlineData: {
-              data: part.source.value,
-              mimeType: part.source.mimeType
-            }
-          };
-        } else {
-          const defaultMimeType = {
-            image: "image/jpeg",
-            audio: "audio/mp3",
-            video: "video/mp4",
-            document: "application/pdf"
-          }[part.type];
-          return {
-            fileData: {
-              fileUri: part.source.value,
-              mimeType: part.source.mimeType ?? defaultMimeType
-            }
-          };
-        }
-      }
-      default: {
-        const _exhaustiveCheck = part;
-        throw new Error(
-          `Unsupported content part type: ${_exhaustiveCheck.type}`
-        );
-      }
-    }
-  }
-  formatMessages(messages) {
-    const toolCallIdToName = /* @__PURE__ */ new Map();
-    for (const msg of messages) {
-      if (msg.role === "assistant" && msg.toolCalls) {
-        for (const tc of msg.toolCalls) {
-          toolCallIdToName.set(tc.id, tc.function.name);
-        }
-      }
-    }
-    const formatted = messages.map((msg) => {
-      const role = msg.role === "assistant" ? "model" : "user";
-      const parts = [];
-      if (Array.isArray(msg.content)) {
-        for (const contentPart of msg.content) {
-          parts.push(this.convertContentPartToGemini(contentPart));
-        }
-      } else if (msg.content && msg.role !== "tool") {
-        parts.push({ text: msg.content });
-      }
-      if (msg.role === "assistant" && msg.toolCalls?.length) {
-        for (const toolCall of msg.toolCalls) {
-          let parsedArgs = {};
-          try {
-            parsedArgs = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {};
-          } catch {
-            parsedArgs = {};
-          }
-          const thoughtSignature = toolCall.metadata?.thoughtSignature;
-          const part = {
-            functionCall: {
-              id: toolCall.id,
-              name: toolCall.function.name,
-              args: parsedArgs
-            }
-          };
-          if (thoughtSignature) {
-            part.thoughtSignature = thoughtSignature;
-          }
-          parts.push(part);
-        }
-      }
-      if (msg.role === "tool" && msg.toolCallId) {
-        const functionName = toolCallIdToName.get(msg.toolCallId) || msg.toolCallId;
-        const toolContent = msg.content;
-        if (Array.isArray(toolContent)) {
-          const textChunks = [];
-          const mediaParts = [];
-          for (const part of toolContent) {
-            if (part.type === "text") {
-              textChunks.push(part.content);
-            } else if (part.source.type === "data") {
-              mediaParts.push({
-                inlineData: {
-                  data: part.source.value,
-                  mimeType: part.source.mimeType
-                }
-              });
-            } else {
-              const defaultMimeType = {
-                image: "image/jpeg",
-                audio: "audio/mp3",
-                video: "video/mp4",
-                document: "application/pdf"
-              }[part.type];
-              mediaParts.push({
-                fileData: {
-                  fileUri: part.source.value,
-                  mimeType: part.source.mimeType ?? defaultMimeType
-                }
-              });
-            }
-          }
-          parts.push({
-            functionResponse: {
-              id: msg.toolCallId,
-              name: functionName,
-              response: { content: textChunks.join("\n") },
-              ...mediaParts.length > 0 && { parts: mediaParts }
-            }
-          });
-        } else {
-          parts.push({
-            functionResponse: {
-              id: msg.toolCallId,
-              name: functionName,
-              response: { content: toolContent || "" }
-            }
-          });
-        }
-      }
-      return {
-        role,
-        parts: parts.length > 0 ? parts : [{ text: "" }]
-      };
-    });
-    return this.mergeConsecutiveSameRoleMessages(formatted);
-  }
-  /**
-   * Merge consecutive messages of the same role into a single message.
-   * Gemini's API requires strictly alternating user/model roles.
-   * Tool results are mapped to role:'user', which can collide with actual
-   * user messages in multi-turn conversations.
-   *
-   * Also filters out empty model messages (e.g., from a previous failed request)
-   * and deduplicates functionResponse parts with the same name (tool call ID).
-   */
-  mergeConsecutiveSameRoleMessages(messages) {
-    const merged = [];
-    for (const msg of messages) {
-      const parts = msg.parts || [];
-      if (msg.role === "model") {
-        const hasContent = parts.length > 0 && !parts.every(
-          (p) => "text" in p && p.text === ""
-        );
-        if (!hasContent) {
-          continue;
-        }
-      }
-      const prev = merged[merged.length - 1];
-      if (prev && prev.role === msg.role) {
-        prev.parts = [...prev.parts || [], ...parts];
-      } else {
-        merged.push({ ...msg, parts: [...parts] });
-      }
-    }
-    for (const msg of merged) {
-      if (!msg.parts) continue;
-      const seenFunctionResponseNames = /* @__PURE__ */ new Set();
-      msg.parts = msg.parts.filter((part) => {
-        if ("functionResponse" in part && part.functionResponse?.name) {
-          if (seenFunctionResponseNames.has(part.functionResponse.name)) {
-            return false;
-          }
-          seenFunctionResponseNames.add(part.functionResponse.name);
-        }
-        return true;
-      });
-    }
-    return merged;
-  }
-  mapCommonOptionsToGemini(options) {
-    const { thinkingConfig, ...modelOpts } = options.modelOptions ?? {};
-    const mappedThinkingConfig = thinkingConfig ? {
-      ...thinkingConfig.includeThoughts !== void 0 && {
-        includeThoughts: thinkingConfig.includeThoughts
-      },
-      ...thinkingConfig.thinkingBudget !== void 0 && {
-        thinkingBudget: thinkingConfig.thinkingBudget
-      },
-      ...thinkingConfig.thinkingLevel ? {
-        thinkingLevel: thinkingConfig.thinkingLevel
-      } : {}
-    } : void 0;
-    const normalizedPrompts = normalizeSystemPrompts(options.systemPrompts);
-    const systemInstruction = normalizedPrompts.length > 0 ? normalizedPrompts.map((p) => p.content).join("\n") : void 0;
-    const combinedSchema = options.outputSchema;
-    const combinedSchemaConfig = combinedSchema ? {
-      responseMimeType: "application/json",
-      responseSchema: combinedSchema
-    } : void 0;
-    const requestOptions = {
-      model: options.model,
-      contents: this.formatMessages(options.messages),
-      config: {
-        ...modelOpts,
-        ...mappedThinkingConfig !== void 0 && {
-          thinkingConfig: mappedThinkingConfig
-        },
-        ...systemInstruction !== void 0 && { systemInstruction },
-        tools: convertToolsToProviderFormat(options.tools),
-        ...combinedSchemaConfig ?? {}
-      }
-    };
-    return requestOptions;
-  }
-  /**
-   * Gemini 3.x natively combines `tools` + `responseSchema` in a single
-   * streaming `generateContentStream` call (issue #605). Gemini 2.x is
-   * documented as brittle for the combination and keeps the engine's
-   * legacy finalization path.
-   */
-  supportsCombinedToolsAndSchema() {
-    return GEMINI_COMBINED_TOOLS_AND_SCHEMA_MODELS.has(this.model);
-  }
-}
-function createGeminiChat(model, apiKey, config) {
-  return new GeminiTextAdapter({ apiKey, ...config }, model);
-}
-function geminiText(model, config) {
-  const apiKey = getGeminiApiKeyFromEnv();
-  return createGeminiChat(model, apiKey, config);
-}
-export {
-  GeminiTextAdapter,
-  createGeminiChat,
-  geminiText
-};
-//# sourceMappingURL=text.js.map