@standardagents/google 0.0.1-dev.ffffff

package/dist/index.js

@@ -0,0 +1,1140 @@
+// src/GoogleProvider.ts
+import {
+  GoogleGenAI,
+  FunctionCallingConfigMode,
+  createPartFromBase64,
+  createPartFromFunctionResponse,
+  RawReferenceImage
+} from "@google/genai/web";
+import { ProviderError } from "@standardagents/spec";
+
+// src/icons.ts
+var GOOGLE_ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none"><rect width="64" height="64" rx="16" fill="#fff"/><path d="M54 32.73c0-1.58-.14-3.1-.4-4.55H32v8.61h12.33c-.53 2.85-2.14 5.27-4.56 6.9v5.73h7.38C51.47 45.44 54 39.61 54 32.73Z" fill="#4285F4"/><path d="M32 55c6.2 0 11.4-2.05 15.2-5.58l-7.38-5.73c-2.05 1.37-4.67 2.18-7.82 2.18-6 0-11.08-4.05-12.9-9.49h-7.62v5.96A22.98 22.98 0 0 0 32 55Z" fill="#34A853"/><path d="M19.1 36.38A13.8 13.8 0 0 1 18.38 32c0-1.52.26-3 .72-4.38v-5.96h-7.62A22.98 22.98 0 0 0 9 32c0 3.67.88 7.13 2.48 10.34l7.62-5.96Z" fill="#FBBC05"/><path d="M32 18.9c3.37 0 6.4 1.16 8.79 3.45l6.59-6.59C43.39 12.05 38.19 9 32 9A22.98 22.98 0 0 0 11.48 21.66l7.62 5.96C20.92 22.95 26 18.9 32 18.9Z" fill="#EA4335"/></svg>`;
+function svgToDataUri(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+function getGoogleIconDataUri() {
+  return svgToDataUri(GOOGLE_ICON);
+}
+
+// src/pricing.ts
+var MODEL_PRICING = {
+  "gemini-3-pro-preview": {
+    inputPerMillion: 2,
+    outputPerMillion: 12,
+    cachedInputPerMillion: 0.2
+  },
+  "gemini-3.1-pro-preview": {
+    inputPerMillion: 2,
+    longInputPerMillion: 4,
+    outputPerMillion: 12,
+    longOutputPerMillion: 18,
+    cachedInputPerMillion: 0.2,
+    longCachedInputPerMillion: 0.4,
+    longContextThreshold: 2e5
+  },
+  "gemini-2.5-pro": {
+    inputPerMillion: 1.25,
+    longInputPerMillion: 2.5,
+    outputPerMillion: 10,
+    longOutputPerMillion: 15,
+    cachedInputPerMillion: 0.125,
+    longCachedInputPerMillion: 0.25,
+    longContextThreshold: 2e5
+  },
+  "gemini-2.5-flash": {
+    inputPerMillion: 0.3,
+    outputPerMillion: 2.5,
+    cachedInputPerMillion: 0.03
+  },
+  "gemini-2.5-flash-lite": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cachedInputPerMillion: 0.01
+  },
+  "gemini-3-flash-preview": {
+    inputPerMillion: 0.5,
+    outputPerMillion: 3,
+    cachedInputPerMillion: 0.05,
+    inputByModalityPerMillion: {
+      text: 0.5,
+      image: 0.5,
+      video: 0.5,
+      audio: 1
+    },
+    cachedByModalityPerMillion: {
+      text: 0.05,
+      image: 0.05,
+      video: 0.05,
+      audio: 0.1
+    }
+  },
+  "gemini-3.1-flash-lite-preview": {
+    inputPerMillion: 0.25,
+    outputPerMillion: 1.5,
+    cachedInputPerMillion: 0.025,
+    inputByModalityPerMillion: {
+      text: 0.25,
+      image: 0.25,
+      video: 0.25,
+      audio: 0.5
+    },
+    cachedByModalityPerMillion: {
+      text: 0.025,
+      image: 0.025,
+      video: 0.025,
+      audio: 0.05
+    }
+  },
+  "deep-research-pro-preview-12-2025": {
+    inputPerMillion: 2,
+    outputPerMillion: 12,
+    cachedInputPerMillion: 0.2
+  },
+  "gemini-2.0-flash": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cachedInputPerMillion: 0.025,
+    inputByModalityPerMillion: {
+      text: 0.1,
+      image: 0.1,
+      video: 0.1,
+      audio: 0.7
+    },
+    cachedByModalityPerMillion: {
+      text: 0.025,
+      image: 0.025,
+      video: 0.025,
+      audio: 0.175
+    }
+  },
+  "gemini-2.0-flash-001": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cachedInputPerMillion: 0.025,
+    inputByModalityPerMillion: {
+      text: 0.1,
+      image: 0.1,
+      video: 0.1,
+      audio: 0.7
+    },
+    cachedByModalityPerMillion: {
+      text: 0.025,
+      image: 0.025,
+      video: 0.025,
+      audio: 0.175
+    }
+  },
+  "gemini-2.0-flash-lite": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  },
+  "gemini-2.0-flash-lite-001": {
+    inputPerMillion: 0.075,
+    outputPerMillion: 0.3
+  },
+  "gemini-2.5-computer-use-preview-10-2025": {
+    inputPerMillion: 1.25,
+    longInputPerMillion: 2.5,
+    outputPerMillion: 10,
+    longOutputPerMillion: 15,
+    longContextThreshold: 2e5
+  },
+  "gemini-2.5-flash-preview-tts": {
+    inputPerMillion: 0.5,
+    outputPerMillion: 10,
+    outputByModalityPerMillion: {
+      audio: 10
+    }
+  },
+  "gemini-2.5-pro-preview-tts": {
+    inputPerMillion: 1,
+    outputPerMillion: 20,
+    outputByModalityPerMillion: {
+      audio: 20
+    }
+  },
+  "gemini-robotics-er-1.5-preview": {
+    inputPerMillion: 0.3,
+    outputPerMillion: 2.5,
+    inputByModalityPerMillion: {
+      text: 0.3,
+      image: 0.3,
+      video: 0.3,
+      audio: 1
+    }
+  },
+  "gemini-2.5-flash-image": {
+    inputPerMillion: 0.3,
+    outputImagePerImage: 0.039
+  },
+  "gemini-3.1-flash-image-preview": {
+    inputPerMillion: 0.5,
+    outputPerMillion: 3,
+    outputImagePerImage: 0.045
+  },
+  "gemini-3-pro-image-preview": {
+    inputPerMillion: 2,
+    outputPerMillion: 12,
+    outputImagePerImage: 0.134
+  },
+  "nano-banana-pro-preview": {
+    inputPerMillion: 2,
+    outputPerMillion: 12,
+    outputImagePerImage: 0.134
+  },
+  "imagen-4.0-generate-001": {
+    inputPerMillion: 0,
+    outputImagePerImage: 0.04
+  },
+  "imagen-4.0-fast-generate-001": {
+    inputPerMillion: 0,
+    outputImagePerImage: 0.02
+  },
+  "imagen-4.0-ultra-generate-001": {
+    inputPerMillion: 0,
+    outputImagePerImage: 0.06
+  },
+  "imagen-3.0-capability-001": {
+    inputPerMillion: 0,
+    outputImagePerImage: 0.04
+  },
+  "gemma-4-31b-it": {
+    inputPerMillion: 0,
+    outputPerMillion: 0,
+    cachedInputPerMillion: 0
+  }
+};
+var MODEL_PRICING_PREFIXES = [
+  {
+    prefix: "gemini-3.1-pro-preview",
+    pricing: MODEL_PRICING["gemini-3.1-pro-preview"]
+  },
+  {
+    prefix: "gemini-3-pro-preview",
+    pricing: MODEL_PRICING["gemini-3-pro-preview"]
+  },
+  {
+    prefix: "gemini-3-flash-preview",
+    pricing: MODEL_PRICING["gemini-3-flash-preview"]
+  },
+  {
+    prefix: "gemini-3.1-flash-lite-preview",
+    pricing: MODEL_PRICING["gemini-3.1-flash-lite-preview"]
+  },
+  {
+    prefix: "gemini-2.5-flash-lite-preview-",
+    pricing: MODEL_PRICING["gemini-2.5-flash-lite"]
+  },
+  {
+    prefix: "gemini-flash-latest",
+    pricing: MODEL_PRICING["gemini-2.5-flash"]
+  },
+  {
+    prefix: "gemini-flash-lite-latest",
+    pricing: MODEL_PRICING["gemini-2.5-flash-lite"]
+  },
+  {
+    prefix: "gemini-pro-latest",
+    pricing: MODEL_PRICING["gemini-2.5-pro"]
+  },
+  {
+    prefix: "gemma-4-",
+    pricing: {
+      inputPerMillion: 0,
+      outputPerMillion: 0,
+      cachedInputPerMillion: 0
+    }
+  },
+  {
+    prefix: "gemma-3-",
+    pricing: {
+      inputPerMillion: 0,
+      outputPerMillion: 0,
+      cachedInputPerMillion: 0
+    }
+  },
+  {
+    prefix: "gemma-3n-",
+    pricing: {
+      inputPerMillion: 0,
+      outputPerMillion: 0,
+      cachedInputPerMillion: 0
+    }
+  }
+];
+function normalizeGoogleModelId(modelId) {
+  return modelId.trim().toLowerCase().replace(/^google\//, "").replace(/^models\//, "").replace(/^publishers\/google\/models\//, "");
+}
+function normalizeModality(modality) {
+  const normalized = (modality || "").trim().toLowerCase();
+  if (normalized === "text") return "text";
+  if (normalized === "image") return "image";
+  if (normalized === "video") return "video";
+  if (normalized === "audio") return "audio";
+  if (normalized === "document") return "document";
+  return "unspecified";
+}
+function toModalityCounts(details) {
+  const counts = {};
+  for (const detail of details || []) {
+    const modality = normalizeModality(detail.modality);
+    const tokenCount = Math.max(detail.tokenCount ?? 0, 0);
+    counts[modality] = (counts[modality] ?? 0) + tokenCount;
+  }
+  return counts;
+}
+function sumModalityCosts(counts, modalityRates, defaultRate) {
+  let total = 0;
+  for (const [modality, tokenCount] of Object.entries(counts)) {
+    if (!tokenCount) continue;
+    const rate = modalityRates?.[modality] ?? defaultRate;
+    total += tokenCount / 1e6 * rate;
+  }
+  return total;
+}
+function getGoogleModelPricing(modelId) {
+  const normalizedModelId = normalizeGoogleModelId(modelId);
+  const exact = MODEL_PRICING[normalizedModelId];
+  if (exact) return exact;
+  return MODEL_PRICING_PREFIXES.find((entry) => normalizedModelId.startsWith(entry.prefix))?.pricing;
+}
+function calculateGoogleUsageCost(modelId, usage, imageCount = 0) {
+  const pricing = getGoogleModelPricing(modelId);
+  if (!pricing) return void 0;
+  const cachedTokens = usage.cachedTokens ?? 0;
+  const uncachedPromptTokens = Math.max(0, usage.promptTokens - cachedTokens);
+  const useLongContext = pricing.longContextThreshold != null && usage.promptTokens > pricing.longContextThreshold;
+  const inputRate = useLongContext ? pricing.longInputPerMillion ?? pricing.inputPerMillion : pricing.inputPerMillion;
+  const outputRate = useLongContext ? pricing.longOutputPerMillion ?? pricing.outputPerMillion ?? 0 : pricing.outputPerMillion ?? 0;
+  const cachedRate = useLongContext ? pricing.longCachedInputPerMillion ?? pricing.cachedInputPerMillion ?? 0 : pricing.cachedInputPerMillion ?? 0;
+  const billableOutputTokens = usage.completionTokens + (usage.reasoningTokens ?? 0);
+  const promptModalityCounts = toModalityCounts(usage.promptTokenDetails);
+  const cachedModalityCounts = toModalityCounts(usage.cachedTokenDetails);
+  const uncachedPromptModalityCounts = {};
+  for (const modality of /* @__PURE__ */ new Set([
+    ...Object.keys(promptModalityCounts),
+    ...Object.keys(cachedModalityCounts)
+  ])) {
+    uncachedPromptModalityCounts[modality] = Math.max(
+      (promptModalityCounts[modality] ?? 0) - (cachedModalityCounts[modality] ?? 0),
+      0
+    );
+  }
+  const completionModalityCounts = toModalityCounts(usage.completionTokenDetails);
+  if (usage.reasoningTokens) {
+    completionModalityCounts.text = (completionModalityCounts.text ?? 0) + usage.reasoningTokens;
+  }
+  const hasPromptModalityPricing = Object.keys(uncachedPromptModalityCounts).length > 0 && pricing.inputByModalityPerMillion;
+  const hasCachedModalityPricing = Object.keys(cachedModalityCounts).length > 0 && pricing.cachedByModalityPerMillion;
+  const hasOutputModalityPricing = Object.keys(completionModalityCounts).length > 0 && pricing.outputByModalityPerMillion;
+  const inputCost = hasPromptModalityPricing ? sumModalityCosts(uncachedPromptModalityCounts, pricing.inputByModalityPerMillion, inputRate) : uncachedPromptTokens / 1e6 * inputRate;
+  const cachedCost = hasCachedModalityPricing ? sumModalityCosts(cachedModalityCounts, pricing.cachedByModalityPerMillion, cachedRate) : cachedTokens / 1e6 * cachedRate;
+  const outputCost = hasOutputModalityPricing ? sumModalityCosts(completionModalityCounts, pricing.outputByModalityPerMillion, outputRate) : billableOutputTokens / 1e6 * outputRate;
+  const imageCost = imageCount * (pricing.outputImagePerImage ?? 0);
+  return Number((inputCost + cachedCost + outputCost + imageCost).toFixed(12));
+}
+
+// src/GoogleProvider.ts
+var STATIC_MODELS = [
+  {
+    id: "gemma-4-31b-it",
+    name: "Gemma 4 31B IT",
+    description: "Hosted Gemma 4 instruction-tuned model with image input and optional thinking.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: false,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 262144,
+      reasoningLevels: { 0: null, 100: "high" }
+    }
+  },
+  {
+    id: "gemini-2.5-pro",
+    name: "Gemini 2.5 Pro",
+    description: "State-of-the-art Gemini model for coding and reasoning.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1048576,
+      reasoningLevels: { 0: null, 50: "medium", 100: "high" }
+    }
+  },
+  {
+    id: "gemini-2.5-flash",
+    name: "Gemini 2.5 Flash",
+    description: "Fast multimodal Gemini model for general-purpose tasks.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1048576
+    }
+  },
+  {
+    id: "gemini-2.5-flash-lite",
+    name: "Gemini 2.5 Flash-Lite",
+    description: "Low-cost Gemini model for high-volume workloads.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: true,
+      maxContextTokens: 1048576
+    }
+  },
+  {
+    id: "gemini-2.5-flash-image",
+    name: "Gemini 2.5 Flash Image",
+    description: "Gemini image generation model with native image output.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 1048576
+    }
+  },
+  {
+    id: "gemini-3-pro-image-preview",
+    name: "Gemini 3 Pro Image Preview",
+    description: "High-end Gemini image-preview model with image generation output.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 1048576
+    }
+  },
+  {
+    id: "gemini-3.1-flash-image-preview",
+    name: "Gemini 3.1 Flash Image Preview",
+    description: "Fast Gemini image-preview model with image output.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: true,
+      supportsStreaming: true,
+      supportsJsonMode: false,
+      maxContextTokens: 1048576
+    }
+  },
+  {
+    id: "imagen-4.0-generate-001",
+    name: "Imagen 4 Generate",
+    description: "Google Imagen model for image generation.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: false,
+      supportsStreaming: false,
+      supportsJsonMode: false,
+      maxContextTokens: 0
+    }
+  },
+  {
+    id: "imagen-3.0-capability-001",
+    name: "Imagen 3 Capability",
+    description: "Google Imagen model for image editing.",
+    capabilities: {
+      supportsImages: true,
+      supportsToolCalls: false,
+      supportsStreaming: false,
+      supportsJsonMode: false,
+      maxContextTokens: 0
+    }
+  }
+];
+function normalizeModelId(modelId) {
+  return modelId.trim().replace(/^google\//, "").replace(/^models\//, "").replace(/^publishers\/google\/models\//, "");
+}
+function isImagenModel(modelId) {
+  return normalizeModelId(modelId).startsWith("imagen-");
+}
+function supportsGoogleVision(model, normalizedId) {
+  const description = (model.description || "").toLowerCase();
+  if (isImagenModel(normalizedId)) {
+    return true;
+  }
+  if (normalizedId.startsWith("gemini-")) {
+    return true;
+  }
+  if (normalizedId.startsWith("gemma-3") || normalizedId.startsWith("gemma-4")) {
+    return true;
+  }
+  return ["multimodal", "image", "vision", "video", "audio"].some((term) => description.includes(term));
+}
+function supportsGoogleToolCalls(normalizedId) {
+  return normalizedId.startsWith("gemini-") || normalizedId.startsWith("functiongemma");
+}
+function inferGoogleReasoningLevels(model, normalizedId) {
+  if (!model.thinking) return void 0;
+  if (normalizedId.startsWith("gemma-")) {
+    return { 0: null, 100: "high" };
+  }
+  return { 0: null, 50: "medium", 100: "high" };
+}
+function mapDynamicCapabilities(model) {
+  const normalizedId = normalizeModelId(model.name || model.displayName || "");
+  const supportedActions = new Set(model.supportedActions || []);
+  const supportsContentGeneration = supportedActions.has("generateContent") || normalizedId.startsWith("gemini-") || normalizedId.startsWith("gemma-");
+  const supportsTools = supportsGoogleToolCalls(normalizedId);
+  return {
+    supportsImages: supportsGoogleVision(model, normalizedId),
+    supportsToolCalls: supportsTools,
+    supportsStreaming: supportsContentGeneration && !isImagenModel(normalizedId),
+    supportsJsonMode: supportsTools,
+    maxContextTokens: model.inputTokenLimit,
+    maxOutputTokens: model.outputTokenLimit,
+    reasoningLevels: inferGoogleReasoningLevels(model, normalizedId)
+  };
+}
+function toProviderModelInfo(model) {
+  const id = normalizeModelId(model.name || model.displayName || "");
+  return {
+    id,
+    name: model.displayName || id,
+    description: model.description,
+    contextLength: model.inputTokenLimit,
+    iconId: getGoogleIconDataUri(),
+    slug: id
+  };
+}
+function mapFinishReason(value) {
+  switch (value) {
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "IMAGE_SAFETY":
+    case "PROHIBITED_CONTENT":
+    case "IMAGE_PROHIBITED_CONTENT":
+      return "content_filter";
+    case "MALFORMED_FUNCTION_CALL":
+    case "UNEXPECTED_TOOL_CALL":
+      return "error";
+    case "STOP":
+    default:
+      return "stop";
+  }
+}
+function toolChoiceToGoogle(choice) {
+  if (choice === "auto") {
+    return { mode: FunctionCallingConfigMode.AUTO };
+  }
+  if (choice === "none") {
+    return { mode: FunctionCallingConfigMode.NONE };
+  }
+  if (choice === "required") {
+    return { mode: FunctionCallingConfigMode.ANY };
+  }
+  if (choice && typeof choice === "object" && "name" in choice) {
+    return {
+      mode: FunctionCallingConfigMode.ANY,
+      allowedFunctionNames: [choice.name]
+    };
+  }
+  return void 0;
+}
+function transformTools(tools) {
+  if (!tools?.length) return void 0;
+  return [{
+    functionDeclarations: tools.map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters || {
+        type: "object",
+        properties: {},
+        required: []
+      }
+    }))
+  }];
+}
+function normalizeInlineBytes(data, mediaType) {
+  const value = data || "";
+  const match = value.match(/^data:([^;]+);base64,(.*)$/);
+  if (!match) {
+    return { data: value, mediaType };
+  }
+  return {
+    data: match[2],
+    mediaType: match[1] || mediaType
+  };
+}
+function buildUserParts(message) {
+  if (typeof message.content === "string") {
+    return [{ text: message.content }];
+  }
+  return message.content.map((part) => {
+    if (part.type === "text") {
+      return { text: part.text };
+    }
+    if (part.type === "image") {
+      const normalized = normalizeInlineBytes(part.data, part.mediaType || "image/png");
+      return createPartFromBase64(normalized.data, normalized.mediaType || "image/png");
+    }
+    if (part.type === "image_url") {
+      const url = part.image_url?.url || "";
+      if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.*)$/);
+        if (match) {
+          return createPartFromBase64(match[2], match[1]);
+        }
+      }
+      return {
+        fileData: {
+          mimeType: "image/*",
+          fileUri: url
+        }
+      };
+    }
+    return {
+      inlineData: {
+        mimeType: part.mediaType,
+        data: part.data
+      }
+    };
+  });
+}
+function buildAssistantParts(message) {
+  const parts = [];
+  if (message.content) {
+    parts.push({ text: message.content });
+  }
+  if (message.reasoning) {
+    parts.push({ text: message.reasoning, thought: true });
+  }
+  if (message.toolCalls?.length) {
+    for (const toolCall of message.toolCalls) {
+      parts.push({
+        functionCall: {
+          id: toolCall.id,
+          name: toolCall.name,
+          args: toolCall.arguments
+        }
+      });
+    }
+  }
+  return parts;
+}
+function buildToolParts(message) {
+  const response = {};
+  if (typeof message.content === "string") {
+    response.output = message.content;
+  } else if ("type" in message.content) {
+    if (message.content.type === "text") response.output = message.content.text;
+    else if (message.content.type === "error") response.error = message.content.error;
+    else response.output = message.content;
+  } else {
+    response.output = message.content;
+  }
+  const imageParts = message.attachments?.filter((attachment) => attachment.type === "image" && attachment.data).map((attachment, index) => {
+    const normalized = normalizeInlineBytes(attachment.data, attachment.mediaType);
+    return {
+      inlineData: {
+        mimeType: normalized.mediaType,
+        data: normalized.data
+      },
+      partMetadata: { attachmentIndex: index }
+    };
+  }) || [];
+  return [
+    createPartFromFunctionResponse(
+      message.toolCallId,
+      message.toolName,
+      response,
+      imageParts.length ? imageParts.map((part) => ({ inlineData: part.inlineData })) : void 0
+    )
+  ];
+}
+function buildContents(messages) {
+  const contents = [];
+  const systemMessages = messages.filter((message) => message.role === "system").map((message) => message.content);
+  const systemInstruction = systemMessages.length ? { role: "user", parts: [{ text: systemMessages.join("\n\n") }] } : void 0;
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    if (message.role === "user") {
+      contents.push({ role: "user", parts: buildUserParts(message) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      contents.push({ role: "model", parts: buildAssistantParts(message) });
+      continue;
+    }
+    contents.push({ role: "user", parts: buildToolParts(message) });
+  }
+  return { systemInstruction, contents };
+}
+function extractReasoningFromParts(parts) {
+  if (!parts?.length) return null;
+  const text = parts.filter((part) => part.thought && typeof part.text === "string").map((part) => part.text).join("");
+  return text || null;
+}
+function extractImagesFromParts(parts) {
+  if (!parts?.length) return void 0;
+  const images = parts.filter((part) => part.inlineData?.mimeType?.startsWith("image/")).map((part, index) => ({
+    id: `image_${index}`,
+    data: part.inlineData?.data || "",
+    mediaType: part.inlineData?.mimeType || "image/png"
+  }));
+  return images.length ? images : void 0;
+}
+function extractToolCalls(parts) {
+  if (!parts?.length) return void 0;
+  const toolCalls = parts.filter((part) => part.functionCall?.name).map((part) => ({
+    id: part.functionCall?.id || crypto.randomUUID(),
+    name: part.functionCall?.name || "tool",
+    arguments: part.functionCall?.args || {}
+  }));
+  return toolCalls.length ? toolCalls : void 0;
+}
+function transformUsage(modelId, usage, imageCount = 0) {
+  const mapped = {
+    promptTokens: usage?.promptTokenCount || 0,
+    completionTokens: usage?.candidatesTokenCount || 0,
+    totalTokens: usage?.totalTokenCount || 0,
+    reasoningTokens: usage?.thoughtsTokenCount,
+    cachedTokens: usage?.cachedContentTokenCount,
+    provider: "google"
+  };
+  mapped.cost = calculateGoogleUsageCost(
+    modelId,
+    {
+      ...mapped,
+      promptTokenDetails: usage?.promptTokensDetails,
+      completionTokenDetails: usage?.candidatesTokensDetails || usage?.responseTokensDetails,
+      cachedTokenDetails: usage?.cacheTokensDetails
+    },
+    imageCount
+  );
+  return mapped;
+}
+var GoogleProvider = class _GoogleProvider {
+  name = "google";
+  specificationVersion = "1";
+  config;
+  client = null;
+  static cacheTtl = 5 * 60 * 1e3;
+  static modelsCache = null;
+  static modelsCacheTime = 0;
+  static modelMetadataCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  getClient() {
+    if (!this.client) {
+      this.client = new GoogleGenAI({
+        apiKey: this.config.apiKey
+      });
+    }
+    return this.client;
+  }
+  supportsModel(modelId) {
+    return modelId.startsWith("gemini-") || modelId.startsWith("gemma-") || modelId.startsWith("imagen-") || modelId.startsWith("models/");
+  }
+  getIcon(_modelId) {
+    return getGoogleIconDataUri();
+  }
+  getHttpOptions() {
+    if (!this.config.baseUrl && !this.config.timeout) return void 0;
+    return {
+      ...this.config.baseUrl ? { baseUrl: this.config.baseUrl } : {},
+      ...this.config.timeout ? { timeout: this.config.timeout } : {}
+    };
+  }
+  async getModels(filter) {
+    const now = Date.now();
+    if (_GoogleProvider.modelsCache && now - _GoogleProvider.modelsCacheTime < _GoogleProvider.cacheTtl) {
+      return this.filterModels(_GoogleProvider.modelsCache, filter);
+    }
+    try {
+      const models = [];
+      const client = this.getClient();
+      const pager = await client.models.list({
+        config: {
+          httpOptions: this.getHttpOptions()
+        }
+      });
+      for await (const model of pager) {
+        const id = normalizeModelId(model.name || "");
+        if (!id) continue;
+        const supportsGeneration = model.supportedActions?.some(
+          (action) => ["generateContent", "generateImages", "editImage", "predict"].includes(action)
+        );
+        if (!supportsGeneration) continue;
+        _GoogleProvider.modelMetadataCache.set(id, model);
+        models.push(toProviderModelInfo(model));
+      }
+      for (const staticModel of STATIC_MODELS) {
+        if (!models.some((model) => model.id === staticModel.id)) {
+          models.push({
+            id: staticModel.id,
+            name: staticModel.name,
+            description: staticModel.description,
+            iconId: this.getIcon(staticModel.id),
+            slug: staticModel.id
+          });
+        }
+      }
+      _GoogleProvider.modelsCache = models.sort((a, b) => a.name.localeCompare(b.name));
+      _GoogleProvider.modelsCacheTime = now;
+      return this.filterModels(_GoogleProvider.modelsCache, filter);
+    } catch (error) {
+      console.error("Failed to list Google models:", error);
+      return this.filterModels(
+        STATIC_MODELS.map((model) => ({
+          id: model.id,
+          name: model.name,
+          description: model.description,
+          iconId: this.getIcon(model.id),
+          slug: model.id
+        })),
+        filter
+      );
+    }
+  }
+  filterModels(models, filter) {
+    if (!filter) return models;
+    const query = filter.toLowerCase();
+    return models.filter(
+      (model) => model.id.toLowerCase().includes(query) || model.name.toLowerCase().includes(query) || (model.description?.toLowerCase().includes(query) ?? false)
+    );
+  }
+  async getModelMetadata(modelId) {
+    const normalized = normalizeModelId(modelId);
+    const cached = _GoogleProvider.modelMetadataCache.get(normalized);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const model = await this.getClient().models.get({
+        model: normalized,
+        config: {
+          httpOptions: this.getHttpOptions()
+        }
+      });
+      _GoogleProvider.modelMetadataCache.set(normalized, model);
+      return model;
+    } catch {
+      return null;
+    }
+  }
+  async getModelCapabilities(modelId) {
+    const normalized = normalizeModelId(modelId);
+    const staticModel = STATIC_MODELS.find((model) => model.id === normalized);
+    if (staticModel) {
+      return { ...staticModel.capabilities };
+    }
+    try {
+      const metadata = await this.getModelMetadata(normalized);
+      if (metadata) {
+        return mapDynamicCapabilities(metadata);
+      }
+      const models = await this.getModels();
+      const found = models.find((model) => model.id === normalized);
+      if (!found) return null;
+      return {
+        supportsImages: normalized.startsWith("gemini-") || normalized.startsWith("gemma-") || normalized.includes("image"),
+        supportsToolCalls: supportsGoogleToolCalls(normalized),
+        supportsStreaming: !isImagenModel(normalized),
+        supportsJsonMode: supportsGoogleToolCalls(normalized),
+        maxContextTokens: found.contextLength
+      };
+    } catch {
+      return null;
+    }
+  }
+  buildGenerateContentParams(request) {
+    const providerOptions = request.providerOptions || {};
+    const { systemInstruction, contents } = buildContents(request.messages);
+    const config = {
+      ...this.getHttpOptions() ? { httpOptions: this.getHttpOptions() } : {},
+      ...systemInstruction ? { systemInstruction } : {},
+      ...typeof request.temperature === "number" ? { temperature: request.temperature } : {},
+      ...typeof request.topP === "number" ? { topP: request.topP } : {},
+      ...typeof request.topK === "number" ? { topK: request.topK } : {},
+      ...typeof request.maxOutputTokens === "number" ? { maxOutputTokens: request.maxOutputTokens } : {},
+      ...request.stopSequences?.length ? { stopSequences: request.stopSequences } : {},
+      ...request.responseFormat?.type === "json" ? {
+        responseMimeType: "application/json",
+        ...request.responseFormat.schema ? { responseJsonSchema: request.responseFormat.schema } : {}
+      } : {},
+      ...request.tools?.length ? { tools: transformTools(request.tools) } : {},
+      ...request.tools?.length && toolChoiceToGoogle(request.toolChoice) ? { toolConfig: { functionCallingConfig: toolChoiceToGoogle(request.toolChoice) } } : {},
+      ...typeof providerOptions.candidateCount === "number" ? { candidateCount: providerOptions.candidateCount } : {},
+      ...Array.isArray(providerOptions.responseModalities) ? { responseModalities: providerOptions.responseModalities } : {},
+      ...typeof providerOptions.mediaResolution === "string" ? { mediaResolution: providerOptions.mediaResolution } : {},
+      ...typeof providerOptions.cachedContent === "string" ? { cachedContent: providerOptions.cachedContent } : {},
+      ...typeof providerOptions.enableEnhancedCivicAnswers === "boolean" ? { enableEnhancedCivicAnswers: providerOptions.enableEnhancedCivicAnswers } : {},
+      ...providerOptions.labels ? { labels: providerOptions.labels } : {},
+      ...providerOptions.safetySettings ? { safetySettings: providerOptions.safetySettings } : {},
+      ...providerOptions.thinkingConfig ? { thinkingConfig: providerOptions.thinkingConfig } : {},
+      ...providerOptions.imageConfig ? { imageConfig: providerOptions.imageConfig } : {},
+      ...typeof request.reasoning?.maxTokens === "number" ? { thinkingConfig: { ...providerOptions.thinkingConfig || {}, thinkingBudget: request.reasoning.maxTokens } } : {}
+    };
+    return {
+      model: normalizeModelId(request.model),
+      contents,
+      config
+    };
+  }
+  extractImagenRequest(request) {
+    const providerOptions = request.providerOptions || {};
+    const latestUser = [...request.messages].reverse().find((message) => message.role === "user");
+    const prompt = latestUser ? typeof latestUser.content === "string" ? latestUser.content : latestUser.content.filter((part) => part.type === "text").map((part) => part.text).join("\n") : "";
+    const referenceImages = latestUser && typeof latestUser.content !== "string" ? latestUser.content.filter((part) => part.type === "image").map((part, index) => {
+      const normalized = normalizeInlineBytes(part.data, part.mediaType);
+      const image = new RawReferenceImage();
+      image.referenceId = index + 1;
+      image.referenceImage = {
+        imageBytes: normalized.data,
+        mimeType: normalized.mediaType
+      };
+      return image;
+    }) : [];
+    const body = {
+      model: normalizeModelId(request.model),
+      prompt,
+      ...referenceImages.length ? { referenceImages: "[binary images omitted]" } : {},
+      config: {
+        ...this.getHttpOptions() ? { httpOptions: this.getHttpOptions() } : {},
+        ...typeof providerOptions.numberOfImages === "number" ? { numberOfImages: providerOptions.numberOfImages } : {},
+        ...typeof providerOptions.negativePrompt === "string" ? { negativePrompt: providerOptions.negativePrompt } : {},
+        ...typeof providerOptions.aspectRatio === "string" ? { aspectRatio: providerOptions.aspectRatio } : {},
+        ...typeof providerOptions.guidanceScale === "number" ? { guidanceScale: providerOptions.guidanceScale } : {},
+        ...typeof providerOptions.seed === "number" ? { seed: providerOptions.seed } : {},
+        ...typeof providerOptions.safetyFilterLevel === "string" ? { safetyFilterLevel: providerOptions.safetyFilterLevel } : {},
+        ...typeof providerOptions.personGeneration === "string" ? { personGeneration: providerOptions.personGeneration } : {},
+        ...typeof providerOptions.includeSafetyAttributes === "boolean" ? { includeSafetyAttributes: providerOptions.includeSafetyAttributes } : {},
+        ...typeof providerOptions.includeRaiReason === "boolean" ? { includeRaiReason: providerOptions.includeRaiReason } : {},
+        ...typeof providerOptions.language === "string" ? { language: providerOptions.language } : {},
+        ...typeof providerOptions.outputMimeType === "string" ? { outputMimeType: providerOptions.outputMimeType } : {},
+        ...typeof providerOptions.outputCompressionQuality === "number" ? { outputCompressionQuality: providerOptions.outputCompressionQuality } : {},
+        ...typeof providerOptions.addWatermark === "boolean" ? { addWatermark: providerOptions.addWatermark } : {},
+        ...providerOptions.labels ? { labels: providerOptions.labels } : {},
+        ...typeof providerOptions.imageSize === "string" ? { imageSize: providerOptions.imageSize } : {},
+        ...typeof providerOptions.enhancePrompt === "boolean" ? { enhancePrompt: providerOptions.enhancePrompt } : {},
+        ...typeof providerOptions.editMode === "string" ? { editMode: providerOptions.editMode } : {},
+        ...typeof providerOptions.baseSteps === "number" ? { baseSteps: providerOptions.baseSteps } : {}
+      }
+    };
+    return {
+      prompt,
+      referenceImages: referenceImages.length ? referenceImages : void 0,
+      body
+    };
+  }
+  async inspectRequest(request) {
+    if (isImagenModel(request.model)) {
+      const imagen = this.extractImagenRequest(request);
+      return {
+        body: imagen.body,
+        messagesPath: "prompt",
+        metadata: {
+          endpoint: imagen.referenceImages?.length ? `${this.config.baseUrl || "https://generativelanguage.googleapis.com"}/editImage` : `${this.config.baseUrl || "https://generativelanguage.googleapis.com"}/generateImages`,
+          headers: { "Content-Type": "application/json" }
+        }
+      };
+    }
+    return {
+      body: this.buildGenerateContentParams(request),
+      messagesPath: "contents",
+      metadata: {
+        endpoint: `${this.config.baseUrl || "https://generativelanguage.googleapis.com"}/generateContent`,
+        headers: { "Content-Type": "application/json" }
+      }
+    };
+  }
+  async generate(request) {
+    if (isImagenModel(request.model)) {
+      return this.generateImagen(request);
+    }
+    try {
+      const client = this.getClient();
+      const response = await client.models.generateContent(this.buildGenerateContentParams(request));
+      const candidate = response.candidates?.[0];
+      const parts = candidate?.content?.parts;
+      const images = extractImagesFromParts(parts);
+      const usage = transformUsage(normalizeModelId(request.model), response.usageMetadata, images?.length || 0);
+      return {
+        content: response.text || null,
+        reasoning: extractReasoningFromParts(parts),
+        reasoningDetails: extractReasoningFromParts(parts) ? [{ type: "text", text: extractReasoningFromParts(parts) || void 0, format: "google-gemini-v1" }] : void 0,
+        toolCalls: extractToolCalls(parts),
+        images,
+        finishReason: mapFinishReason(candidate?.finishReason),
+        usage,
+        metadata: {
+          provider: "google",
+          responseId: response.responseId,
+          modelVersion: response.modelVersion,
+          promptFeedback: response.promptFeedback
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  async generateImagen(request) {
+    try {
+      const client = this.getClient();
+      const imagen = this.extractImagenRequest(request);
+      const model = normalizeModelId(request.model);
+      const response = imagen.referenceImages?.length ? await client.models.editImage({
+        model,
+        prompt: imagen.prompt,
+        referenceImages: imagen.referenceImages,
+        config: imagen.body.config
+      }) : await client.models.generateImages({
+        model,
+        prompt: imagen.prompt,
+        config: imagen.body.config
+      });
+      const images = (response.generatedImages || []).filter((image) => image.image?.imageBytes).map((image, index) => ({
+        id: `image_${index}`,
+        data: image.image?.imageBytes || "",
+        mediaType: image.image?.mimeType || "image/png",
+        revisedPrompt: image.enhancedPrompt
+      }));
+      return {
+        content: null,
+        images,
+        finishReason: "stop",
+        usage: {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+          cost: calculateGoogleUsageCost(model, { promptTokens: 0, completionTokens: 0, cachedTokens: 0 }, images.length),
+          provider: "google"
+        },
+        metadata: {
+          provider: "google"
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  async stream(request) {
+    if (isImagenModel(request.model)) {
+      throw new ProviderError("Imagen models do not support streaming in Standard Agents.", "invalid_request");
+    }
+    const self = this;
+    try {
+      const client = this.getClient();
+      const stream = await client.models.generateContentStream(this.buildGenerateContentParams(request));
+      return {
+        async *[Symbol.asyncIterator]() {
+          let sawContent = false;
+          let sawReasoning = false;
+          let finishReason = "stop";
+          let finalUsage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            provider: "google"
+          };
+          let imageIndex = 0;
+          try {
+            for await (const chunk of stream) {
+              const candidate = chunk.candidates?.[0];
+              const parts = candidate?.content?.parts || [];
+              for (const part of parts) {
+                if (part.text && !part.thought) {
+                  sawContent = true;
+                  yield { type: "content-delta", delta: part.text };
+                } else if (part.text && part.thought) {
+                  sawReasoning = true;
+                  yield { type: "reasoning-delta", delta: part.text };
+                } else if (part.functionCall?.name) {
+                  const id = part.functionCall.id || crypto.randomUUID();
+                  yield { type: "tool-call-start", id, name: part.functionCall.name };
+                  yield { type: "tool-call-done", id, arguments: part.functionCall.args || {} };
+                } else if (part.inlineData?.mimeType?.startsWith("image/")) {
+                  const image = {
+                    id: `image_${imageIndex}`,
+                    data: part.inlineData.data || "",
+                    mediaType: part.inlineData.mimeType || "image/png"
+                  };
+                  yield { type: "image-done", index: imageIndex, image };
+                  imageIndex += 1;
+                }
+              }
+              if (chunk.usageMetadata) {
+                finalUsage = transformUsage(normalizeModelId(request.model), chunk.usageMetadata, imageIndex);
+              }
+              if (candidate?.finishReason) {
+                finishReason = mapFinishReason(candidate.finishReason);
+              }
+            }
+            if (sawContent) yield { type: "content-done" };
+            if (sawReasoning) yield { type: "reasoning-done" };
+            yield { type: "finish", finishReason, usage: finalUsage };
+          } catch (error) {
+            yield { type: "error", error: self.toProviderError(error).message };
+          }
+        }
+      };
+    } catch (error) {
+      throw this.toProviderError(error);
+    }
+  }
+  toProviderError(error) {
+    if (error instanceof ProviderError) return error;
+    if (error instanceof Error) {
+      const candidate = error;
+      const status = candidate.status || candidate.statusCode;
+      if (status === 429) return new ProviderError(error.message, "rate_limit", status);
+      if (status === 401 || status === 403) return new ProviderError(error.message, "auth_error", status);
+      if (status === 400) return new ProviderError(error.message, "invalid_request", status);
+      if (status && status >= 500) return new ProviderError(error.message, "server_error", status);
+      if (error.name === "AbortError") return new ProviderError(error.message, "timeout");
+      return new ProviderError(error.message, "unknown", status);
+    }
+    return new ProviderError(String(error), "unknown");
+  }
+};
+
+// src/providerOptions.ts
+import { z } from "zod";
+var googleProviderOptions = z.object({
+  candidateCount: z.number().int().min(1).max(8).optional(),
+  responseModalities: z.array(z.enum(["TEXT", "IMAGE", "AUDIO"])).optional(),
+  mediaResolution: z.string().optional(),
+  cachedContent: z.string().optional(),
+  enableEnhancedCivicAnswers: z.boolean().optional(),
+  labels: z.record(z.string(), z.string()).optional(),
+  safetySettings: z.array(z.record(z.string(), z.unknown())).optional(),
+  thinkingConfig: z.record(z.string(), z.unknown()).optional(),
+  imageConfig: z.record(z.string(), z.unknown()).optional(),
+  numberOfImages: z.number().int().min(1).max(4).optional(),
+  negativePrompt: z.string().optional(),
+  aspectRatio: z.string().optional(),
+  guidanceScale: z.number().optional(),
+  safetyFilterLevel: z.string().optional(),
+  personGeneration: z.string().optional(),
+  includeSafetyAttributes: z.boolean().optional(),
+  includeRaiReason: z.boolean().optional(),
+  language: z.string().optional(),
+  outputMimeType: z.string().optional(),
+  outputCompressionQuality: z.number().int().optional(),
+  addWatermark: z.boolean().optional(),
+  imageSize: z.string().optional(),
+  enhancePrompt: z.boolean().optional(),
+  editMode: z.string().optional(),
+  baseSteps: z.number().int().optional()
+}).passthrough();
+
+// src/index.ts
+var google = Object.assign(
+  (config) => new GoogleProvider(config),
+  { providerOptions: googleProviderOptions }
+);
+export {
+  GoogleProvider,
+  google,
+  googleProviderOptions
+};
+//# sourceMappingURL=index.js.map