@tanstack/ai-gemini 0.17.3 → 0.18.1

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

@@ -1,899 +0,0 @@
-import { EventType } from "@tanstack/ai";
-import { BaseTextAdapter } from "@tanstack/ai/adapters";
-import { createGeminiClient, generateId, getGeminiApiKeyFromEnv } from "../../utils/client.js";
-class GeminiTextInteractionsAdapter extends BaseTextAdapter {
-  kind = "text";
-  name = "gemini-text-interactions";
-  client;
-  // Tracks the most recent server-assigned interaction id per threadId
-  // so the adapter can chain follow-up calls on the same thread without
-  // the caller having to thread the id manually. Two callers rely on
-  // this:
-  //   1. The agent loop's tool-call iterations (each iteration is a new
-  //      `chatStream` call with accumulated tool messages).
-  //   2. The agentic-structured composition: a `chatStream` run followed
-  //      by `structuredOutput` on the accumulated messages.
-  // Cross-request chaining is the caller's job via
-  // `modelOptions.previous_interaction_id`. To keep stale ids from
-  // chaining a brand-new turn, `chatStream` evicts at the START when
-  // the caller signals fresh-turn intent (no caller-provided id AND a
-  // single user message — anything else is a follow-up). Errors evict
-  // immediately so a failed turn never chains into the next one.
-  interactionIdByThread = /* @__PURE__ */ new Map();
-  constructor(config, model) {
-    super({}, model);
-    this.client = createGeminiClient(config);
-  }
-  async *chatStream(options) {
-    const runId = options.runId ?? generateId(this.name);
-    const threadId = options.threadId ?? generateId(this.name);
-    const timestamp = Date.now();
-    const { logger } = options;
-    if (!options.modelOptions?.previous_interaction_id && options.messages.length === 1 && options.messages[0]?.role === "user") {
-      this.interactionIdByThread.delete(threadId);
-    }
-    const effectivePreviousInteractionId = options.modelOptions?.previous_interaction_id ?? this.interactionIdByThread.get(threadId);
-    let sawTerminalEvent = false;
-    let completedTryBlock = false;
-    try {
-      const request = buildInteractionsRequest({
-        ...options,
-        modelOptions: {
-          ...options.modelOptions,
-          previous_interaction_id: effectivePreviousInteractionId
-        }
-      });
-      logger.request(
-        `activity=chat provider=gemini-text-interactions model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
-        {
-          provider: "gemini-text-interactions",
-          model: this.model,
-          request
-        }
-      );
-      const stream = await this.client.interactions.create(
-        { ...request, stream: true },
-        { signal: options.abortController?.signal }
-      );
-      for await (const chunk of translateInteractionEvents(
-        stream,
-        options.model,
-        runId,
-        threadId,
-        options.parentRunId,
-        timestamp,
-        this.name,
-        logger
-      )) {
-        if (chunk.type === EventType.CUSTOM && chunk.name === "gemini.interactionId") {
-          const value = chunk.value;
-          this.interactionIdByThread.set(threadId, value.interactionId);
-        }
-        if (chunk.type === EventType.RUN_FINISHED) {
-          sawTerminalEvent = true;
-        } else if (chunk.type === EventType.RUN_ERROR) {
-          sawTerminalEvent = true;
-          this.interactionIdByThread.delete(threadId);
-        }
-        yield chunk;
-      }
-      if (!sawTerminalEvent) {
-        this.interactionIdByThread.delete(threadId);
-        const message = "Gemini Interactions stream ended without a terminal event (no interaction.complete or error)";
-        logger.errors("gemini-text-interactions.chatStream truncated", {
-          source: "gemini-text-interactions.chatStream",
-          runId,
-          threadId
-        });
-        yield {
-          type: EventType.RUN_ERROR,
-          runId,
-          model: options.model,
-          timestamp,
-          message,
-          error: { message }
-        };
-      }
-      completedTryBlock = true;
-    } catch (error) {
-      this.interactionIdByThread.delete(threadId);
-      const message = error instanceof Error ? error.message : "An unknown error occurred during the interactions stream.";
-      logger.errors("gemini-text-interactions.chatStream fatal", {
-        error,
-        source: "gemini-text-interactions.chatStream"
-      });
-      yield {
-        type: EventType.RUN_ERROR,
-        runId,
-        model: options.model,
-        timestamp,
-        message,
-        error: { message }
-      };
-    } finally {
-      if (!completedTryBlock) {
-        this.interactionIdByThread.delete(threadId);
-      }
-    }
-  }
-  async structuredOutput(options) {
-    const { chatOptions, outputSchema } = options;
-    const { logger } = chatOptions;
-    const threadId = chatOptions.threadId;
-    const effectivePreviousInteractionId = chatOptions.modelOptions?.previous_interaction_id ?? (threadId ? this.interactionIdByThread.get(threadId) : void 0);
-    const baseRequest = buildInteractionsRequest({
-      ...chatOptions,
-      modelOptions: {
-        ...chatOptions.modelOptions,
-        previous_interaction_id: effectivePreviousInteractionId
-      }
-    });
-    const request = {
-      ...baseRequest,
-      response_mime_type: "application/json",
-      response_format: outputSchema
-    };
-    try {
-      logger.request(
-        `activity=chat provider=gemini-text-interactions model=${this.model} messages=${chatOptions.messages.length} tools=${chatOptions.tools?.length ?? 0} stream=false`,
-        {
-          provider: "gemini-text-interactions",
-          model: this.model,
-          request
-        }
-      );
-      const result = await this.client.interactions.create(
-        request,
-        { signal: chatOptions.abortController?.signal }
-      );
-      const rawText = extractTextFromInteraction(result);
-      if (!rawText) {
-        throw new Error(
-          `Gemini Interactions returned no text output for structured-output request (status: ${result.status}). The model may have produced only tool calls or non-text content.`
-        );
-      }
-      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 };
-    } catch (error) {
-      logger.errors("gemini-text-interactions.structuredOutput fatal", {
-        error,
-        source: "gemini-text-interactions.structuredOutput"
-      });
-      throw new Error(
-        error instanceof Error ? error.message : "An unknown error occurred during structured output generation.",
-        { cause: error }
-      );
-    }
-  }
-}
-function createGeminiTextInteractions(model, apiKey, config) {
-  return new GeminiTextInteractionsAdapter({ apiKey, ...config }, model);
-}
-function geminiTextInteractions(model, config) {
-  const apiKey = getGeminiApiKeyFromEnv();
-  return createGeminiTextInteractions(model, apiKey, config);
-}
-function buildInteractionsRequest(options) {
-  const modelOpts = options.modelOptions;
-  const systemInstruction = modelOpts?.system_instruction ?? options.systemPrompts?.join("\n");
-  const generationConfig = {
-    ...modelOpts?.generation_config
-  };
-  const hasGenerationConfig = Object.keys(generationConfig).length > 0;
-  const input = convertMessagesToInteractionsInput(
-    options.messages,
-    modelOpts?.previous_interaction_id !== void 0
-  );
-  return {
-    model: options.model,
-    input,
-    previous_interaction_id: modelOpts?.previous_interaction_id,
-    system_instruction: systemInstruction,
-    tools: convertToolsToInteractionsFormat(options.tools),
-    generation_config: hasGenerationConfig ? generationConfig : void 0,
-    store: modelOpts?.store,
-    background: modelOpts?.background,
-    response_modalities: modelOpts?.response_modalities,
-    response_format: modelOpts?.response_format,
-    response_mime_type: modelOpts?.response_mime_type
-  };
-}
-function convertMessagesToInteractionsInput(messages, hasPreviousInteraction) {
-  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 source = hasPreviousInteraction ? messagesAfterLastAssistant(messages) : messages;
-  if (hasPreviousInteraction && source.length === 0) {
-    throw new Error(
-      "Gemini Interactions adapter: modelOptions.previous_interaction_id was provided but no new messages were found after the last assistant turn. Append at least one user or tool message before chaining."
-    );
-  }
-  if (!hasPreviousInteraction) {
-    const [only, ...rest] = source;
-    if (!only) {
-      throw new Error("Gemini Interactions adapter: no messages to send.");
-    }
-    if (rest.length > 0) {
-      throw new Error(
-        'Gemini Interactions adapter: cannot send prior conversation history on a fresh interaction. Either set modelOptions.previous_interaction_id to chain prior turns server-side, or trim the message list to a single new user turn. See docs/adapters/gemini.md ("Wiring with useChat") for the canonical client/server pattern.'
-      );
-    }
-    if (only.role !== "user") {
-      throw new Error(
-        `Gemini Interactions adapter: the first message of a fresh interaction must be a user turn (got role="${only.role}"). Set modelOptions.previous_interaction_id to continue an existing interaction.`
-      );
-    }
-    const content = messageToContentBlocks(only);
-    if (content.length === 0) {
-      throw new Error(
-        "Gemini Interactions adapter: the user message produced no content blocks to send."
-      );
-    }
-    return [{ type: "user_input", content }];
-  }
-  const steps = [];
-  for (const msg of source) {
-    if (msg.role === "tool" && msg.toolCallId) {
-      const result = serializeToolResultContent(msg.content);
-      steps.push({
-        type: "function_result",
-        call_id: msg.toolCallId,
-        name: toolCallIdToName.get(msg.toolCallId),
-        result
-      });
-    } else if (msg.role === "user") {
-      const content = messageToContentBlocks(msg);
-      if (content.length > 0) {
-        steps.push({ type: "user_input", content });
-      }
-    }
-  }
-  if (steps.length === 0) {
-    throw new Error(
-      "Gemini Interactions adapter: messages after the last assistant turn produced no steps to send."
-    );
-  }
-  return steps;
-}
-function serializeToolResultContent(content) {
-  if (typeof content === "string") return content;
-  if (content === null || content === void 0) {
-    throw new Error(
-      "Gemini Interactions adapter: tool message has no content. The Interactions API requires a string `result` on function_result steps — return a string from your tool implementation (encode JSON/multimodal output yourself)."
-    );
-  }
-  throw new Error(
-    "Gemini Interactions adapter: tool message content must be a string (got an array of content parts). The Interactions API requires a string `result` on function_result steps — stringify multimodal tool output before returning it from your tool."
-  );
-}
-function messageToContentBlocks(msg) {
-  const blocks = [];
-  if (Array.isArray(msg.content)) {
-    for (const part of msg.content) {
-      blocks.push(contentPartToBlock(part));
-    }
-  } else if (typeof msg.content === "string" && msg.content && msg.role !== "tool") {
-    blocks.push({ type: "text", text: msg.content });
-  }
-  return blocks;
-}
-function messagesAfterLastAssistant(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") {
-      return messages.slice(i + 1);
-    }
-  }
-  return messages;
-}
-function safeParseToolArguments(raw, logger) {
-  if (!raw) return {};
-  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 IMAGE_MIME_TYPES = [
-  "image/png",
-  "image/jpeg",
-  "image/webp",
-  "image/heic",
-  "image/heif"
-];
-const AUDIO_MIME_TYPES = [
-  "audio/wav",
-  "audio/mp3",
-  "audio/aiff",
-  "audio/aac",
-  "audio/ogg",
-  "audio/flac"
-];
-const VIDEO_MIME_TYPES = [
-  "video/mp4",
-  "video/mpeg",
-  "video/mpg",
-  "video/mov",
-  "video/avi",
-  "video/x-flv",
-  "video/webm",
-  "video/wmv",
-  "video/3gpp"
-];
-const DOCUMENT_MIME_TYPES = [
-  "application/pdf"
-];
-function validateMime(allowed, value, kind) {
-  if (value === void 0) return void 0;
-  if (allowed.includes(value)) {
-    return value;
-  }
-  throw new Error(
-    `Unsupported ${kind} mime type "${value}" for the Gemini Interactions API. Allowed: ${allowed.join(", ")}.`
-  );
-}
-function contentPartToBlock(part) {
-  if (part.type === "text") {
-    return { type: "text", text: part.content };
-  }
-  const isData = part.source.type === "data";
-  switch (part.type) {
-    case "image": {
-      const mime_type = validateMime(
-        IMAGE_MIME_TYPES,
-        part.source.mimeType,
-        "image"
-      );
-      return isData ? { type: "image", data: part.source.value, mime_type } : { type: "image", uri: part.source.value, mime_type };
-    }
-    case "audio": {
-      const mime_type = validateMime(
-        AUDIO_MIME_TYPES,
-        part.source.mimeType,
-        "audio"
-      );
-      return isData ? { type: "audio", data: part.source.value, mime_type } : { type: "audio", uri: part.source.value, mime_type };
-    }
-    case "video": {
-      const mime_type = validateMime(
-        VIDEO_MIME_TYPES,
-        part.source.mimeType,
-        "video"
-      );
-      return isData ? { type: "video", data: part.source.value, mime_type } : { type: "video", uri: part.source.value, mime_type };
-    }
-    case "document": {
-      const mime_type = validateMime(
-        DOCUMENT_MIME_TYPES,
-        part.source.mimeType,
-        "document"
-      );
-      return isData ? { type: "document", data: part.source.value, mime_type } : { type: "document", uri: part.source.value, mime_type };
-    }
-  }
-}
-function convertToolsToInteractionsFormat(tools) {
-  if (!tools || tools.length === 0) return void 0;
-  const result = [];
-  for (const tool of tools) {
-    switch (tool.name) {
-      case "google_search": {
-        const metadata = tool.metadata ?? {};
-        result.push({
-          type: "google_search",
-          ...metadata.search_types ? { search_types: metadata.search_types } : {}
-        });
-        break;
-      }
-      case "code_execution": {
-        result.push({ type: "code_execution" });
-        break;
-      }
-      case "url_context": {
-        result.push({ type: "url_context" });
-        break;
-      }
-      case "file_search": {
-        const metadata = tool.metadata ?? {};
-        result.push({
-          type: "file_search",
-          ...metadata.fileSearchStoreNames ? { file_search_store_names: metadata.fileSearchStoreNames } : {},
-          ...metadata.topK !== void 0 ? { top_k: metadata.topK } : {},
-          ...metadata.metadataFilter !== void 0 ? { metadata_filter: metadata.metadataFilter } : {}
-        });
-        break;
-      }
-      case "computer_use": {
-        const metadata = tool.metadata ?? {};
-        if (metadata.environment && metadata.environment !== "browser") {
-          throw new Error(
-            `computer_use environment "${metadata.environment}" is not supported on the Gemini Interactions API. Only "browser" is accepted.`
-          );
-        }
-        result.push({
-          type: "computer_use",
-          ...metadata.environment ? { environment: metadata.environment } : {},
-          ...metadata.excludedPredefinedFunctions ? {
-            excludedPredefinedFunctions: metadata.excludedPredefinedFunctions
-          } : {}
-        });
-        break;
-      }
-      case "google_search_retrieval":
-        throw new Error(
-          "`google_search_retrieval` is not supported on the Gemini Interactions API. Use `googleSearchTool()` (`google_search`) with `geminiTextInteractions()`, or call `geminiText()` for the legacy retrieval tool."
-        );
-      case "google_maps":
-        throw new Error(
-          "`google_maps` is not yet supported on the Gemini Interactions API. Use `geminiText()` for Google Maps grounding."
-        );
-      case "mcp_server":
-        throw new Error(
-          "`mcp_server` is not yet supported on the `geminiTextInteractions()` adapter."
-        );
-      default: {
-        if (!tool.description) {
-          throw new Error(
-            `Tool ${tool.name} requires a description for the Gemini Interactions adapter`
-          );
-        }
-        result.push({
-          type: "function",
-          name: tool.name,
-          description: tool.description,
-          parameters: sanitizeToolParameters(
-            tool.inputSchema ?? { type: "object", properties: {} }
-          )
-        });
-      }
-    }
-  }
-  return result;
-}
-function statusToFinishReason(status, sawFunctionCall) {
-  if (status === "requires_action") return "tool_calls";
-  if (status === "incomplete") return "length";
-  if (sawFunctionCall) return "tool_calls";
-  return "stop";
-}
-function statusIsError(status) {
-  return status === "failed" || status === "cancelled";
-}
-async function* translateInteractionEvents(stream, model, runId, threadId, parentRunId, timestamp, adapterName, logger) {
-  const messageId = generateId(adapterName);
-  let hasEmittedRunStarted = false;
-  let hasEmittedTextMessageStart = false;
-  let textAccumulated = "";
-  let interactionId;
-  let sawFunctionCall = false;
-  const toolCalls = /* @__PURE__ */ new Map();
-  let nextToolIndex = 0;
-  let thinkingStepId = null;
-  let thinkingAccumulated = "";
-  let reasoningMessageId = null;
-  let hasClosedReasoning = false;
-  const closeReasoningIfNeeded = function* () {
-    if (reasoningMessageId && !hasClosedReasoning) {
-      hasClosedReasoning = true;
-      yield {
-        type: EventType.REASONING_MESSAGE_END,
-        messageId: reasoningMessageId,
-        model,
-        timestamp
-      };
-      yield {
-        type: EventType.REASONING_END,
-        messageId: reasoningMessageId,
-        model,
-        timestamp
-      };
-      thinkingStepId = null;
-      reasoningMessageId = null;
-      hasClosedReasoning = false;
-    }
-  };
-  const closeOpenState = function* () {
-    yield* closeReasoningIfNeeded();
-    for (const [toolCallId, state] of toolCalls) {
-      if (state.ended) continue;
-      state.ended = true;
-      yield {
-        type: EventType.TOOL_CALL_END,
-        toolCallId,
-        toolName: state.name,
-        model,
-        timestamp,
-        input: state.args
-      };
-    }
-    if (hasEmittedTextMessageStart) {
-      hasEmittedTextMessageStart = false;
-      yield {
-        type: EventType.TEXT_MESSAGE_END,
-        messageId,
-        model,
-        timestamp
-      };
-    }
-  };
-  const emitRunStartedIfNeeded = function* () {
-    if (!hasEmittedRunStarted) {
-      hasEmittedRunStarted = true;
-      yield {
-        type: EventType.RUN_STARTED,
-        runId,
-        threadId,
-        model,
-        timestamp,
-        parentRunId
-      };
-    }
-  };
-  for await (const event of stream) {
-    logger.provider(`provider=gemini-text-interactions`, { event });
-    switch (event.event_type) {
-      case "interaction.start": {
-        interactionId = event.interaction.id;
-        yield* emitRunStartedIfNeeded();
-        break;
-      }
-      case "content.start": {
-        yield* emitRunStartedIfNeeded();
-        break;
-      }
-      case "content.delta": {
-        yield* emitRunStartedIfNeeded();
-        const delta = event.delta;
-        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 "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
-              };
-              toolCalls.set(toolCallId, state);
-            } else {
-              state.args = { ...state.args, ...deltaArgs };
-              if (delta.name) state.name = delta.name;
-            }
-            if (!state.started) {
-              state.started = true;
-              yield {
-                type: EventType.TOOL_CALL_START,
-                toolCallId,
-                toolCallName: state.name,
-                toolName: state.name,
-                parentMessageId: messageId,
-                model,
-                timestamp,
-                index: state.index
-              };
-            }
-            yield {
-              type: EventType.TOOL_CALL_ARGS,
-              toolCallId,
-              model,
-              timestamp,
-              delta: JSON.stringify(deltaArgs),
-              args: JSON.stringify(state.args)
-            };
-            break;
-          }
-          case "google_search_call": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.googleSearchCall",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "google_search_result": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.googleSearchResult",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "code_execution_call": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.codeExecutionCall",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "code_execution_result": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.codeExecutionResult",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "url_context_call": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.urlContextCall",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "url_context_result": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.urlContextResult",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "file_search_call": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.fileSearchCall",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "file_search_result": {
-            yield* closeReasoningIfNeeded();
-            yield {
-              type: EventType.CUSTOM,
-              name: "gemini.fileSearchResult",
-              value: delta,
-              model,
-              timestamp
-            };
-            break;
-          }
-          case "thought_summary": {
-            const thoughtText = delta.content && "text" in delta.content ? delta.content.text : "";
-            if (!thoughtText) break;
-            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"
-              };
-            }
-            thinkingAccumulated += thoughtText;
-            yield {
-              type: EventType.REASONING_MESSAGE_CONTENT,
-              messageId: reasoningMessageId,
-              delta: thoughtText,
-              model,
-              timestamp
-            };
-            yield {
-              type: EventType.STEP_FINISHED,
-              stepName: thinkingStepId,
-              stepId: thinkingStepId,
-              model,
-              timestamp,
-              delta: thoughtText,
-              content: thinkingAccumulated
-            };
-            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.
-          case "image":
-          case "audio":
-          case "video":
-          case "document":
-          case "function_result":
-          case "mcp_server_tool_call":
-          case "mcp_server_tool_result":
-          case "thought_signature":
-          default:
-            logger.provider(
-              `gemini-text-interactions unhandled content.delta type`,
-              { delta }
-            );
-            break;
-        }
-        break;
-      }
-      case "content.stop":
-      case "interaction.status_update": {
-        break;
-      }
-      case "interaction.complete": {
-        if (event.interaction.id) {
-          interactionId = event.interaction.id;
-        }
-        yield* closeOpenState();
-        const status = event.interaction.status;
-        if (statusIsError(status)) {
-          const message = `Gemini Interactions ${status}: the interaction ended without a usable response.`;
-          logger.errors(
-            "gemini-text-interactions.translateInteractionEvents non-success status",
-            {
-              source: "gemini-text-interactions.chatStream",
-              status,
-              interactionId
-            }
-          );
-          yield {
-            type: EventType.RUN_ERROR,
-            runId,
-            model,
-            timestamp,
-            message,
-            code: status,
-            error: { message, code: status }
-          };
-          return;
-        }
-        const usage = event.interaction.usage;
-        const finishReason = statusToFinishReason(status, sawFunctionCall);
-        if (interactionId) {
-          yield {
-            type: EventType.CUSTOM,
-            name: "gemini.interactionId",
-            value: { interactionId },
-            model,
-            timestamp
-          };
-        }
-        yield {
-          type: EventType.RUN_FINISHED,
-          runId,
-          threadId,
-          model,
-          timestamp,
-          finishReason,
-          usage: usage ? {
-            promptTokens: usage.total_input_tokens ?? 0,
-            completionTokens: usage.total_output_tokens ?? 0,
-            totalTokens: usage.total_tokens ?? 0
-          } : void 0
-        };
-        return;
-      }
-      case "error": {
-        yield* closeOpenState();
-        const rawMessage = event.error?.message;
-        const message = typeof rawMessage === "string" && rawMessage.length > 0 ? rawMessage : `Gemini Interactions error (no message): ${JSON.stringify(event.error ?? {})}`;
-        const rawCode = event.error?.code;
-        const code = typeof rawCode === "string" || typeof rawCode === "number" ? String(rawCode) : void 0;
-        yield {
-          type: EventType.RUN_ERROR,
-          runId,
-          model,
-          timestamp,
-          message,
-          code,
-          error: { message, code }
-        };
-        return;
-      }
-      default:
-        logger.provider(`gemini-text-interactions unhandled event_type`, {
-          event
-        });
-        break;
-    }
-  }
-  yield* closeOpenState();
-}
-function extractTextFromInteraction(interaction) {
-  let text = "";
-  for (const output of interaction.outputs ?? []) {
-    if (output.type === "text") {
-      text += output.text;
-    }
-  }
-  return text;
-}
-function sanitizeToolParameters(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-  if (Array.isArray(schema)) return schema.map(sanitizeToolParameters);
-  const out = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "required" && Array.isArray(value) && value.length === 0) {
-      continue;
-    }
-    out[key] = sanitizeToolParameters(value);
-  }
-  return out;
-}
-export {
-  GeminiTextInteractionsAdapter,
-  createGeminiTextInteractions,
-  geminiTextInteractions
-};
-//# sourceMappingURL=adapter.js.map