@anvia/gemini 0.4.1 → 1.0.0-rc.10

package/dist/index.js

@@ -10,15 +10,13 @@ __export(gemini_exports, {
   GEMINI_2_5_FLASH_IMAGE: () => GEMINI_2_5_FLASH_IMAGE,
   GEMINI_3_PRO_IMAGE_PREVIEW: () => GEMINI_3_PRO_IMAGE_PREVIEW,
   GeminiClient: () => GeminiClient,
-  GeminiCompletionModel: () => GeminiCompletionModel,
-  GeminiEmbeddingModel: () => GeminiEmbeddingModel,
-  GeminiImageGenerationModel: () => GeminiImageGenerationModel,
-  GeminiImagenGenerationModel: () => GeminiImagenGenerationModel,
-  GeminiTranscriptionModel: () => GeminiTranscriptionModel,
   IMAGEN_4_GENERATE: () => IMAGEN_4_GENERATE
 });
 
 // src/gemini/client.ts
+import {
+  resolveModelContextLimits
+} from "@anvia/core/completion";
 import {
   ModelListingError
 } from "@anvia/core/model-listing";
@@ -26,9 +24,9 @@ import { GoogleGenAI } from "@google/genai";
 
 // src/gemini/completion.ts
 import {
-  AssistantContent,
   assertCompletionRequestSupported,
-  resolveCompletionModelInfo,
+  CompletionProviderOutputError,
+  isJsonValue,
   Usage,
   withContextUsage
 } from "@anvia/core/completion";
@@ -48,82 +46,35 @@ function orderedRequestMessages(request) {
   return messages;
 }
 
-// src/gemini/models.ts
-var CONTEXT_1M_64K = {
-  contextWindow: 1048576,
-  maxInputTokens: 1048576,
-  maxOutputTokens: 65536
-};
-var GEMINI_COMPLETION_MODEL_CONTEXT_LIMITS = {
-  "gemini-2.0-flash": {
-    contextWindow: 1048576,
-    maxInputTokens: 1048576,
-    maxOutputTokens: 8192
-  },
-  "gemini-2.0-flash-lite": {
-    contextWindow: 1048576,
-    maxInputTokens: 1048576,
-    maxOutputTokens: 8192
-  },
-  "gemini-2.5-flash": CONTEXT_1M_64K,
-  "gemini-2.5-flash-image": {
-    contextWindow: 32768,
-    maxInputTokens: 32768,
-    maxOutputTokens: 32768
-  },
-  "gemini-2.5-flash-lite": CONTEXT_1M_64K,
-  "gemini-2.5-flash-preview-tts": {
-    contextWindow: 8192,
-    maxInputTokens: 8192,
-    maxOutputTokens: 16384
-  },
-  "gemini-2.5-pro": CONTEXT_1M_64K,
-  "gemini-2.5-pro-preview-tts": {
-    contextWindow: 8192,
-    maxInputTokens: 8192,
-    maxOutputTokens: 16384
-  },
-  "gemini-3-flash-preview": CONTEXT_1M_64K,
-  "gemini-3-pro-image-preview": {
-    contextWindow: 131072,
-    maxInputTokens: 131072,
-    maxOutputTokens: 32768
-  },
-  "gemini-3-pro-preview": CONTEXT_1M_64K,
-  "gemini-3.1-flash-image-preview": {
-    contextWindow: 65536,
-    maxInputTokens: 65536,
-    maxOutputTokens: 65536
-  },
-  "gemini-3.1-flash-lite": CONTEXT_1M_64K,
-  "gemini-3.1-flash-lite-preview": CONTEXT_1M_64K,
-  "gemini-3.1-pro-preview": CONTEXT_1M_64K,
-  "gemini-3.1-pro-preview-customtools": CONTEXT_1M_64K,
-  "gemini-3.5-flash": CONTEXT_1M_64K,
-  "gemini-flash-latest": CONTEXT_1M_64K,
-  "gemini-flash-lite-latest": CONTEXT_1M_64K,
-  "gemma-4-26b-a4b-it": {
-    contextWindow: 262144,
-    maxInputTokens: 262144,
-    maxOutputTokens: 32768
-  },
-  "gemma-4-31b-it": {
-    contextWindow: 262144,
-    maxInputTokens: 262144,
-    maxOutputTokens: 32768
-  }
-};
+// src/gemini/retry.ts
+function disableGeminiNativeRetries(config) {
+  const httpOptions = isPlainObject(config.httpOptions) ? config.httpOptions : {};
+  const retryOptions = isPlainObject(httpOptions.retryOptions) ? httpOptions.retryOptions : {};
+  return {
+    ...config,
+    httpOptions: {
+      ...httpOptions,
+      retryOptions: {
+        ...retryOptions,
+        attempts: 1
+      }
+    }
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/gemini/completion.ts
 var GeminiCompletionModel = class {
-  constructor(client, defaultModel = "gemini-2.5-flash", metadataOptions = {}) {
+  constructor(client, modelId, contextLimits) {
     this.client = client;
-    this.defaultModel = defaultModel;
-    this.metadataOptions = metadataOptions;
+    this.modelId = modelId;
+    this.contextLimits = contextLimits;
   }
   client;
-  defaultModel;
-  metadataOptions;
+  modelId;
+  contextLimits;
   provider = "gemini";
   capabilities = {
     streaming: true,
@@ -134,62 +85,76 @@ var GeminiCompletionModel = class {
     outputSchema: true,
     reasoning: true
   };
-  getModelInfo(model = this.defaultModel) {
-    return resolveCompletionModelInfo(
-      model,
-      GEMINI_COMPLETION_MODEL_CONTEXT_LIMITS,
-      this.metadataOptions.modelOverrides
-    );
+  modelInfo() {
+    return this.contextLimits === void 0 ? void 0 : { modelId: this.modelId, context: this.contextLimits };
   }
   traceRequest(request, options = {}) {
-    const params = toGeminiGenerateContentParams(this.defaultModel, request);
+    const params = toGeminiGenerateContentParams(this.modelId, request);
     return providerRequestSummary(params, request, options);
   }
-  async completion(request) {
+  async completion(request, options) {
     assertCompletionRequestSupported(this, request);
-    const params = toGeminiGenerateContentParams(this.defaultModel, request);
+    const params = toGeminiGenerateContentParams(this.modelId, request);
+    applyAbortSignal(params, options);
     const response = await this.client.models.generateContent(params);
-    return withContextUsage(
-      fromGeminiGenerateContentResponse(response),
-      this.getModelInfo(request.model ?? this.defaultModel)
-    );
+    return withContextUsage(fromGeminiGenerateContentResponse(response), this.modelInfo());
   }
-  async *streamCompletion(request) {
+  async *streamCompletion(request, options) {
     assertCompletionRequestSupported(this, request, { streaming: true });
-    const params = toGeminiGenerateContentParams(this.defaultModel, request);
+    const params = toGeminiGenerateContentParams(this.modelId, request);
+    applyAbortSignal(params, options);
     const stream = await this.client.models.generateContentStream(params);
+    const streamState = new GeminiCompletionStreamState();
     for await (const chunk of stream) {
-      for (const event of fromGeminiGenerateContentStreamChunk(chunk)) {
-        yield event.type === "final" ? {
-          ...event,
-          response: withContextUsage(
-            event.response,
-            this.getModelInfo(request.model ?? this.defaultModel)
-          )
-        } : event;
+      const mapping = mapGeminiGenerateContentStreamChunk(chunk);
+      streamState.accept(chunk, mapping);
+      for (const event of mapping.events) {
+        if (event.type !== "final") {
+          yield event;
+        }
       }
     }
+    streamState.assertComplete();
+    const finalEvent = streamState.finalEvent();
+    if (finalEvent !== void 0) {
+      yield {
+        ...finalEvent,
+        response: withContextUsage(finalEvent.response, this.modelInfo())
+      };
+    }
   }
 };
-function toGeminiGenerateContentParams(defaultModel, request) {
+function toGeminiGenerateContentParams(modelId, request) {
   const messages = requestMessages(request);
-  const config = geminiConfig(request, messages);
+  if (request.providerOptions !== void 0 && (!isPlainObject2(request.providerOptions) || !isJsonValue(request.providerOptions))) {
+    throw new TypeError("Gemini providerOptions must be a JSON object.");
+  }
+  const providerOptions = request.providerOptions ?? {};
+  const { config: providerConfigValue, ...providerTopLevel } = providerOptions;
+  if (providerConfigValue !== void 0 && !isPlainObject2(providerConfigValue)) {
+    throw new TypeError("Gemini providerOptions.config must be a JSON object.");
+  }
+  const providerConfig = providerConfigValue === void 0 ? {} : { ...providerConfigValue };
+  delete providerConfig.tools;
+  const config = disableGeminiNativeRetries({
+    ...providerConfig,
+    ...geminiConfig(request, messages)
+  });
   const params = {
-    model: request.model ?? defaultModel,
+    ...providerTopLevel,
+    model: modelId,
     contents: messagesToGeminiContents(messages),
     config
   };
-  if (request.additionalParams !== void 0 && isPlainObject(request.additionalParams)) {
-    const { config: additionalConfig, ...additionalTopLevel } = request.additionalParams;
-    Object.assign(params, additionalTopLevel);
-    if (isPlainObject(additionalConfig)) {
-      params.config = { ...config, ...additionalConfig };
-    }
-  }
   return params;
 }
+function applyAbortSignal(params, options) {
+  if (options?.abortSignal === void 0) return;
+  const config = isPlainObject2(params.config) ? params.config : {};
+  params.config = { ...config, abortSignal: options.abortSignal };
+}
 function providerRequestSummary(params, request, options) {
-  const config = isPlainObject(params.config) ? params.config : {};
+  const config = isPlainObject2(params.config) ? params.config : {};
   return compactJsonObject({
     provider: "gemini",
     api: options.stream === true ? "models.generateContentStream" : "models.generateContent",
@@ -205,7 +170,7 @@ function providerRequestSummary(params, request, options) {
     temperature: request.temperature,
     maxTokens: request.maxTokens,
     toolChoice: toolChoiceSummary(request.toolChoice),
-    additionalParamKeys: isPlainObject(request.additionalParams) ? Object.keys(request.additionalParams).sort() : void 0
+    providerOptionKeys: isPlainObject2(request.providerOptions) ? Object.keys(request.providerOptions).sort() : void 0
   });
 }
 function toolChoiceSummary(toolChoice) {
@@ -217,10 +182,10 @@ function toolChoiceSummary(toolChoice) {
 function compactJsonObject(values) {
   return Object.fromEntries(
     Object.entries(values).flatMap(([key, value]) => {
-      if (value === void 0) {
+      if (!isJsonValue(value)) {
         return [];
       }
-      return [[key, toJsonValue(value)]];
+      return [[key, value]];
     })
   );
 }
@@ -269,11 +234,11 @@ function messagesToGeminiContents(messages) {
     }
     if (message.role === "assistant") {
       const content2 = assistantMessageToGeminiContent(message);
-      for (const item of message.content) {
-        if (item.type === "tool_call") {
-          toolNamesById.set(item.id, item.function.name);
+      for (const item of typeof message.content === "string" ? [] : message.content) {
+        if (item.type === "tool-call") {
+          toolNamesById.set(item.toolCallId, item.toolName);
           if (item.callId !== void 0) {
-            toolNamesById.set(item.callId, item.function.name);
+            toolNamesById.set(item.callId, item.toolName);
           }
         }
       }
@@ -292,19 +257,26 @@ function messagesToGeminiContents(messages) {
 function userMessageToGeminiContent(message) {
   return {
     role: "user",
-    parts: message.content.map(userContentToGeminiPart)
+    parts: typeof message.content === "string" ? [{ text: message.content }] : message.content.map(userContentToGeminiPart)
   };
 }
 function toolMessageToGeminiContent(message, toolNamesById) {
   return {
     role: "user",
-    parts: message.content.map((content) => toolContentToGeminiPart(content, toolNamesById))
+    parts: message.content.map((content) => {
+      if (content.type !== "tool-result") {
+        throw new TypeError(
+          "Anvia interaction responses must be resolved by Agent before provider calls."
+        );
+      }
+      return toolContentToGeminiPart(content, toolNamesById);
+    })
   };
 }
 function assistantMessageToGeminiContent(message) {
   return {
     role: "model",
-    parts: message.content.flatMap((content) => {
+    parts: typeof message.content === "string" ? [{ text: message.content }] : message.content.flatMap((content) => {
       if (content.type === "text") {
         const part = { text: content.text };
         if (content.signature !== void 0) {
@@ -312,10 +284,10 @@ function assistantMessageToGeminiContent(message) {
         }
         return [part];
       }
-      if (content.type === "tool_call") {
+      if (content.type === "tool-call") {
         const functionCall = {
-          name: content.function.name,
-          args: content.function.arguments ?? {}
+          name: content.toolName,
+          args: content.input
         };
         if (content.callId !== void 0) {
           functionCall.id = content.callId;
@@ -326,8 +298,8 @@ function assistantMessageToGeminiContent(message) {
         }
         return [part];
       }
-      if (content.type === "reasoning" && content.content !== void 0) {
-        return content.content.flatMap((reasoning) => {
+      if (content.type === "reasoning" && content.details !== void 0) {
+        return content.details.flatMap((reasoning) => {
           if (reasoning.type !== "text" && reasoning.type !== "summary") {
             return [];
           }
@@ -338,8 +310,10 @@ function assistantMessageToGeminiContent(message) {
           return [part];
         });
       }
-      if (content.type === "image") {
-        throw new Error("Gemini does not support image content in assistant history yet");
+      if (content.type === "image" || content.type === "file") {
+        throw new Error(
+          "Gemini does not support image or file content in assistant history yet"
+        );
       }
       return [];
     })
@@ -355,18 +329,18 @@ function userContentToGeminiPart(content) {
   return documentContentToGeminiPart(content);
 }
 function imageContentToGeminiPart(content) {
-  if (content.source.type === "base64") {
+  if (content.image.type === "data") {
     return {
       inlineData: {
-        mimeType: content.source.mediaType,
-        data: content.source.data
+        mimeType: content.mediaType ?? "image/png",
+        data: content.image.data
       }
     };
   }
   return {
     fileData: {
-      fileUri: content.source.url,
-      mimeType: mimeTypeFromImageUrl(content.source.url)
+      fileUri: content.image.url,
+      mimeType: content.mediaType ?? mimeTypeFromImageUrl(content.image.url)
     }
   };
 }
@@ -388,29 +362,29 @@ function safeUrlPathname(url) {
   }
 }
 function documentContentToGeminiPart(content) {
-  if (content.source.type === "text") {
-    return { text: content.source.text };
+  if (content.data.type === "text") {
+    return { text: content.data.text };
   }
-  if (content.source.type === "base64") {
+  if (content.data.type === "data") {
     return {
       inlineData: {
-        mimeType: content.source.mediaType,
-        data: content.source.data
+        mimeType: content.mediaType,
+        data: content.data.data
       }
     };
   }
   return {
     fileData: {
-      fileUri: content.source.url,
-      mimeType: content.source.mediaType
+      fileUri: content.data.url,
+      mimeType: content.mediaType
     }
   };
 }
 function toolContentToGeminiPart(content, toolNamesById) {
-  const id = content.callId ?? content.id;
+  const id = content.callId ?? content.toolCallId;
   const functionResponse = {
-    name: content.toolName ?? toolNamesById.get(id) ?? content.id,
-    response: toolResultResponse(content.content)
+    name: content.toolName || toolNamesById.get(id) || content.toolCallId,
+    response: toolResultResponse(content)
   };
   if (content.callId !== void 0) {
     functionResponse.id = content.callId;
@@ -418,10 +392,21 @@ function toolContentToGeminiPart(content, toolNamesById) {
   return { functionResponse };
 }
 function toolResultResponse(content) {
+  const output = content.output;
+  if (output.type === "json") {
+    return { result: output.value };
+  }
+  if (output.type === "text") {
+    return { content: output.value };
+  }
+  if (output.type === "error-json" || output.type === "error-text") {
+    return { error: output.value };
+  }
+  if (output.type === "execution-denied") {
+    return { error: output.reason ?? "Tool execution was denied." };
+  }
   return {
-    content: content.map(
-      (item) => item.type === "text" ? item.text : `[image:${item.mediaType ?? "image/png"}]`
-    ).join("\n")
+    content: output.value.map((item) => item.type === "text" ? item.text : `[file:${item.mediaType}]`).join("\n")
   };
 }
 function toolDefinitionToGemini(tool) {
@@ -449,29 +434,73 @@ function toolChoiceToGemini(toolChoice) {
   };
 }
 function fromGeminiGenerateContentResponse(response) {
-  const raw = response;
-  const choice = assistantContentFromGeminiResponse(raw);
+  const raw = isPlainObject2(response) ? response : {};
+  const usage = usageFromGemini(raw.usageMetadata);
+  const parts = candidateParts(raw, usage);
+  const providerFinishReason = providerFinishReasonFromGeminiResponse(raw);
+  const finishError = geminiToolFinishError(
+    providerFinishReason,
+    hasGeminiFunctionCallMarker(raw, parts),
+    usage
+  );
+  if (finishError !== void 0) throw finishError;
+  const choice = assistantContentFromGeminiResponse(raw, usage);
   const result = {
     choice,
-    usage: usageFromGemini(raw.usageMetadata),
+    usage,
     rawResponse: response
   };
+  applyGeminiFinishReason(result, raw);
   const id = stringFrom(raw.responseId) ?? stringFrom(raw.id);
   if (id !== void 0) {
     result.messageId = id;
   }
+  assertSafeGeminiCompletionResponse(result);
   return result;
 }
-function fromGeminiGenerateContentStreamChunk(chunk) {
-  if (!isPlainObject(chunk)) {
-    return [];
+function applyGeminiFinishReason(response, raw, hasStreamedToolCalls = false) {
+  const value = providerFinishReasonFromGeminiResponse(raw);
+  if (value === void 0) return;
+  applyGeminiFinishReasonValue(response, value, hasStreamedToolCalls);
+}
+function applyGeminiFinishReasonValue(response, value, hasStreamedToolCalls) {
+  response.finishReason = geminiFinishReason(
+    value,
+    hasStreamedToolCalls || response.choice.some((part) => part.type === "tool-call")
+  );
+  response.providerFinishReason = value;
+}
+function geminiFinishReason(value, hasToolCalls) {
+  if (value === "MAX_TOKENS") return "length";
+  if (value === "SAFETY" || value === "RECITATION" || value === "BLOCKLIST" || value === "PROHIBITED_CONTENT" || value === "SPII" || value === "IMAGE_SAFETY" || value === "IMAGE_PROHIBITED_CONTENT") {
+    return "content-filter";
+  }
+  if (value === "STOP") {
+    return hasToolCalls ? "tool-calls" : "stop";
+  }
+  return "other";
+}
+function mapGeminiGenerateContentStreamChunk(chunk) {
+  if (!isPlainObject2(chunk)) {
+    return {
+      events: [],
+      toolCalls: [],
+      hasToolCallMarker: false,
+      hasSyntheticToolCalls: false
+    };
   }
   const events = [];
-  const directText = typeof chunk.text === "string" ? chunk.text : "";
-  if (directText.length > 0 && candidateParts(chunk).length === 0) {
+  const usage = usageFromGemini(chunk.usageMetadata);
+  const parts = candidateParts(chunk, usage);
+  const providerFinishReason = providerFinishReasonFromGeminiResponse(chunk);
+  const hasToolCallMarker = hasGeminiFunctionCallMarker(chunk, parts);
+  const terminalError = providerFinishReason === void 0 ? void 0 : geminiToolFinishError(providerFinishReason, hasToolCallMarker, usage);
+  const calls = terminalError === void 0 ? functionCallsFromGeminiResponse(chunk, parts, usage) : [];
+  const directText = textFromGeminiResponse(chunk, parts);
+  if (terminalError === void 0 && directText.length > 0 && parts.length === 0) {
     events.push({ type: "text_delta", delta: directText });
   }
-  for (const part of candidateParts(chunk)) {
+  for (const { part } of terminalError === void 0 ? parts : []) {
     if (typeof part.text === "string" && part.text.length > 0) {
       if (part.thought === true) {
         events.push({ type: "reasoning_delta", delta: part.text, contentType: "summary" });
@@ -480,18 +509,22 @@ function fromGeminiGenerateContentStreamChunk(chunk) {
       }
     }
   }
-  for (const call of functionCallsFromGeminiResponse(chunk)) {
+  for (const call of calls) {
     events.push(
-      toolCallDelta(call.id ?? call.name, {
-        callId: call.id,
+      toolCallDelta(call.toolCallId, {
+        callId: call.callId,
         name: call.name,
         signature: call.signature
       })
     );
+    const argumentsDelta = JSON.stringify(call.args);
+    if (argumentsDelta === void 0) {
+      throw invalidGeminiToolCallArguments(call.toolCallId, usage);
+    }
     events.push(
-      toolCallDelta(call.id ?? call.name, {
-        callId: call.id,
-        argumentsDelta: JSON.stringify(call.args ?? {}),
+      toolCallDelta(call.toolCallId, {
+        callId: call.callId,
+        argumentsDelta,
         argumentsMode: "replace"
       })
     );
@@ -500,113 +533,522 @@ function fromGeminiGenerateContentStreamChunk(chunk) {
   if (id !== void 0) {
     events.push({ type: "message_id", id });
   }
-  if (isPlainObject(chunk.usageMetadata)) {
-    events.push({ type: "final", response: fromGeminiGenerateContentResponse(chunk) });
+  if (isPlainObject2(chunk.usageMetadata)) {
+    if (terminalError === void 0) {
+      events.push({ type: "final", response: fromGeminiGenerateContentResponse(chunk) });
+    } else {
+      const response = { choice: [], usage, rawResponse: chunk };
+      if (providerFinishReason !== void 0) {
+        applyGeminiFinishReasonValue(response, providerFinishReason, true);
+      }
+      events.push({ type: "final", response });
+    }
   }
-  return events;
+  return providerFinishReason === void 0 ? {
+    events,
+    toolCalls: calls.map(toolCallFromGeminiFunctionCall),
+    hasToolCallMarker,
+    hasSyntheticToolCalls: calls.some((call) => call.callId === void 0),
+    terminalError
+  } : {
+    events,
+    toolCalls: calls.map(toolCallFromGeminiFunctionCall),
+    hasToolCallMarker,
+    hasSyntheticToolCalls: calls.some((call) => call.callId === void 0),
+    providerFinishReason,
+    terminalError
+  };
 }
-function assistantContentFromGeminiResponse(response) {
-  const parts = candidateParts(response);
+var GeminiCompletionStreamState = class {
+  toolCalls = /* @__PURE__ */ new Map();
+  providerFinishReason;
+  terminalChunk;
+  finalResponse;
+  sawToolCallMarker = false;
+  sawSyntheticToolCallChunk = false;
+  terminalError;
+  accept(chunk, mapping) {
+    if (mapping.hasSyntheticToolCalls && this.sawSyntheticToolCallChunk) {
+      const toolCallId = mapping.toolCalls.find(
+        (toolCall) => toolCall.callId === void 0
+      )?.toolCallId;
+      throw toolCallId === void 0 ? new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        usage: this.currentUsage()
+      }) : invalidGeminiToolCall(toolCallId, this.currentUsage());
+    }
+    if (this.providerFinishReason !== void 0 && (mapping.hasToolCallMarker || hasGeminiSemanticProgress(mapping.events))) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        finishReason: "other",
+        usage: this.currentUsage()
+      });
+    }
+    for (const toolCall of mapping.toolCalls) {
+      const existing = this.toolCalls.get(toolCall.toolCallId);
+      if (existing !== void 0) {
+        if (existing.callId === void 0 || toolCall.callId === void 0 || !sameGeminiToolCall(existing, toolCall)) {
+          throw invalidGeminiToolCall(toolCall.toolCallId, this.currentUsage());
+        }
+        continue;
+      }
+      this.toolCalls.set(toolCall.toolCallId, toolCall);
+    }
+    this.sawToolCallMarker ||= mapping.hasToolCallMarker;
+    this.sawSyntheticToolCallChunk ||= mapping.hasSyntheticToolCalls;
+    for (const event of mapping.events) {
+      if (event.type === "final") {
+        this.finalResponse = event.response;
+      }
+    }
+    this.terminalError ??= mapping.terminalError;
+    if (mapping.providerFinishReason !== void 0) {
+      if (this.providerFinishReason !== void 0 && this.providerFinishReason !== mapping.providerFinishReason) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-tool-call",
+          finishReason: "other",
+          usage: this.currentUsage()
+        });
+      }
+      this.providerFinishReason = mapping.providerFinishReason;
+      this.terminalChunk = chunk;
+    }
+  }
+  assertComplete() {
+    if (this.terminalError !== void 0) {
+      throw geminiProviderOutputErrorWithUsage(this.terminalError, this.currentUsage());
+    }
+    if (!this.sawToolCallMarker && this.toolCalls.size === 0) return;
+    if (this.providerFinishReason !== void 0) {
+      assertSafeGeminiToolFinishReason(this.providerFinishReason, this.currentUsage());
+      return;
+    }
+    const toolCallId = this.toolCalls.keys().next().value;
+    throw new CompletionProviderOutputError(
+      toolCallId === void 0 ? { kind: "incomplete-tool-call", usage: this.currentUsage() } : { kind: "incomplete-tool-call", toolCallId, usage: this.currentUsage() }
+    );
+  }
+  finalEvent() {
+    let response = this.finalResponse;
+    if (response === void 0) {
+      if (this.terminalChunk === void 0) {
+        return void 0;
+      }
+      const raw = isPlainObject2(this.terminalChunk) ? this.terminalChunk : {};
+      response = {
+        choice: [],
+        usage: usageFromGemini(raw.usageMetadata),
+        rawResponse: this.terminalChunk
+      };
+      const messageId = stringFrom(raw.responseId) ?? stringFrom(raw.id);
+      if (messageId !== void 0) response.messageId = messageId;
+    }
+    response = mergeGeminiStreamToolCalls(response, [...this.toolCalls.values()]);
+    if (this.providerFinishReason !== void 0) {
+      applyGeminiFinishReasonValue(response, this.providerFinishReason, this.toolCalls.size > 0);
+    }
+    assertSafeGeminiCompletionResponse(response);
+    return { type: "final", response };
+  }
+  currentUsage() {
+    if (this.finalResponse !== void 0) {
+      return this.finalResponse.usage;
+    }
+    const raw = isPlainObject2(this.terminalChunk) ? this.terminalChunk : {};
+    return usageFromGemini(raw.usageMetadata);
+  }
+};
+function hasGeminiSemanticProgress(events) {
+  return events.some(
+    (event) => event.type === "text_delta" || event.type === "reasoning_delta" || event.type === "tool_call_delta" || event.type === "tool_call" || event.type === "provider_tool_call"
+  );
+}
+function sameGeminiToolCall(left, right) {
+  return left.toolName === right.toolName && left.callId === right.callId && left.signature === right.signature && sameJsonValue(left.input, right.input);
+}
+function sameJsonValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (isJsonArray(left) || isJsonArray(right)) {
+    return isJsonArray(left) && isJsonArray(right) && left.length === right.length && left.every((value, index) => {
+      const rightValue = right[index];
+      return rightValue !== void 0 && sameJsonValue(value, rightValue);
+    });
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key) => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key])
+  );
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function assistantContentFromGeminiResponse(response, usage) {
+  const parts = candidateParts(response, usage);
+  const calls = functionCallsFromGeminiResponse(response, parts, usage);
   if (parts.length === 0) {
-    const text = textFromGeminiResponse(response);
-    return text.length > 0 ? [AssistantContent.text(text)] : [];
+    const choice2 = [];
+    const text = textFromGeminiResponse(response, parts);
+    if (text.length > 0) choice2.push({ type: "text", text });
+    choice2.push(...calls.map(toolCallFromGeminiFunctionCall));
+    return choice2;
   }
+  const callsByPartIndex = new Map(calls.map((call) => [call.partIndex, call]));
   const choice = [];
-  for (const part of parts) {
+  for (const { index, part } of parts) {
     if (typeof part.text === "string" && part.text.length > 0) {
       if (part.thought === true) {
-        choice.push(AssistantContent.reasoningSummary(part.text));
+        choice.push({
+          type: "reasoning",
+          text: part.text,
+          details: [{ type: "summary", text: part.text }]
+        });
       } else {
-        const text = AssistantContent.text(part.text);
         const signature = thoughtSignatureFrom(part);
-        if (signature !== void 0) {
-          text.signature = signature;
-        }
+        let text = {
+          type: "text",
+          text: part.text
+        };
+        if (signature !== void 0) text = { ...text, signature };
         choice.push(text);
       }
     }
-    if (isPlainObject(part.functionCall)) {
-      const call = functionCallFromGeminiPart(part.functionCall, part);
-      if (call !== void 0) {
-        const toolCall = AssistantContent.toolCall(
-          call.id ?? crypto.randomUUID(),
-          call.name,
-          call.args,
-          call.id
-        );
-        if (call.signature !== void 0) {
-          toolCall.signature = call.signature;
-        }
-        choice.push(toolCall);
-      }
+    const call = callsByPartIndex.get(index);
+    if (call !== void 0) {
+      choice.push(toolCallFromGeminiFunctionCall(call));
     }
   }
   return choice;
 }
-function textFromGeminiResponse(response) {
-  if (typeof response.text === "string") {
-    return response.text;
+function textFromGeminiResponse(response, parts = candidateParts(response)) {
+  if (parts.length > 0) {
+    return parts.flatMap(
+      ({ part }) => part.thought !== true && typeof part.text === "string" ? [part.text] : []
+    ).join("");
   }
-  return candidateParts(response).flatMap((part) => part.thought !== true && typeof part.text === "string" ? [part.text] : []).join("");
+  if (hasGeminiCandidatePayload(response)) {
+    return "";
+  }
+  const directText = ownDataProperty(response, "text");
+  return typeof directText === "string" ? directText : "";
 }
-function functionCallsFromGeminiResponse(response) {
-  const directCalls = Array.isArray(response.functionCalls) ? response.functionCalls : Array.isArray(response.function_calls) ? response.function_calls : [];
-  const partCalls = candidateParts(response).flatMap((part) => {
-    if (!isPlainObject(part.functionCall)) {
-      return [];
-    }
-    const call = functionCallFromGeminiPart(part.functionCall, part);
-    return call === void 0 ? [] : [call];
-  });
-  const normalizedDirectCalls = directCalls.flatMap((call) => {
-    if (!isPlainObject(call) || typeof call.name !== "string") {
-      return [];
-    }
-    const normalized = {
-      name: call.name,
-      args: toJsonValue(call.args ?? {})
-    };
-    const id = stringFrom(call.id);
-    const signature = thoughtSignatureFrom(call);
-    if (id !== void 0) {
-      normalized.id = id;
-    }
-    if (signature !== void 0) {
-      normalized.signature = signature;
+function functionCallsFromGeminiResponse(response, parts, usage) {
+  if (parts.length > 0) {
+    const calls2 = parts.flatMap(({ index, part }) => {
+      if (part.functionCall === void 0) {
+        return [];
+      }
+      if (!isPlainObject2(part.functionCall)) {
+        throw invalidGeminiToolCall(deterministicGeminiToolCallId(index), usage);
+      }
+      return [functionCallFromGeminiPart(part.functionCall, part, index, usage)];
+    });
+    assertDistinctGeminiFunctionCalls(calls2, usage);
+    return calls2;
+  }
+  if (hasGeminiCandidatePayload(response)) {
+    return [];
+  }
+  const camelCaseCalls = ownDataProperty(response, "functionCalls");
+  const snakeCaseCalls = ownDataProperty(response, "function_calls");
+  const directCalls = Array.isArray(camelCaseCalls) ? camelCaseCalls : Array.isArray(snakeCaseCalls) ? snakeCaseCalls : [];
+  const calls = directCalls.map((call, index) => {
+    if (!isPlainObject2(call)) {
+      throw invalidGeminiToolCall(deterministicGeminiToolCallId(index), usage);
     }
-    return [normalized];
+    return functionCallFromGeminiPart(call, call, index, usage);
   });
-  return [...normalizedDirectCalls, ...partCalls];
+  assertDistinctGeminiFunctionCalls(calls, usage);
+  return calls;
 }
-function functionCallFromGeminiPart(call, part) {
-  if (typeof call.name !== "string") {
-    return void 0;
+function functionCallFromGeminiPart(call, part, partIndex, usage) {
+  const fallbackId = deterministicGeminiToolCallId(partIndex);
+  const rawCallId = call.id;
+  const callId = isNonblankString(rawCallId) ? rawCallId : void 0;
+  const toolCallId = callId ?? fallbackId;
+  if (rawCallId !== void 0 && callId === void 0) {
+    throw invalidGeminiToolCall(toolCallId, usage);
+  }
+  if (call.partialArgs !== void 0 || call.partial_args !== void 0 || call.willContinue !== void 0 || call.will_continue !== void 0) {
+    throw new CompletionProviderOutputError({
+      kind: "incomplete-tool-call",
+      toolCallId,
+      usage
+    });
+  }
+  const name = call.name;
+  if (!isNonblankString(name)) {
+    throw invalidGeminiToolCall(toolCallId, usage);
+  }
+  const args = call.args;
+  if (!isPlainObject2(args) || !isJsonValue(args)) {
+    throw invalidGeminiToolCallArguments(toolCallId, usage);
   }
   const normalized = {
-    name: call.name,
-    args: toJsonValue(call.args ?? {})
+    toolCallId,
+    name,
+    args,
+    partIndex
   };
-  const id = stringFrom(call.id);
   const signature = thoughtSignatureFrom(part) ?? thoughtSignatureFrom(call);
-  if (id !== void 0) {
-    normalized.id = id;
+  if (callId !== void 0) {
+    return signature === void 0 ? { ...normalized, callId } : { ...normalized, callId, signature };
   }
-  if (signature !== void 0) {
-    normalized.signature = signature;
+  return signature === void 0 ? normalized : { ...normalized, signature };
+}
+function candidateParts(response, usage) {
+  const candidate = primaryGeminiCandidate(response);
+  if (candidate === void 0 || candidate.content === void 0) {
+    return [];
+  }
+  if (!isPlainObject2(candidate.content)) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call", usage });
   }
-  return normalized;
+  if (candidate.content.parts === void 0) return [];
+  if (!Array.isArray(candidate.content.parts)) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call", usage });
+  }
+  if (candidate.content.parts.some((part) => !isPlainObject2(part))) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call", usage });
+  }
+  return candidate.content.parts.map((part, index) => ({
+    index,
+    part
+  }));
 }
-function candidateParts(response) {
-  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
-  return candidates.flatMap((candidate) => {
-    if (!isPlainObject(candidate) || !isPlainObject(candidate.content)) {
-      return [];
+function primaryGeminiCandidate(response) {
+  if (response.candidates === void 0) return void 0;
+  if (!Array.isArray(response.candidates)) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+  }
+  const candidates = response.candidates;
+  if (candidates.some(
+    (candidate2) => !isPlainObject2(candidate2) || candidate2.index !== void 0 && (!Number.isSafeInteger(candidate2.index) || candidate2.index < 0)
+  )) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+  }
+  const primaryCandidates = candidates.filter(
+    (candidate2) => isPlainObject2(candidate2) && candidate2.index === 0
+  );
+  if (primaryCandidates.length === 1) {
+    return primaryCandidates[0];
+  }
+  if (primaryCandidates.length > 1) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+  }
+  if (candidates.length === 0) return void 0;
+  if (candidates.length !== 1) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+  }
+  const candidate = candidates[0];
+  if (candidate.index !== void 0 && candidate.index !== 0) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+  }
+  return candidate;
+}
+function providerFinishReasonFromGeminiResponse(response) {
+  const candidateFinishReason = stringFrom(primaryGeminiCandidate(response)?.finishReason);
+  if (candidateFinishReason !== void 0) return candidateFinishReason;
+  const promptFeedback = response.promptFeedback ?? response.prompt_feedback;
+  if (promptFeedback === void 0) return void 0;
+  if (!isPlainObject2(promptFeedback)) {
+    throw new CompletionProviderOutputError({ kind: "invalid-response" });
+  }
+  const blockReason = promptFeedback.blockReason ?? promptFeedback.block_reason;
+  if (blockReason === void 0) return void 0;
+  if (typeof blockReason !== "string" || blockReason.length === 0) {
+    throw new CompletionProviderOutputError({ kind: "invalid-response" });
+  }
+  return blockReason;
+}
+function hasGeminiCandidatePayload(response) {
+  return Array.isArray(response.candidates) && response.candidates.length > 0;
+}
+function hasGeminiFunctionCallMarker(response, parts) {
+  if (parts.some(({ part }) => ownDataProperty(part, "functionCall") !== void 0)) {
+    return true;
+  }
+  if (hasGeminiCandidatePayload(response)) return false;
+  const camelCaseCalls = ownDataProperty(response, "functionCalls");
+  const snakeCaseCalls = ownDataProperty(response, "function_calls");
+  return Array.isArray(camelCaseCalls) && camelCaseCalls.length > 0 || Array.isArray(snakeCaseCalls) && snakeCaseCalls.length > 0;
+}
+function deterministicGeminiToolCallId(partIndex) {
+  return `gemini-tool-${partIndex.toString()}`;
+}
+function toolCallFromGeminiFunctionCall(call) {
+  let toolCall = {
+    type: "tool-call",
+    toolCallId: call.toolCallId,
+    toolName: call.name,
+    input: call.args
+  };
+  if (call.callId !== void 0) toolCall = { ...toolCall, callId: call.callId };
+  if (call.signature !== void 0) toolCall = { ...toolCall, signature: call.signature };
+  return toolCall;
+}
+function mergeGeminiStreamToolCalls(response, toolCalls) {
+  if (toolCalls.length === 0) return response;
+  const finalIds = new Set(
+    response.choice.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : [])
+  );
+  const missing = toolCalls.filter((toolCall) => !finalIds.has(toolCall.toolCallId));
+  return missing.length === 0 ? response : { ...response, choice: [...response.choice, ...missing] };
+}
+function assertSafeGeminiToolFinishReason(value, usage) {
+  const error = geminiToolFinishError(value, true, usage);
+  if (error !== void 0) throw error;
+}
+function geminiToolFinishError(value, hasToolCalls, usage) {
+  if (value === "MALFORMED_FUNCTION_CALL") {
+    return new CompletionProviderOutputError({ kind: "malformed-tool-arguments", usage });
+  }
+  if (value === "UNEXPECTED_TOOL_CALL" || value === "TOO_MANY_TOOL_CALLS") {
+    return new CompletionProviderOutputError({ kind: "invalid-tool-call", usage });
+  }
+  if (!hasToolCalls) return void 0;
+  if (value === void 0) {
+    return new CompletionProviderOutputError({ kind: "incomplete-tool-call", usage });
+  }
+  const finishReason = geminiFinishReason(value, true);
+  if (finishReason === "tool-calls") return void 0;
+  if (finishReason === "length") {
+    return new CompletionProviderOutputError({
+      kind: "truncated-tool-call",
+      finishReason,
+      usage
+    });
+  }
+  if (finishReason === "content-filter") {
+    return new CompletionProviderOutputError({
+      kind: "filtered-tool-call",
+      finishReason,
+      usage
+    });
+  }
+  return new CompletionProviderOutputError({ kind: "invalid-tool-call", finishReason, usage });
+}
+function assertSafeGeminiCompletionResponse(response) {
+  const toolCalls = response.choice.filter(
+    (part) => part.type === "tool-call"
+  );
+  if (toolCalls.length > 0) {
+    if (response.finishReason === void 0) {
+      throw new CompletionProviderOutputError({
+        kind: "incomplete-tool-call",
+        usage: response.usage
+      });
+    }
+    assertNormalizedGeminiToolFinishReason(response.finishReason, response.usage);
+  } else if (toolCalls.length === 0 && response.finishReason === "tool-calls") {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-call",
+      finishReason: response.finishReason,
+      usage: response.usage
+    });
+  }
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const callIds = /* @__PURE__ */ new Set();
+  for (const toolCall of toolCalls) {
+    if (toolCallIds.has(toolCall.toolCallId)) {
+      throw invalidGeminiToolCall(toolCall.toolCallId, response.usage);
+    }
+    toolCallIds.add(toolCall.toolCallId);
+    if (toolCall.callId !== void 0) {
+      if (callIds.has(toolCall.callId)) {
+        throw invalidGeminiToolCall(toolCall.toolCallId, response.usage);
+      }
+      callIds.add(toolCall.callId);
+    }
+  }
+}
+function assertDistinctGeminiFunctionCalls(calls, usage) {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const callIds = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (toolCallIds.has(call.toolCallId)) {
+      throw invalidGeminiToolCall(call.toolCallId, usage);
+    }
+    toolCallIds.add(call.toolCallId);
+    if (call.callId !== void 0) {
+      if (callIds.has(call.callId)) {
+        throw invalidGeminiToolCall(call.toolCallId, usage);
+      }
+      callIds.add(call.callId);
     }
-    return Array.isArray(candidate.content.parts) ? candidate.content.parts.filter(isPlainObject) : [];
+  }
+}
+function assertNormalizedGeminiToolFinishReason(finishReason, usage) {
+  if (finishReason === "stop" || finishReason === "tool-calls") return;
+  if (finishReason === "length") {
+    throw new CompletionProviderOutputError({
+      kind: "truncated-tool-call",
+      finishReason,
+      usage
+    });
+  }
+  if (finishReason === "content-filter") {
+    throw new CompletionProviderOutputError({
+      kind: "filtered-tool-call",
+      finishReason,
+      usage
+    });
+  }
+  throw new CompletionProviderOutputError({ kind: "invalid-tool-call", finishReason, usage });
+}
+function geminiProviderOutputErrorWithUsage(error, usage) {
+  if (error.kind === "truncated-tool-call") {
+    return new CompletionProviderOutputError({
+      kind: error.kind,
+      finishReason: "length",
+      toolCallId: error.toolCallId,
+      usage
+    });
+  }
+  if (error.kind === "filtered-tool-call") {
+    return new CompletionProviderOutputError({
+      kind: error.kind,
+      finishReason: "content-filter",
+      toolCallId: error.toolCallId,
+      usage
+    });
+  }
+  if (error.finishReason === "length" || error.finishReason === "content-filter") {
+    throw error;
+  }
+  return new CompletionProviderOutputError({
+    kind: error.kind,
+    finishReason: error.finishReason,
+    toolCallId: error.toolCallId,
+    usage
+  });
+}
+function invalidGeminiToolCall(toolCallId, usage) {
+  return new CompletionProviderOutputError({ kind: "invalid-tool-call", toolCallId, usage });
+}
+function invalidGeminiToolCallArguments(toolCallId, usage) {
+  return new CompletionProviderOutputError({
+    kind: "invalid-tool-arguments",
+    toolCallId,
+    usage
   });
 }
+function ownDataProperty(value, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isNonblankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
 function usageFromGemini(usage) {
-  const raw = isPlainObject(usage) ? usage : {};
+  const raw = isPlainObject2(usage) ? usage : {};
   const promptInputTokens = numberFrom(raw.promptTokenCount);
   const toolInputTokens = numberFrom(raw.toolUsePromptTokenCount);
   const inputTokens = promptInputTokens + toolInputTokens;
@@ -631,17 +1073,11 @@ function usageFromGemini(usage) {
     }
   };
 }
-function toJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) || isPlainObject(value)) {
-    return value;
-  }
-  return String(value);
-}
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberFrom(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
 }
 function stringFrom(value) {
   return typeof value === "string" ? value : void 0;
@@ -661,36 +1097,41 @@ function toolCallDelta(id, values) {
 
 // src/gemini/embedding.ts
 var GeminiEmbeddingModel = class {
-  constructor(client, model, options = {}) {
+  constructor(client, options) {
     this.client = client;
-    this.model = model;
+    this.modelId = options.modelId;
     this.dimensions = options.dimensions;
     this.maxBatchSize = options.maxBatchSize ?? 100;
     this.taskType = options.taskType;
     this.title = options.title;
   }
   client;
-  model;
+  provider = "gemini";
+  modelId;
   dimensions;
   maxBatchSize;
   taskType;
   title;
-  async embedTexts(texts) {
+  async embedTexts(texts, options) {
     const embeddings = [];
     for (let index = 0; index < texts.length; index += this.maxBatchSize) {
       const batch = texts.slice(index, index + this.maxBatchSize);
-      embeddings.push(...await this.embedBatch(batch));
+      embeddings.push(...await this.embedBatch(batch, options));
     }
     return embeddings;
   }
-  async embedBatch(texts) {
+  async embedBatch(texts, options) {
     if (texts.length === 0) {
       return [];
     }
+    const config = { ...this.embeddingConfig() };
+    if (options?.abortSignal !== void 0) {
+      Object.assign(config, { abortSignal: options.abortSignal });
+    }
     const response = await this.client.models.embedContent({
-      model: this.model,
+      model: this.modelId,
       contents: texts,
-      config: this.embeddingConfig()
+      config: disableGeminiNativeRetries(config)
     });
     const rawEmbeddings = embeddingsFromResponse(response);
     if (rawEmbeddings.length !== texts.length) {
@@ -740,54 +1181,60 @@ var GEMINI_2_5_FLASH_IMAGE = "gemini-2.5-flash-image";
 var GEMINI_3_PRO_IMAGE_PREVIEW = "gemini-3-pro-image-preview";
 var IMAGEN_4_GENERATE = "imagen-4.0-generate-001";
 var GeminiImageGenerationModel = class {
-  constructor(client, defaultModel = GEMINI_2_5_FLASH_IMAGE) {
+  constructor(client, modelId) {
     this.client = client;
-    this.defaultModel = defaultModel;
+    this.modelId = modelId;
   }
   client;
-  defaultModel;
+  modelId;
   provider = "gemini";
-  async imageGeneration(request) {
+  async imageGeneration(request, options) {
+    const providerOptions = isPlainObject3(request.providerOptions) ? request.providerOptions : {};
+    const { config: providerConfigValue, ...providerTopLevel } = providerOptions;
+    const providerConfig = isPlainObject3(providerConfigValue) ? providerConfigValue : {};
+    const providerImageConfig = isPlainObject3(providerConfig.imageConfig) ? providerConfig.imageConfig : {};
+    const config = {
+      ...providerConfig,
+      responseModalities: ["TEXT", "IMAGE"],
+      imageConfig: {
+        ...providerImageConfig,
+        aspectRatio: aspectRatio(request.width, request.height)
+      }
+    };
+    if (options?.abortSignal !== void 0) config.abortSignal = options.abortSignal;
     const params = {
-      model: this.defaultModel,
+      ...providerTopLevel,
+      model: this.modelId,
       contents: request.prompt,
-      config: {
-        responseModalities: ["TEXT", "IMAGE"],
-        imageConfig: { aspectRatio: aspectRatio(request.width, request.height) }
-      }
+      config: disableGeminiNativeRetries(config)
     };
-    if (isPlainObject2(request.additionalParams)) {
-      const { config, ...topLevel } = request.additionalParams;
-      Object.assign(params, topLevel);
-      if (isPlainObject2(config)) {
-        params.config = { ...params.config, ...config };
-      }
-    }
     const response = await this.client.models.generateContent(params);
     return nativeImageResponseFromGemini(response);
   }
 };
 var GeminiImagenGenerationModel = class {
-  constructor(client, defaultModel = IMAGEN_4_GENERATE) {
+  constructor(client, modelId) {
     this.client = client;
-    this.defaultModel = defaultModel;
+    this.modelId = modelId;
   }
   client;
-  defaultModel;
+  modelId;
   provider = "gemini";
-  async imageGeneration(request) {
+  async imageGeneration(request, options) {
+    const providerOptions = isPlainObject3(request.providerOptions) ? request.providerOptions : {};
+    const { config: providerConfigValue, ...providerTopLevel } = providerOptions;
+    const providerConfig = isPlainObject3(providerConfigValue) ? providerConfigValue : {};
+    const config = {
+      ...providerConfig,
+      aspectRatio: aspectRatio(request.width, request.height)
+    };
+    if (options?.abortSignal !== void 0) config.abortSignal = options.abortSignal;
     const params = {
-      model: this.defaultModel,
+      ...providerTopLevel,
+      model: this.modelId,
       prompt: request.prompt,
-      config: { aspectRatio: aspectRatio(request.width, request.height) }
+      config: disableGeminiNativeRetries(config)
     };
-    if (isPlainObject2(request.additionalParams)) {
-      const { config, ...topLevel } = request.additionalParams;
-      Object.assign(params, topLevel);
-      if (isPlainObject2(config)) {
-        params.config = { ...params.config, ...config };
-      }
-    }
     const response = await this.client.models.generateImages(params);
     return imagenResponseFromGemini(response);
   }
@@ -796,12 +1243,12 @@ function nativeImageResponseFromGemini(response) {
   const raw = response;
   const candidates = Array.isArray(raw.candidates) ? raw.candidates : [];
   const images = candidates.flatMap((candidate) => {
-    if (!isPlainObject2(candidate) || !isPlainObject2(candidate.content)) {
+    if (!isPlainObject3(candidate) || !isPlainObject3(candidate.content)) {
       return [];
     }
     const parts = Array.isArray(candidate.content.parts) ? candidate.content.parts : [];
     return parts.flatMap((part) => {
-      if (!isPlainObject2(part) || !isPlainObject2(part.inlineData)) {
+      if (!isPlainObject3(part) || !isPlainObject3(part.inlineData)) {
         return [];
       }
       const data = part.inlineData.data;
@@ -816,14 +1263,11 @@ function nativeImageResponseFromGemini(response) {
       ];
     });
   });
-  const image = images[0]?.data;
-  if (image === void 0) {
+  if (images.length === 0) {
     throw new Error("Gemini image generation response contained no inline image data.");
   }
   return {
-    image,
     images,
-    mediaType: images[0]?.mediaType,
     rawResponse: response
   };
 }
@@ -831,7 +1275,7 @@ function imagenResponseFromGemini(response) {
   const raw = response;
   const images = (Array.isArray(raw.generatedImages) ? raw.generatedImages : []).flatMap(
     (item) => {
-      if (!isPlainObject2(item) || !isPlainObject2(item.image)) {
+      if (!isPlainObject3(item) || !isPlainObject3(item.image)) {
         return [];
       }
       const imageBytes = item.image.imageBytes;
@@ -846,14 +1290,11 @@ function imagenResponseFromGemini(response) {
       ];
     }
   );
-  const image = images[0]?.data;
-  if (image === void 0) {
+  if (images.length === 0) {
     throw new Error("Gemini image generation response contained no base64 images.");
   }
   return {
-    image,
     images,
-    mediaType: images[0]?.mediaType,
     rawResponse: response
   };
 }
@@ -882,50 +1323,114 @@ function decodeBase64Image(value) {
   }
   return new Uint8Array(bytes);
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/gemini/models.ts
+var CONTEXT_1M_64K = {
+  contextWindow: 1048576,
+  maxInputTokens: 1048576,
+  maxOutputTokens: 65536
+};
+var GEMINI_COMPLETION_MODEL_CONTEXT_LIMITS = {
+  "gemini-2.0-flash": {
+    contextWindow: 1048576,
+    maxInputTokens: 1048576,
+    maxOutputTokens: 8192
+  },
+  "gemini-2.0-flash-lite": {
+    contextWindow: 1048576,
+    maxInputTokens: 1048576,
+    maxOutputTokens: 8192
+  },
+  "gemini-2.5-flash": CONTEXT_1M_64K,
+  "gemini-2.5-flash-image": {
+    contextWindow: 32768,
+    maxInputTokens: 32768,
+    maxOutputTokens: 32768
+  },
+  "gemini-2.5-flash-lite": CONTEXT_1M_64K,
+  "gemini-2.5-flash-preview-tts": {
+    contextWindow: 8192,
+    maxInputTokens: 8192,
+    maxOutputTokens: 16384
+  },
+  "gemini-2.5-pro": CONTEXT_1M_64K,
+  "gemini-2.5-pro-preview-tts": {
+    contextWindow: 8192,
+    maxInputTokens: 8192,
+    maxOutputTokens: 16384
+  },
+  "gemini-3-flash-preview": CONTEXT_1M_64K,
+  "gemini-3-pro-image-preview": {
+    contextWindow: 131072,
+    maxInputTokens: 131072,
+    maxOutputTokens: 32768
+  },
+  "gemini-3-pro-preview": CONTEXT_1M_64K,
+  "gemini-3.1-flash-image-preview": {
+    contextWindow: 65536,
+    maxInputTokens: 65536,
+    maxOutputTokens: 65536
+  },
+  "gemini-3.1-flash-lite": CONTEXT_1M_64K,
+  "gemini-3.1-flash-lite-preview": CONTEXT_1M_64K,
+  "gemini-3.1-pro-preview": CONTEXT_1M_64K,
+  "gemini-3.1-pro-preview-customtools": CONTEXT_1M_64K,
+  "gemini-3.5-flash": CONTEXT_1M_64K,
+  "gemini-flash-latest": CONTEXT_1M_64K,
+  "gemini-flash-lite-latest": CONTEXT_1M_64K,
+  "gemma-4-26b-a4b-it": {
+    contextWindow: 262144,
+    maxInputTokens: 262144,
+    maxOutputTokens: 32768
+  },
+  "gemma-4-31b-it": {
+    contextWindow: 262144,
+    maxInputTokens: 262144,
+    maxOutputTokens: 32768
+  }
+};
+
 // src/gemini/transcription.ts
 import { Buffer as Buffer3 } from "buffer";
 var TRANSCRIPTION_PREAMBLE = "Transcribe the provided audio exactly. Do not add additional information.";
 var GeminiTranscriptionModel = class {
-  constructor(client, defaultModel = "gemini-2.5-flash") {
+  constructor(client, modelId) {
     this.client = client;
-    this.defaultModel = defaultModel;
+    this.modelId = modelId;
   }
   client;
-  defaultModel;
+  modelId;
   provider = "gemini";
-  async transcription(request) {
-    const config = {};
+  async transcription(request, options) {
+    const config = isPlainObject4(request.providerOptions) ? { ...request.providerOptions } : {};
     if (request.temperature !== void 0) {
       config.temperature = request.temperature;
     }
-    if (isPlainObject3(request.additionalParams)) {
-      Object.assign(config, request.additionalParams);
-    }
+    if (options?.abortSignal !== void 0) config.abortSignal = options.abortSignal;
     const response = await this.client.models.generateContent({
-      model: this.defaultModel,
+      model: this.modelId,
       contents: [
         {
           role: "user",
           parts: [
             {
               inlineData: {
-                mimeType: mimeTypeFromFilename(request.filename),
+                mimeType: request.mediaType ?? mimeTypeFromFilename(request.filename),
                 data: Buffer3.from(request.data).toString("base64")
               }
             }
           ]
         }
       ],
-      config: {
+      config: disableGeminiNativeRetries({
         ...config,
         systemInstruction: request.prompt === void 0 ? TRANSCRIPTION_PREAMBLE : `${TRANSCRIPTION_PREAMBLE}
 
 ${request.prompt}`
-      }
+      })
     });
     return {
       text: textFromGenerateContentResponse(response),
@@ -940,12 +1445,12 @@ function textFromGenerateContentResponse(response) {
   }
   const candidates = Array.isArray(raw.candidates) ? raw.candidates : [];
   for (const candidate of candidates) {
-    if (!isPlainObject3(candidate) || !isPlainObject3(candidate.content)) {
+    if (!isPlainObject4(candidate) || !isPlainObject4(candidate.content)) {
       continue;
     }
     const parts = Array.isArray(candidate.content.parts) ? candidate.content.parts : [];
     for (const part of parts) {
-      if (isPlainObject3(part) && typeof part.text === "string") {
+      if (isPlainObject4(part) && typeof part.text === "string") {
         return part.text;
       }
     }
@@ -962,34 +1467,55 @@ function mimeTypeFromFilename(filename) {
   if (lower.endsWith(".opus")) return "audio/opus";
   return "audio/mpeg";
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/gemini/client.ts
 var GeminiClient = class {
-  client;
-  constructor(options = {}) {
-    this.client = options.client ?? new GoogleGenAI(toGoogleGenAIOptions(options));
-  }
-  completionModel(model = "gemini-2.5-flash") {
-    return new GeminiCompletionModel(this.client, model);
-  }
-  embeddingModel(model = "gemini-embedding-001", options = {}) {
-    return new GeminiEmbeddingModel(this.client, model, options);
+  sdk;
+  constructor(options) {
+    if (options.client !== void 0) {
+      rejectManagedOptionsWithInjectedClient(options, ["apiKey", "vertexAi"]);
+      this.sdk = options.client;
+      return;
+    }
+    this.sdk = new GoogleGenAI(toGoogleGenAIOptions(options));
+  }
+  completionModel(options) {
+    const modelId = requireModelId(options.modelId);
+    return new GeminiCompletionModel(
+      this.sdk,
+      modelId,
+      resolveModelContextLimits(
+        modelId,
+        GEMINI_COMPLETION_MODEL_CONTEXT_LIMITS,
+        options.contextLimits
+      )
+    );
   }
-  imageGenerationModel(model = GEMINI_2_5_FLASH_IMAGE) {
-    return new GeminiImageGenerationModel(this.client, model);
+  embeddingModel(options) {
+    requireModelId(options.modelId);
+    validateOptionalPositiveSafeInteger(options.dimensions, "dimensions");
+    validateOptionalPositiveSafeInteger(options.maxBatchSize, "maxBatchSize");
+    return new GeminiEmbeddingModel(this.sdk, options);
   }
-  imagenGenerationModel(model = IMAGEN_4_GENERATE) {
-    return new GeminiImagenGenerationModel(this.client, model);
+  imageGenerationModel(options) {
+    const modelId = requireModelId(options.modelId);
+    return options.api === "generateContent" ? new GeminiImageGenerationModel(this.sdk, modelId) : new GeminiImagenGenerationModel(this.sdk, modelId);
   }
-  transcriptionModel(model = "gemini-2.5-flash") {
-    return new GeminiTranscriptionModel(this.client, model);
+  transcriptionModel(options) {
+    return new GeminiTranscriptionModel(this.sdk, requireModelId(options.modelId));
   }
-  async listModels() {
+  async listModels(options = {}) {
     try {
-      const response = await this.client.models.list({ config: { pageSize: 1e3 } });
+      const config = { pageSize: 1e3 };
+      if (options.abortSignal !== void 0) {
+        Object.assign(config, { abortSignal: options.abortSignal });
+      }
+      const response = await this.sdk.models.list({
+        config: disableGeminiNativeRetries(config)
+      });
       const data = (await collectModelsFromResponse(response)).map(toListedModel).filter(isListedModel);
       return { data };
     } catch (error) {
@@ -997,25 +1523,48 @@ var GeminiClient = class {
     }
   }
 };
+function rejectManagedOptionsWithInjectedClient(options, keys) {
+  const conflict = keys.find((key) => key in options);
+  if (conflict !== void 0) {
+    throw new TypeError(`GeminiClient cannot combine client with ${conflict}.`);
+  }
+}
 function toGoogleGenAIOptions(options) {
-  if (options.vertexai === true) {
-    return {
+  if ("client" in options && options.client !== void 0) {
+    throw new TypeError("Injected Gemini clients do not have managed SDK options.");
+  }
+  if ("vertexAi" in options && options.vertexAi !== void 0) {
+    const sdkOptions = {
       vertexai: true,
-      project: requireOption(options.project, "project", "Vertex Gemini"),
-      location: requireOption(options.location, "location", "Vertex Gemini"),
-      ...options.googleAuthOptions === void 0 ? {} : { googleAuthOptions: options.googleAuthOptions }
+      project: requireOption(options.vertexAi.projectId, "projectId", "Vertex Gemini"),
+      location: requireOption(options.vertexAi.location, "location", "Vertex Gemini")
     };
+    if (options.vertexAi.googleAuthOptions !== void 0) {
+      sdkOptions.googleAuthOptions = options.vertexAi.googleAuthOptions;
+    }
+    return sdkOptions;
   }
   return {
     apiKey: requireOption(options.apiKey, "apiKey", "Gemini")
   };
 }
 function requireOption(value, name, label) {
-  if (value === void 0 || value.length === 0) {
+  if (value === void 0 || value.trim().length === 0) {
     throw new Error(`Missing ${label} ${name}. Pass ${name} when constructing GeminiClient.`);
   }
   return value;
 }
+function requireModelId(modelId) {
+  if (modelId.trim().length === 0) {
+    throw new TypeError("modelId must be a non-empty string");
+  }
+  return modelId;
+}
+function validateOptionalPositiveSafeInteger(value, name) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+}
 async function collectModelsFromResponse(response) {
   if (isAsyncIterable(response)) {
     const models = [];
@@ -1116,11 +1665,6 @@ export {
   GEMINI_2_5_FLASH_IMAGE,
   GEMINI_3_PRO_IMAGE_PREVIEW,
   GeminiClient,
-  GeminiCompletionModel,
-  GeminiEmbeddingModel,
-  GeminiImageGenerationModel,
-  GeminiImagenGenerationModel,
-  GeminiTranscriptionModel,
   IMAGEN_4_GENERATE,
   gemini_exports as gemini
 };