@llm-ports/adapter-google 0.1.0-alpha.11

package/dist/index.cjs

@@ -0,0 +1,601 @@
+'use strict';
+
+var genai = require('@google/genai');
+var core = require('@llm-ports/core');
+var zodToJsonSchema = require('zod-to-json-schema');
+
+// src/adapter.ts
+var ADAPTER_NAME = "google";
+function toGeminiParts(block) {
+  switch (block.type) {
+    case "text":
+      return [{ text: block.text }];
+    case "image": {
+      if (block.source.kind === "base64") {
+        return [
+          {
+            inlineData: {
+              mimeType: block.source.mediaType,
+              data: block.source.data
+            }
+          }
+        ];
+      }
+      return [
+        {
+          fileData: {
+            // Gemini infers mimeType from URL extension when not provided.
+            // We pass image/jpeg as a sane default; users wanting tighter
+            // control should pass base64 with explicit mediaType.
+            mimeType: "image/jpeg",
+            fileUri: block.source.url
+          }
+        }
+      ];
+    }
+    case "audio": {
+      if (block.source.kind === "base64") {
+        return [
+          {
+            inlineData: {
+              mimeType: block.source.mediaType,
+              data: block.source.data
+            }
+          }
+        ];
+      }
+      throw new core.ContentBlockUnsupportedError(ADAPTER_NAME, "audio (url; Gemini accepts base64 or fileData with fileUri)");
+    }
+    case "tool_use": {
+      const args = block.input !== null && typeof block.input === "object" ? block.input : { value: block.input };
+      return [{ functionCall: { name: block.name, args } }];
+    }
+    case "tool_result": {
+      const response = typeof block.content === "string" ? { result: block.content } : { result: extractTextOnly(block.content) };
+      return [
+        {
+          functionResponse: {
+            // Gemini's API requires the tool name; we use toolUseId since
+            // llm-ports' ToolResultBlock doesn't carry the name. Adapters
+            // that need the name can plumb it through a separate channel.
+            name: block.toolUseId,
+            response
+          }
+        }
+      ];
+    }
+  }
+}
+function extractTextOnly(blocks) {
+  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function toGeminiParts2(content) {
+  if (typeof content === "string") {
+    return [{ text: content }];
+  }
+  return content.flatMap(toGeminiParts);
+}
+function toGeminiRequest(messages) {
+  let systemInstruction;
+  const contents = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      const text = typeof msg.content === "string" ? msg.content : extractTextOnly(msg.content);
+      systemInstruction = systemInstruction === void 0 ? text : `${systemInstruction}
+
+${text}`;
+      continue;
+    }
+    const role = msg.role === "tool" ? "function" : msg.role === "assistant" ? "model" : "user";
+    contents.push({
+      role,
+      parts: toGeminiParts2(msg.content)
+    });
+  }
+  return systemInstruction !== void 0 ? { systemInstruction, contents } : { contents };
+}
+function extractGeminiText(parts) {
+  if (!parts) return "";
+  return parts.filter((p) => "text" in p).map((p) => p.text).join("");
+}
+function fromGeminiCandidate(candidate) {
+  const out = [];
+  const parts = candidate.content?.parts ?? [];
+  for (const part of parts) {
+    if ("text" in part && part.text.length > 0) {
+      out.push({ type: "text", text: part.text });
+    } else if ("functionCall" in part) {
+      out.push({
+        type: "tool_use",
+        id: part.functionCall.name,
+        name: part.functionCall.name,
+        input: part.functionCall.args
+      });
+    } else if ("inlineData" in part) {
+      const mt = part.inlineData.mimeType;
+      if (mt === "image/jpeg" || mt === "image/png" || mt === "image/gif" || mt === "image/webp") {
+        out.push({
+          type: "image",
+          source: { kind: "base64", mediaType: mt, data: part.inlineData.data }
+        });
+      }
+    }
+  }
+  return out;
+}
+function toGeminiTools(tools) {
+  const declarations = Object.entries(tools).map(
+    ([name, def]) => ({
+      name,
+      description: def.description,
+      parameters: zodToGeminiSchema(def.inputSchema)
+    })
+  );
+  return [{ functionDeclarations: declarations }];
+}
+function zodToGeminiSchema(schema) {
+  try {
+    const json = zodToJsonSchema.zodToJsonSchema(schema, {
+      target: "openApi3",
+      $refStrategy: "none"
+    });
+    return sanitizeGeminiSchema(json);
+  } catch {
+    return { type: "object", properties: {} };
+  }
+}
+function sanitizeGeminiSchema(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { type: "object", properties: {} };
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (key === "$schema" || key === "definitions" || key === "$defs" || key === "$ref") {
+      continue;
+    }
+    if (key === "properties" && value && typeof value === "object") {
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = sanitizeGeminiSchema(propSchema);
+      }
+      cleaned[key] = props;
+      continue;
+    }
+    if (key === "items" && value && typeof value === "object" && !Array.isArray(value)) {
+      cleaned[key] = sanitizeGeminiSchema(value);
+      continue;
+    }
+    cleaned[key] = value;
+  }
+  return cleaned;
+}
+function detectUnsupportedSchemaFeature(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const obj = input;
+  for (const key of ["oneOf", "allOf", "not", "$ref"]) {
+    if (key in obj) return key;
+  }
+  if (obj["properties"] && typeof obj["properties"] === "object") {
+    for (const propSchema of Object.values(obj["properties"])) {
+      const nested = detectUnsupportedSchemaFeature(propSchema);
+      if (nested) return nested;
+    }
+  }
+  if (obj["items"] && typeof obj["items"] === "object" && !Array.isArray(obj["items"])) {
+    const nested = detectUnsupportedSchemaFeature(obj["items"]);
+    if (nested) return nested;
+  }
+  if (Array.isArray(obj["anyOf"])) {
+    for (const sub of obj["anyOf"]) {
+      const nested = detectUnsupportedSchemaFeature(sub);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+// src/pricing.ts
+var GEMINI_PRICING = {
+  // Gemini 2.5 family (2026-05 GA pricing)
+  "gemini-2.5-pro": {
+    inputPer1M: 1.25,
+    outputPer1M: 5,
+    cacheReadPer1M: 0.3125
+  },
+  "gemini-2.5-flash": {
+    inputPer1M: 0.075,
+    outputPer1M: 0.3,
+    cacheReadPer1M: 0.01875
+  },
+  "gemini-2.5-flash-lite": {
+    inputPer1M: 0.0375,
+    outputPer1M: 0.15,
+    cacheReadPer1M: 9375e-6
+  },
+  // Gemini 2.0 family (still available)
+  "gemini-2.0-flash": {
+    inputPer1M: 0.1,
+    outputPer1M: 0.4,
+    cacheReadPer1M: 0.025
+  },
+  "gemini-2.0-flash-lite": {
+    inputPer1M: 0.075,
+    outputPer1M: 0.3
+  }
+};
+function lookupGeminiPricing(modelId) {
+  return GEMINI_PRICING[modelId];
+}
+
+// src/adapter.ts
+function pricingFor(ctx, modelId) {
+  const pricing = ctx.pricingOverrides[modelId] ?? GEMINI_PRICING[modelId];
+  if (!pricing) {
+    throw new Error(
+      `No pricing entry for Google Gemini model "${modelId}". Provide pricingOverrides or update src/pricing.ts.`
+    );
+  }
+  return pricing;
+}
+function createGoogleAdapter(opts) {
+  const mergedPricing = {
+    ...GEMINI_PRICING,
+    ...opts.pricingOverrides ?? {}
+  };
+  const ctx = {
+    client: new genai.GoogleGenAI({ apiKey: opts.apiKey }),
+    validationStrategy: opts.validationStrategy ?? {
+      kind: "retry-with-feedback",
+      maxAttempts: 2,
+      includeOriginalError: true
+    },
+    pricingOverrides: opts.pricingOverrides ?? {},
+    imageSizeLimitBytes: opts.imageSizeLimitBytes ?? 20 * 1024 * 1024
+  };
+  return {
+    name: "google",
+    pricing: mergedPricing,
+    createLLMPort: (modelId, alias) => createPort(ctx, modelId, alias)
+  };
+}
+function createPort(ctx, modelId, alias) {
+  const pricing = pricingFor(ctx, modelId);
+  const validateContent = (content) => {
+    if (Array.isArray(content)) {
+      core.validateImageBlocks(content, {
+        alias,
+        ...ctx.imageSizeLimitBytes > 0 ? { limitBytes: ctx.imageSizeLimitBytes } : {}
+      });
+    }
+  };
+  const validateMessages = (messages) => {
+    for (const msg of messages) validateContent(msg.content);
+  };
+  return {
+    async generateText(options) {
+      core.throwIfAborted(options.signal);
+      validateContent(options.prompt);
+      const start = Date.now();
+      try {
+        const parts = toGeminiParts2(options.prompt);
+        const response = await ctx.client.models.generateContent({
+          model: modelId,
+          contents: [{ role: "user", parts }],
+          config: {
+            ...options.instructions !== void 0 ? { systemInstruction: options.instructions } : {},
+            ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+            ...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+            ...options.signal ? { abortSignal: options.signal } : {}
+          }
+        });
+        const candidate = response.candidates?.[0];
+        const text = extractGeminiText(candidate?.content?.parts);
+        const usage = parseUsage(response);
+        return {
+          text,
+          usage,
+          cost: core.computeChatCost(usage, pricing),
+          modelId: response.modelVersion ?? modelId,
+          providerAlias: alias,
+          latencyMs: Date.now() - start
+        };
+      } catch (err) {
+        throw core.wrapProviderError(alias, err);
+      }
+    },
+    async generateStructured(options) {
+      core.throwIfAborted(options.signal);
+      validateContent(options.prompt);
+      const start = Date.now();
+      let attempts = 0;
+      const maxAttempts = ctx.validationStrategy.kind === "retry-with-feedback" ? ctx.validationStrategy.maxAttempts : 1;
+      const jsonSchema = zodToGeminiSchema(options.schema);
+      const unsupportedFeature = detectUnsupportedSchemaFeature(jsonSchema);
+      const useNativeResponseSchema = unsupportedFeature === null;
+      if (!useNativeResponseSchema) {
+        warnSchemaFallback(modelId, unsupportedFeature);
+      }
+      const sanitizedSchema = useNativeResponseSchema ? sanitizeGeminiSchema(jsonSchema) : null;
+      let correctionPrompt = null;
+      let lastUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      let lastModelId = modelId;
+      while (attempts < maxAttempts) {
+        attempts++;
+        const userText = correctionPrompt ? `${core.stringifyContentBlocks(options.prompt)}
+
+${correctionPrompt}` : useNativeResponseSchema ? core.stringifyContentBlocks(options.prompt) : `${core.stringifyContentBlocks(options.prompt)}
+
+Reply with a single JSON object only. No prose, no code fences.`;
+        try {
+          const response = await ctx.client.models.generateContent({
+            model: modelId,
+            contents: [{ role: "user", parts: [{ text: userText }] }],
+            config: {
+              ...options.instructions !== void 0 ? { systemInstruction: options.instructions } : {},
+              temperature: options.temperature ?? 0,
+              ...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+              responseMimeType: "application/json",
+              ...sanitizedSchema ? { responseSchema: sanitizedSchema } : {},
+              ...options.signal ? { abortSignal: options.signal } : {}
+            }
+          });
+          const candidate = response.candidates?.[0];
+          const raw = extractGeminiText(candidate?.content?.parts);
+          lastUsage = core.mergeTokenUsage(lastUsage, parseUsage(response));
+          lastModelId = response.modelVersion ?? modelId;
+          const decoded = core.extractJSON(raw);
+          let parsed = options.schema.safeParse(decoded);
+          if (!parsed.success) {
+            const repaired = core.attemptValidationRepair(decoded, parsed.error);
+            const reparsed = options.schema.safeParse(repaired);
+            if (reparsed.success) parsed = reparsed;
+          }
+          if (parsed.success) {
+            return {
+              data: parsed.data,
+              usage: lastUsage,
+              cost: core.computeChatCost(lastUsage, pricing),
+              modelId: lastModelId,
+              providerAlias: alias,
+              latencyMs: Date.now() - start,
+              validationAttempts: attempts
+            };
+          }
+          if (ctx.validationStrategy.kind === "retry-with-feedback" && attempts < maxAttempts) {
+            const issues = parsed.error.issues.map((i) => `- ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+            correctionPrompt = `Your previous response failed validation:
+${issues}
+
+Reply with a single corrected JSON object only.`;
+            continue;
+          }
+          core.failValidation(parsed.error.issues, attempts);
+        } catch (err) {
+          throw core.wrapProviderError(alias, err);
+        }
+      }
+      throw new Error("generateStructured exhausted attempts");
+    },
+    async *streamText(options) {
+      core.throwIfAborted(options.signal);
+      validateContent(options.prompt);
+      try {
+        const parts = toGeminiParts2(options.prompt);
+        const stream = await ctx.client.models.generateContentStream({
+          model: modelId,
+          contents: [{ role: "user", parts }],
+          config: {
+            ...options.instructions !== void 0 ? { systemInstruction: options.instructions } : {},
+            ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+            ...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+            ...options.signal ? { abortSignal: options.signal } : {}
+          }
+        });
+        for await (const chunk of stream) {
+          const text = extractGeminiText(
+            chunk.candidates?.[0]?.content?.parts
+          );
+          if (text.length > 0) yield text;
+        }
+      } catch (err) {
+        throw core.wrapProviderError(alias, err);
+      }
+    },
+    async *streamStructured(options) {
+      core.throwIfAborted(options.signal);
+      validateContent(options.prompt);
+      try {
+        const stream = await ctx.client.models.generateContentStream({
+          model: modelId,
+          contents: [
+            {
+              role: "user",
+              parts: [
+                {
+                  text: `${core.stringifyContentBlocks(options.prompt)}
+
+Reply with a single JSON object only. Stream the JSON progressively.`
+                }
+              ]
+            }
+          ],
+          config: {
+            ...options.instructions !== void 0 ? { systemInstruction: options.instructions } : {},
+            temperature: options.temperature ?? 0,
+            ...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+            responseMimeType: "application/json",
+            ...options.signal ? { abortSignal: options.signal } : {}
+          }
+        });
+        let buffer = "";
+        for await (const chunk of stream) {
+          const text = extractGeminiText(
+            chunk.candidates?.[0]?.content?.parts
+          );
+          if (text.length === 0) continue;
+          buffer += text;
+          const partial = core.tryParsePartialJSON(buffer);
+          if (partial !== null) yield partial;
+        }
+      } catch (err) {
+        throw core.wrapProviderError(alias, err);
+      }
+    },
+    async runAgent(options) {
+      core.throwIfAborted(options.signal);
+      validateMessages(options.messages);
+      const start = Date.now();
+      const maxSteps = options.maxSteps ?? 10;
+      const conversation = [...options.messages];
+      const toolCalls = [];
+      let stepsTaken = 0;
+      let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+      let finalText = "";
+      let lastModelId = modelId;
+      let terminationReason = "max_steps";
+      const toolsRegistered = Object.keys(options.tools).length > 0;
+      const geminiTools = toolsRegistered ? toGeminiTools(options.tools) : void 0;
+      try {
+        for (let step = 0; step < maxSteps; step++) {
+          core.throwIfAborted(options.signal);
+          stepsTaken = step + 1;
+          const { systemInstruction, contents } = toGeminiRequest(conversation);
+          const response = await ctx.client.models.generateContent({
+            model: modelId,
+            contents,
+            config: {
+              // options.instructions takes precedence over a system message
+              // baked into the messages array, matching the per-method pattern
+              // used elsewhere in the adapter.
+              ...options.instructions !== void 0 ? { systemInstruction: options.instructions } : systemInstruction !== void 0 ? { systemInstruction } : {},
+              ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+              ...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+              ...geminiTools ? { tools: geminiTools } : {},
+              ...options.signal ? { abortSignal: options.signal } : {}
+            }
+          });
+          totalUsage = core.mergeTokenUsage(totalUsage, parseUsage(response));
+          lastModelId = response.modelVersion ?? modelId;
+          const candidate = response.candidates?.[0];
+          const responseParts = candidate?.content?.parts ?? [];
+          const blocks = fromGeminiCandidate({
+            content: { parts: responseParts }
+          });
+          conversation.push({
+            role: "assistant",
+            content: blocks.length > 0 ? blocks : [{ type: "text", text: extractGeminiText(responseParts) }]
+          });
+          finalText = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+          const toolUses = blocks.filter(
+            (b) => b.type === "tool_use"
+          );
+          if (toolUses.length === 0) {
+            terminationReason = "completed";
+            break;
+          }
+          const toolResults = [];
+          for (const tu of toolUses) {
+            const def = options.tools[tu.name];
+            if (!def) {
+              toolResults.push({
+                type: "tool_result",
+                toolUseId: tu.id,
+                content: `Tool "${tu.name}" not found.`,
+                isError: true
+              });
+              continue;
+            }
+            try {
+              const output = await def.execute(tu.input);
+              toolCalls.push({
+                name: tu.name,
+                input: tu.input,
+                output
+              });
+              const text = typeof output === "string" ? output : JSON.stringify(output);
+              const truncated = def.maxOutputBytes !== void 0 && text.length > def.maxOutputBytes ? `${text.slice(0, def.maxOutputBytes)}
+[truncated]` : text;
+              toolResults.push({
+                type: "tool_result",
+                toolUseId: tu.id,
+                content: truncated
+              });
+            } catch (toolErr) {
+              toolResults.push({
+                type: "tool_result",
+                toolUseId: tu.id,
+                content: toolErr instanceof Error ? toolErr.message : String(toolErr),
+                isError: true
+              });
+            }
+          }
+          conversation.push({ role: "tool", content: toolResults });
+        }
+      } catch (err) {
+        throw core.wrapProviderError(alias, err);
+      }
+      return {
+        text: finalText,
+        messages: conversation,
+        toolCalls,
+        usage: totalUsage,
+        cost: core.computeChatCost(totalUsage, pricing),
+        modelId: lastModelId,
+        providerAlias: alias,
+        latencyMs: Date.now() - start,
+        stepsTaken,
+        terminationReason
+      };
+    },
+    async listModels() {
+      try {
+        const out = [];
+        const pager = await ctx.client.models.list();
+        for await (const m of pager) {
+          const model = m;
+          if (!model.name) continue;
+          const id = model.name.startsWith("models/") ? model.name.slice("models/".length) : model.name;
+          out.push({
+            id,
+            ...model.displayName ? { displayName: model.displayName } : {},
+            ...model.inputTokenLimit ? { contextWindow: model.inputTokenLimit } : {},
+            ...model.outputTokenLimit ? { metadata: { outputTokenLimit: model.outputTokenLimit } } : {}
+          });
+        }
+        return out;
+      } catch (err) {
+        throw core.wrapProviderError(alias, err);
+      }
+    }
+  };
+}
+function parseUsage(response) {
+  const m = response.usageMetadata ?? {};
+  const inputTokens = m.promptTokenCount ?? 0;
+  const outputTokens = m.candidatesTokenCount ?? 0;
+  const totalTokens = m.totalTokenCount ?? inputTokens + outputTokens;
+  const usage = { inputTokens, outputTokens, totalTokens };
+  if (m.cachedContentTokenCount !== void 0 && m.cachedContentTokenCount > 0) {
+    usage.cacheReadTokens = m.cachedContentTokenCount;
+  }
+  return usage;
+}
+var warnedSchemaFallback = /* @__PURE__ */ new Set();
+function warnSchemaFallback(modelId, feature) {
+  const key = `${modelId}::${feature}`;
+  if (warnedSchemaFallback.has(key)) return;
+  warnedSchemaFallback.add(key);
+  console.warn(
+    `[@llm-ports/adapter-google] generateStructured: model "${modelId}" schema contains "${feature}" which Gemini's responseSchema does not support. Falling back to prompted-JSON + Zod validation (still correct; just slightly weaker constrained-decoding guarantee).`
+  );
+}
+function _resetSchemaFallbackWarnings() {
+  warnedSchemaFallback.clear();
+}
+
+exports.GEMINI_PRICING = GEMINI_PRICING;
+exports._resetSchemaFallbackWarnings = _resetSchemaFallbackWarnings;
+exports.createGoogleAdapter = createGoogleAdapter;
+exports.lookupGeminiPricing = lookupGeminiPricing;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map