@anvia/gemini 1.0.0-rc.6 → 1.0.0

package/dist/index.js

@@ -8,6 +8,9 @@ var __export = (target, all) => {
 var gemini_exports = {};
 __export(gemini_exports, {
   GEMINI_2_5_FLASH_IMAGE: () => GEMINI_2_5_FLASH_IMAGE,
+  GEMINI_3_1_FLASH_IMAGE: () => GEMINI_3_1_FLASH_IMAGE,
+  GEMINI_3_1_FLASH_LITE_IMAGE: () => GEMINI_3_1_FLASH_LITE_IMAGE,
+  GEMINI_3_PRO_IMAGE: () => GEMINI_3_PRO_IMAGE,
   GEMINI_3_PRO_IMAGE_PREVIEW: () => GEMINI_3_PRO_IMAGE_PREVIEW,
   GeminiClient: () => GeminiClient,
   IMAGEN_4_GENERATE: () => IMAGEN_4_GENERATE
@@ -25,6 +28,8 @@ import { GoogleGenAI } from "@google/genai";
 // src/gemini/completion.ts
 import {
   assertCompletionRequestSupported,
+  CompletionProviderOutputError,
+  isJsonValue,
   Usage,
   withContextUsage
 } from "@anvia/core/completion";
@@ -102,21 +107,37 @@ var GeminiCompletionModel = class {
     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.modelInfo())
-        } : 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(modelId, request) {
   const messages = requestMessages(request);
-  const providerOptions = isPlainObject2(request.providerOptions) ? request.providerOptions : {};
+  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;
-  const providerConfig = isPlainObject2(providerConfigValue) ? { ...providerConfigValue } : {};
+  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,
@@ -164,10 +185,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]];
     })
   );
 }
@@ -416,11 +437,20 @@ 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);
@@ -428,34 +458,52 @@ function fromGeminiGenerateContentResponse(response) {
   if (id !== void 0) {
     result.messageId = id;
   }
+  assertSafeGeminiCompletionResponse(result);
   return result;
 }
-function applyGeminiFinishReason(response, raw) {
-  const value = stringFrom(primaryGeminiCandidate(raw)?.finishReason);
+function applyGeminiFinishReason(response, raw, hasStreamedToolCalls = false) {
+  const value = providerFinishReasonFromGeminiResponse(raw);
   if (value === void 0) return;
-  response.finishReason = geminiFinishReason(value, response.choice);
+  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, choice) {
+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 choice.some((part) => part.type === "tool-call") ? "tool-calls" : "stop";
+    return hasToolCalls ? "tool-calls" : "stop";
   }
   return "other";
 }
-function fromGeminiGenerateContentStreamChunk(chunk) {
+function mapGeminiGenerateContentStreamChunk(chunk) {
   if (!isPlainObject2(chunk)) {
-    return [];
+    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" });
@@ -464,18 +512,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"
       })
     );
@@ -485,18 +537,171 @@ function fromGeminiGenerateContentStreamChunk(chunk) {
     events.push({ type: "message_id", id });
   }
   if (isPlainObject2(chunk.usageMetadata)) {
-    events.push({ type: "final", response: fromGeminiGenerateContentResponse(chunk) });
+    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 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
+  };
+}
+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() }
+    );
   }
-  return events;
+  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 assistantContentFromGeminiResponse(response) {
-  const parts = candidateParts(response);
+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 ? [{ type: "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({
@@ -514,89 +719,336 @@ function assistantContentFromGeminiResponse(response) {
         choice.push(text);
       }
     }
-    if (isPlainObject2(part.functionCall)) {
-      const call = functionCallFromGeminiPart(part.functionCall, part);
-      if (call !== void 0) {
-        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);
-      }
+    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 (!isPlainObject2(part.functionCall)) {
-      return [];
-    }
-    const call = functionCallFromGeminiPart(part.functionCall, part);
-    return call === void 0 ? [] : [call];
-  });
-  const normalizedDirectCalls = directCalls.flatMap((call) => {
-    if (!isPlainObject2(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];
-}
-function functionCallFromGeminiPart(call, part) {
-  if (typeof call.name !== "string") {
-    return void 0;
+  assertDistinctGeminiFunctionCalls(calls, usage);
+  return calls;
+}
+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 };
+  }
+  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 });
   }
-  if (signature !== void 0) {
-    normalized.signature = signature;
+  if (candidate.content.parts === void 0) return [];
+  if (!Array.isArray(candidate.content.parts)) {
+    throw new CompletionProviderOutputError({ kind: "invalid-tool-call", usage });
   }
-  return normalized;
+  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 (!isPlainObject2(candidate) || !isPlainObject2(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);
     }
-    return Array.isArray(candidate.content.parts) ? candidate.content.parts.filter(isPlainObject2) : [];
+    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);
+    }
+  }
+}
+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 primaryGeminiCandidate(response) {
-  const candidates = Array.isArray(response.candidates) ? response.candidates.filter(isPlainObject2) : [];
-  return candidates.find((candidate) => candidate.index === 0) ?? candidates[0];
+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 = isPlainObject2(usage) ? usage : {};
@@ -624,17 +1076,11 @@ function usageFromGemini(usage) {
     }
   };
 }
-function toJsonValue(value) {
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) || isPlainObject2(value)) {
-    return value;
-  }
-  return String(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;
@@ -735,6 +1181,9 @@ function isNumberArray(value) {
 // src/gemini/image-generation.ts
 import { Buffer as Buffer2 } from "buffer";
 var GEMINI_2_5_FLASH_IMAGE = "gemini-2.5-flash-image";
+var GEMINI_3_1_FLASH_IMAGE = "gemini-3.1-flash-image";
+var GEMINI_3_1_FLASH_LITE_IMAGE = "gemini-3.1-flash-lite-image";
+var GEMINI_3_PRO_IMAGE = "gemini-3-pro-image";
 var GEMINI_3_PRO_IMAGE_PREVIEW = "gemini-3-pro-image-preview";
 var IMAGEN_4_GENERATE = "imagen-4.0-generate-001";
 var GeminiImageGenerationModel = class {
@@ -931,11 +1380,29 @@ var GEMINI_COMPLETION_MODEL_CONTEXT_LIMITS = {
     maxInputTokens: 65536,
     maxOutputTokens: 65536
   },
+  "gemini-3.1-flash-image": {
+    contextWindow: 131072,
+    maxInputTokens: 131072,
+    maxOutputTokens: 32768
+  },
+  "gemini-3.1-flash-lite-image": {
+    contextWindow: 65536,
+    maxInputTokens: 65536,
+    maxOutputTokens: 4096
+  },
   "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-3.5-flash-lite": CONTEXT_1M_64K,
+  "gemini-3.6-flash": CONTEXT_1M_64K,
+  "gemini-3.7-flash": CONTEXT_1M_64K,
+  "gemini-3-pro-image": {
+    contextWindow: 65536,
+    maxInputTokens: 65536,
+    maxOutputTokens: 32768
+  },
   "gemini-flash-latest": CONTEXT_1M_64K,
   "gemini-flash-lite-latest": CONTEXT_1M_64K,
   "gemma-4-26b-a4b-it": {
@@ -1220,6 +1687,9 @@ function isAsyncIterable(value) {
 }
 export {
   GEMINI_2_5_FLASH_IMAGE,
+  GEMINI_3_1_FLASH_IMAGE,
+  GEMINI_3_1_FLASH_LITE_IMAGE,
+  GEMINI_3_PRO_IMAGE,
   GEMINI_3_PRO_IMAGE_PREVIEW,
   GeminiClient,
   IMAGEN_4_GENERATE,