@anvia/gemini 1.0.0-rc.1 → 1.0.0-rc.3

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,7 @@ import { GoogleGenAI } from "@google/genai";
 
 // src/gemini/completion.ts
 import {
-  AssistantContent,
   assertCompletionRequestSupported,
-  resolveCompletionModelInfo,
   Usage,
   withContextUsage
 } from "@anvia/core/completion";
@@ -48,82 +44,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 +83,60 @@ 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);
     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)
-          )
+          response: withContextUsage(event.response, this.modelInfo())
         } : event;
       }
     }
   }
 };
-function toGeminiGenerateContentParams(defaultModel, request) {
+function toGeminiGenerateContentParams(modelId, request) {
   const messages = requestMessages(request);
-  const config = geminiConfig(request, messages);
+  const providerOptions = isPlainObject2(request.providerOptions) ? request.providerOptions : {};
+  const { config: providerConfigValue, ...providerTopLevel } = providerOptions;
+  const providerConfig = isPlainObject2(providerConfigValue) ? { ...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 +152,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) {
@@ -269,11 +216,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 +239,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 +266,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 +280,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 +292,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 +311,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 +344,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 +374,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) {
@@ -463,7 +430,7 @@ function fromGeminiGenerateContentResponse(response) {
   return result;
 }
 function fromGeminiGenerateContentStreamChunk(chunk) {
-  if (!isPlainObject(chunk)) {
+  if (!isPlainObject2(chunk)) {
     return [];
   }
   const events = [];
@@ -500,7 +467,7 @@ function fromGeminiGenerateContentStreamChunk(chunk) {
   if (id !== void 0) {
     events.push({ type: "message_id", id });
   }
-  if (isPlainObject(chunk.usageMetadata)) {
+  if (isPlainObject2(chunk.usageMetadata)) {
     events.push({ type: "final", response: fromGeminiGenerateContentResponse(chunk) });
   }
   return events;
@@ -509,34 +476,39 @@ function assistantContentFromGeminiResponse(response) {
   const parts = candidateParts(response);
   if (parts.length === 0) {
     const text = textFromGeminiResponse(response);
-    return text.length > 0 ? [AssistantContent.text(text)] : [];
+    return text.length > 0 ? [{ type: "text", text }] : [];
   }
   const choice = [];
   for (const 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)) {
+    if (isPlainObject2(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;
-        }
+        const toolCallId = call.id ?? crypto.randomUUID();
+        let toolCall = {
+          type: "tool-call",
+          toolCallId,
+          toolName: call.name,
+          input: call.args
+        };
+        if (call.id !== void 0) toolCall = { ...toolCall, callId: call.id };
+        if (call.signature !== void 0) toolCall = { ...toolCall, signature: call.signature };
         choice.push(toolCall);
       }
     }
@@ -552,14 +524,14 @@ function textFromGeminiResponse(response) {
 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)) {
+    if (!isPlainObject2(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") {
+    if (!isPlainObject2(call) || typeof call.name !== "string") {
       return [];
     }
     const normalized = {
@@ -599,14 +571,14 @@ function functionCallFromGeminiPart(call, part) {
 function candidateParts(response) {
   const candidates = Array.isArray(response.candidates) ? response.candidates : [];
   return candidates.flatMap((candidate) => {
-    if (!isPlainObject(candidate) || !isPlainObject(candidate.content)) {
+    if (!isPlainObject2(candidate) || !isPlainObject2(candidate.content)) {
       return [];
     }
-    return Array.isArray(candidate.content.parts) ? candidate.content.parts.filter(isPlainObject) : [];
+    return Array.isArray(candidate.content.parts) ? candidate.content.parts.filter(isPlainObject2) : [];
   });
 }
 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;
@@ -632,12 +604,12 @@ function usageFromGemini(usage) {
   };
 }
 function toJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) || isPlainObject(value)) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) || isPlainObject2(value)) {
     return value;
   }
   return String(value);
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberFrom(value) {
@@ -661,36 +633,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 +717,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 +779,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 +799,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 +811,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 +826,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 +859,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 +981,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 +1003,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 +1059,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 +1201,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
 };