@gullabs/google 0.2.0

package/dist/index.js

@@ -0,0 +1,910 @@
+import { assertNever, LlmError, classifyError, redactSecrets } from '@gullabs/core';
+import { ZodOptional, ZodNullable, ZodDefault, ZodObject, ZodString, ZodNumber, ZodBoolean, ZodArray, ZodEnum, ZodLiteral } from 'zod';
+
+// src/adapter.ts
+
+// src/client.ts
+var FLEX_DEFAULT_TIMEOUT_MS = 15e5;
+var TRANSPORT_TIMEOUT_BUFFER_MS = 5e3;
+async function buildGoogleClient(auth) {
+  const { GoogleGenAI } = await import('@google/genai');
+  const ai = new GoogleGenAI({ apiKey: auth.apiKey });
+  return {
+    models: {
+      async generateContent(params) {
+        const result = await ai.models.generateContent(params);
+        return result;
+      }
+    }
+  };
+}
+function isOptionalField(schema) {
+  if (schema instanceof ZodOptional || schema instanceof ZodDefault) return true;
+  if (schema instanceof ZodNullable) {
+    const unwrapped = schema.unwrap();
+    return isOptionalField(unwrapped);
+  }
+  return false;
+}
+function zodToGeminiSchema(schema) {
+  return convertSchema(schema, false);
+}
+function convertSchema(schema, nullable) {
+  const desc = typeof schema.description === "string" ? schema.description : void 0;
+  if (schema instanceof ZodOptional) {
+    const unwrapped = schema.unwrap();
+    return convertSchema(unwrapped, nullable);
+  }
+  if (schema instanceof ZodNullable) {
+    const unwrapped = schema.unwrap();
+    return convertSchema(unwrapped, true);
+  }
+  if (schema instanceof ZodDefault) {
+    const innerType = schema._def.innerType;
+    return convertSchema(innerType, nullable);
+  }
+  if (schema instanceof ZodObject) {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, fieldType] of Object.entries(shape)) {
+      const fieldSchema = convertSchema(fieldType, false);
+      if (fieldSchema === void 0) return void 0;
+      properties[key] = fieldSchema;
+      if (!isOptionalField(fieldType)) {
+        required.push(key);
+      }
+    }
+    const result = {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {},
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+    return result;
+  }
+  if (schema instanceof ZodString) {
+    return {
+      type: "string",
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  if (schema instanceof ZodNumber) {
+    const checks = schema._def.checks ?? [];
+    const isInt = checks.some((c) => c.kind === "int");
+    return {
+      type: isInt ? "integer" : "number",
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  if (schema instanceof ZodBoolean) {
+    return {
+      type: "boolean",
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  if (schema instanceof ZodArray) {
+    const element = schema.element;
+    const items = convertSchema(element, false);
+    if (items === void 0) return void 0;
+    return {
+      type: "array",
+      items,
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  if (schema instanceof ZodEnum) {
+    return {
+      type: "string",
+      enum: schema.options,
+      ...desc !== void 0 ? { description: desc } : {},
+      ...nullable ? { nullable: true } : {}
+    };
+  }
+  if (schema instanceof ZodLiteral) {
+    const val = schema.value;
+    if (typeof val === "string") {
+      return {
+        type: "string",
+        enum: [val],
+        ...desc !== void 0 ? { description: desc } : {},
+        ...nullable ? { nullable: true } : {}
+      };
+    }
+    if (typeof val === "number") {
+      return {
+        type: "number",
+        ...desc !== void 0 ? { description: desc } : {},
+        ...nullable ? { nullable: true } : {}
+      };
+    }
+    if (typeof val === "boolean") {
+      return {
+        type: "boolean",
+        ...desc !== void 0 ? { description: desc } : {},
+        ...nullable ? { nullable: true } : {}
+      };
+    }
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/adapter.ts
+var EFFORT_BUDGET = {
+  none: 0,
+  low: 1024,
+  medium: 8192,
+  high: 24576
+};
+function mapFinishReason(raw) {
+  if (raw === void 0) return void 0;
+  switch (raw) {
+    case "STOP":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "SAFETY":
+    case "RECITATION":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "IMAGE_SAFETY":
+      return "content_filter";
+    default:
+      return "other";
+  }
+}
+function mapMediaResolution(res) {
+  switch (res) {
+    case "low":
+      return "MEDIA_RESOLUTION_LOW";
+    case "medium":
+      return "MEDIA_RESOLUTION_MEDIUM";
+    case "high":
+      return "MEDIA_RESOLUTION_HIGH";
+    default:
+      return assertNever(res);
+  }
+}
+function mapUsage(meta) {
+  const promptTokenCount = meta?.promptTokenCount ?? 0;
+  const candidatesTokenCount = meta?.candidatesTokenCount ?? 0;
+  const cachedContentTokenCount = meta?.cachedContentTokenCount;
+  const thoughtsTokenCount = meta?.thoughtsTokenCount;
+  const outputTokens = candidatesTokenCount + (thoughtsTokenCount ?? 0);
+  const inputTokens = promptTokenCount;
+  const totalTokens = meta?.totalTokenCount;
+  const details = {
+    input: inputTokens,
+    output: outputTokens,
+    ...cachedContentTokenCount !== void 0 ? { cached: cachedContentTokenCount } : {},
+    ...thoughtsTokenCount !== void 0 ? { thinking: thoughtsTokenCount } : {}
+  };
+  const raw = meta !== void 0 ? meta : null;
+  const usage = {
+    inputTokens,
+    outputTokens,
+    details,
+    raw,
+    ...cachedContentTokenCount !== void 0 ? { cachedInputTokens: cachedContentTokenCount } : {},
+    ...thoughtsTokenCount !== void 0 ? { thinkingTokens: thoughtsTokenCount } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+  return usage;
+}
+function geminiAdapter(opts) {
+  return {
+    id: "google",
+    async run(req, ctx) {
+      const warnings = [];
+      const model = req.model;
+      const mapPart = (p) => {
+        switch (p.kind) {
+          case "text":
+            return { text: p.text };
+          case "inline-media": {
+            return {
+              inlineData: {
+                mimeType: p.mimeType,
+                data: p.data
+              },
+              ...p.mediaResolution !== void 0 ? { mediaResolution: { level: mapMediaResolution(p.mediaResolution) } } : {}
+            };
+          }
+          case "file-uri": {
+            return {
+              fileData: {
+                mimeType: p.mimeType,
+                fileUri: p.uri
+              },
+              ...p.mediaResolution !== void 0 ? { mediaResolution: { level: mapMediaResolution(p.mediaResolution) } } : {}
+            };
+          }
+          default:
+            return assertNever(p);
+        }
+      };
+      const contents = req.messages.map((msg) => ({
+        role: msg.role === "assistant" ? "model" : "user",
+        parts: msg.parts.map(mapPart)
+      }));
+      const genConfig = req.config;
+      const config = {};
+      if (req.system !== void 0) {
+        config.systemInstruction = { parts: [{ text: req.system }] };
+      }
+      if (genConfig.temperature !== void 0) {
+        config.temperature = genConfig.temperature;
+      }
+      if (genConfig.topP !== void 0) {
+        config.topP = genConfig.topP;
+      }
+      if (genConfig.topK !== void 0) {
+        config.topK = genConfig.topK;
+      }
+      if (genConfig.maxOutputTokens !== void 0) {
+        config.maxOutputTokens = genConfig.maxOutputTokens;
+      }
+      if (genConfig.stopSequences !== void 0) {
+        config.stopSequences = genConfig.stopSequences;
+      }
+      config.serviceTier = genConfig.serviceTier === "standard" ? "standard" : "flex";
+      const reasoning = genConfig.reasoning;
+      if (reasoning !== void 0) {
+        const reasoningApi = req.modelDescriptor?.capabilities?.reasoningApi;
+        if (reasoningApi === "budget") {
+          const budget = reasoning.budgetTokens !== void 0 ? reasoning.budgetTokens : reasoning.effort !== void 0 ? EFFORT_BUDGET[reasoning.effort] ?? 0 : void 0;
+          config.thinkingConfig = {
+            ...budget !== void 0 ? { thinkingBudget: budget } : {},
+            ...reasoning.includeThoughts === true ? { includeThoughts: true } : {}
+          };
+          if (reasoning.effort !== void 0 && reasoning.budgetTokens !== void 0) {
+            warnings.push({
+              type: "reasoning-mapping",
+              quality: "approximate",
+              details: "budgetTokens takes precedence over effort for thinkingBudget"
+            });
+          }
+        } else if (reasoningApi === "level") {
+          let thinkingLevel;
+          if (reasoning.effort !== void 0) {
+            switch (reasoning.effort) {
+              case "none":
+                thinkingLevel = "MINIMAL";
+                break;
+              case "low":
+                thinkingLevel = "LOW";
+                break;
+              case "medium":
+                thinkingLevel = "MEDIUM";
+                break;
+              case "high":
+                thinkingLevel = "HIGH";
+                break;
+              default:
+                assertNever(reasoning.effort);
+            }
+          }
+          if (reasoning.budgetTokens !== void 0) {
+            warnings.push({
+              type: "reasoning-mapping",
+              quality: "approximate",
+              details: "budgetTokens is not supported for gemini-3.x models; mapping effort to thinkingLevel instead"
+            });
+          }
+          config.thinkingConfig = {
+            ...thinkingLevel !== void 0 ? { thinkingLevel } : {},
+            ...reasoning.includeThoughts === true ? { includeThoughts: true } : {}
+          };
+        } else {
+          warnings.push({
+            type: "reasoning-mapping",
+            quality: "unsupported",
+            details: `thinkingConfig not mapped for model "${model}"; unknown generation`
+          });
+        }
+      }
+      let outputSchemaRequested = false;
+      if (req.outputSchema !== void 0) {
+        outputSchemaRequested = true;
+        config.responseMimeType = "application/json";
+        if (req.outputSchema["~standard"].vendor === "zod") {
+          const geminiSchema = zodToGeminiSchema(req.outputSchema);
+          if (geminiSchema !== void 0) {
+            config.responseSchema = geminiSchema;
+          } else {
+            warnings.push({
+              type: "unsupported-setting",
+              setting: "output.schema",
+              details: "Could not convert Zod schema to Gemini responseSchema; proceeding with responseMimeType only. Engine will still validate."
+            });
+          }
+        } else {
+          warnings.push({
+            type: "other",
+            message: `Native Gemini responseSchema conversion is not available for vendor "${req.outputSchema["~standard"].vendor}"; proceeding with responseMimeType only. Engine will validate output client-side via Standard Schema.`
+          });
+        }
+      }
+      const googleOpts = genConfig.providerOptions?.["google"];
+      if (googleOpts !== void 0 && typeof googleOpts === "object" && googleOpts !== null) {
+        Object.assign(config, googleOpts);
+      }
+      if (req.modelDescriptor?.capabilities?.sampling === "fixed") {
+        const droppedSampling = [];
+        if ("temperature" in config) {
+          delete config.temperature;
+          droppedSampling.push("temperature");
+        }
+        if ("topP" in config) {
+          delete config.topP;
+          droppedSampling.push("topP");
+        }
+        if ("topK" in config) {
+          delete config.topK;
+          droppedSampling.push("topK");
+        }
+        if (droppedSampling.length > 0) {
+          warnings.push({
+            type: "unsupported-setting",
+            setting: droppedSampling.join(", "),
+            details: `Sampling parameter(s) [${droppedSampling.join(
+              ", "
+            )}] from providerOptions.google were stripped: this model has fixed sampling (Gemini 3.x) and the API rejects these fields.`
+          });
+        }
+      }
+      const configAsAny = config;
+      const groundingRequested = Array.isArray(configAsAny.tools) && configAsAny.tools.some((t) => {
+        if (t !== null && typeof t === "object") {
+          const tool = t;
+          return "googleSearch" in tool || "googleSearchRetrieval" in tool;
+        }
+        return false;
+      });
+      if (groundingRequested && req.outputSchema !== void 0) {
+        throw new LlmError(
+          "Grounding (googleSearch) cannot be combined with structured output (output.schema) on Gemini; choose one.",
+          { kind: "bad_request", retryable: false }
+        );
+      }
+      let _flexTimeoutHandle;
+      if (config.serviceTier === "flex" && genConfig.timeoutMs === void 0) {
+        const flexController = new AbortController();
+        const timeoutReason = new DOMException(
+          `Flex timeout: call exceeded ${FLEX_DEFAULT_TIMEOUT_MS}ms client-side ceiling (@google/genai #1277 belt-and-suspenders)`,
+          "TimeoutError"
+        );
+        _flexTimeoutHandle = setTimeout(() => {
+          flexController.abort(timeoutReason);
+        }, FLEX_DEFAULT_TIMEOUT_MS);
+        if (ctx.signal !== void 0) {
+          config.abortSignal = AbortSignal.any([flexController.signal, ctx.signal]);
+        } else {
+          config.abortSignal = flexController.signal;
+        }
+      } else if (ctx.signal !== void 0) {
+        config.abortSignal = ctx.signal;
+      }
+      const callerHttpOptions = config.httpOptions;
+      const computedTimeoutMs = genConfig.timeoutMs !== void 0 ? genConfig.timeoutMs + TRANSPORT_TIMEOUT_BUFFER_MS : genConfig.serviceTier === "flex" ? FLEX_DEFAULT_TIMEOUT_MS : void 0;
+      const mergedHttpOptions = {
+        ...computedTimeoutMs !== void 0 ? { timeout: computedTimeoutMs } : {},
+        ...callerHttpOptions
+      };
+      if (Object.keys(mergedHttpOptions).length > 0) {
+        config.httpOptions = mergedHttpOptions;
+      }
+      const params = {
+        model,
+        contents,
+        config
+      };
+      let response;
+      try {
+        const buildClient = opts?._clientFactory ?? buildGoogleClient;
+        const client = opts?.client !== void 0 ? opts.client : await buildClient(ctx.auth);
+        ctx.logger.debug(
+          { model, configKeys: Object.keys(config) },
+          "llm.adapter.dispatch"
+        );
+        response = await client.models.generateContent(params);
+      } catch (rawErr) {
+        const classified = classifyError(rawErr);
+        throw new LlmError(classified.message, {
+          kind: classified.kind,
+          retryable: classified.retryable,
+          ...classified.httpStatus !== void 0 ? { httpStatus: classified.httpStatus } : {},
+          ...classified.retryAfterMs !== void 0 ? { retryAfterMs: classified.retryAfterMs } : {},
+          provider: "google",
+          cause: classified.cause ?? rawErr
+        });
+      } finally {
+        if (_flexTimeoutHandle !== void 0) clearTimeout(_flexTimeoutHandle);
+      }
+      const hasBlockReason = response.promptFeedback?.blockReason !== void 0;
+      const hasCandidates = response.candidates !== void 0 && response.candidates.length > 0;
+      if (hasBlockReason || !hasCandidates) {
+        const reason = response.promptFeedback?.blockReason ?? "NO_CANDIDATES";
+        throw new LlmError(`Gemini response blocked: ${reason}`, {
+          kind: "content_filter",
+          retryable: false,
+          provider: "google"
+        });
+      }
+      const candidates = response.candidates;
+      if (candidates === void 0 || candidates.length === 0) {
+        throw new LlmError("Gemini response blocked: NO_CANDIDATES", {
+          kind: "content_filter",
+          retryable: false,
+          provider: "google"
+        });
+      }
+      const candidate = candidates[0];
+      if (candidate === void 0) {
+        throw new LlmError("Gemini response blocked: NO_CANDIDATES", {
+          kind: "content_filter",
+          retryable: false,
+          provider: "google"
+        });
+      }
+      const parts = candidate.content?.parts ?? [];
+      const textParts = [];
+      const thoughtParts = [];
+      for (const part of parts) {
+        if (part.text !== void 0) {
+          if (part.thought === true) {
+            thoughtParts.push(part.text);
+          } else {
+            textParts.push(part.text);
+          }
+        }
+      }
+      const text = textParts.join("");
+      const reasoningText = thoughtParts.length > 0 ? thoughtParts.join("") : void 0;
+      let rawStructured;
+      if (outputSchemaRequested && text.length > 0) {
+        try {
+          rawStructured = JSON.parse(text);
+        } catch {
+        }
+      }
+      const usage = mapUsage(response.usageMetadata);
+      const finishReason = mapFinishReason(candidate.finishReason);
+      const result = {
+        model,
+        usage,
+        warnings,
+        ...text.length > 0 ? { text } : {},
+        ...reasoningText !== void 0 ? { reasoningText } : {},
+        ...rawStructured !== void 0 ? { rawStructured } : {},
+        ...finishReason !== void 0 ? { finishReason } : {},
+        ...response.modelVersion !== void 0 ? { modelVersion: response.modelVersion } : {},
+        ...response.responseId !== void 0 ? { responseId: response.responseId } : {},
+        // Build providerMetadata — merge promptFeedback + groundingMetadata when present.
+        ...(() => {
+          const pf = response.promptFeedback;
+          const gm = candidate.groundingMetadata;
+          if (pf === void 0 && gm === void 0) return {};
+          const meta = {};
+          if (pf !== void 0) {
+            meta["promptFeedback"] = pf;
+          }
+          if (gm !== void 0) {
+            meta["groundingMetadata"] = gm;
+          }
+          return { providerMetadata: meta };
+        })()
+      };
+      return result;
+    }
+  };
+}
+var DEFAULT_INTERVAL_MS = 3e3;
+var DEFAULT_TIMEOUT_MS = 3e5;
+var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function buildFilesClient(auth) {
+  const { GoogleGenAI } = await import('@google/genai');
+  const ai = new GoogleGenAI({ apiKey: auth.apiKey });
+  return {
+    async upload(params) {
+      const fileArg = params.file instanceof Uint8Array ? new Blob(
+        [params.file],
+        params.config?.mimeType !== void 0 && params.config.mimeType.length > 0 ? { type: params.config.mimeType } : {}
+      ) : params.file;
+      const result = await ai.files.upload({
+        file: fileArg,
+        ...params.config !== void 0 ? { config: params.config } : {}
+      });
+      return result;
+    },
+    async get(params) {
+      const result = await ai.files.get(params);
+      return result;
+    },
+    async delete(params) {
+      await ai.files.delete(params);
+    }
+  };
+}
+function makeHandle(resp, fallback) {
+  const et = resp.expirationTime;
+  return {
+    name: resp.name ?? fallback.name,
+    uri: resp.uri ?? fallback.uri,
+    mimeType: resp.mimeType ?? fallback.mimeType,
+    ...et !== void 0 && et.length > 0 ? { expiresAt: new Date(et) } : {}
+  };
+}
+var GoogleFileStore = class {
+  auth;
+  clientOverride;
+  onDeleteError;
+  logger;
+  intervalMs;
+  timeoutMs;
+  sleep;
+  now;
+  /** Memoised client promise — built at most once per store instance. */
+  clientPromise;
+  constructor(opts) {
+    this.auth = opts.auth;
+    this.clientOverride = opts.client;
+    this.logger = opts.logger;
+    this.onDeleteError = opts.onDeleteError ?? ((name, err) => {
+      if (this.logger !== void 0) {
+        this.logger.error(
+          { name, error: redactSecrets(classifyError(err).message) },
+          "gemini.file.delete.failed"
+        );
+      } else {
+        console.error(
+          `[GoogleFileStore] delete failed for "${name}":`,
+          redactSecrets(classifyError(err).message)
+        );
+      }
+    });
+    this.intervalMs = opts.poll?.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.timeoutMs = opts.poll?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.sleep = opts.sleep ?? realSleep;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  getClient() {
+    if (this.clientOverride !== void 0) return Promise.resolve(this.clientOverride);
+    if (this.clientPromise === void 0) {
+      this.clientPromise = buildFilesClient(this.auth);
+    }
+    return this.clientPromise;
+  }
+  /**
+   * Upload bytes to the Gemini File API and wait until the file is ACTIVE.
+   *
+   * @param source  - Raw bytes or Blob.
+   * @param mimeType - IANA media type, e.g. `"image/png"`.
+   * @param opts    - Optional display name.
+   */
+  async upload(source, mimeType, opts) {
+    const signal = opts?.signal;
+    const client = await this.getClient();
+    let uploadResp;
+    try {
+      uploadResp = await client.upload({
+        file: source,
+        config: {
+          mimeType,
+          ...opts?.displayName !== void 0 ? { displayName: opts.displayName } : {}
+        }
+      });
+    } catch (e) {
+      throw classifyError(e);
+    }
+    const { name, uri } = uploadResp;
+    if (name === void 0 || name.length === 0 || uri === void 0 || uri.length === 0) {
+      throw new LlmError("File upload response missing required fields (name or uri)", {
+        kind: "bad_request",
+        retryable: false
+      });
+    }
+    const fallback = { name, uri, mimeType };
+    if (uploadResp.state === "ACTIVE") {
+      return makeHandle(uploadResp, fallback);
+    }
+    if (uploadResp.state === "FAILED") {
+      throw new LlmError("File processing failed immediately after upload", {
+        kind: "bad_request",
+        retryable: false
+      });
+    }
+    const deadline = this.now() + this.timeoutMs;
+    if (signal?.aborted === true) {
+      throw new LlmError("File upload polling aborted", {
+        kind: "aborted",
+        retryable: false
+      });
+    }
+    const abortRacePromise = signal !== void 0 ? new Promise((_, reject) => {
+      signal.addEventListener(
+        "abort",
+        () => {
+          reject(
+            new LlmError("File upload polling aborted", {
+              kind: "aborted",
+              retryable: false
+            })
+          );
+        },
+        { once: true }
+      );
+    }) : void 0;
+    for (; ; ) {
+      if (this.now() >= deadline) {
+        throw new LlmError("Timed out waiting for uploaded file to become ACTIVE", {
+          kind: "timeout",
+          retryable: true
+        });
+      }
+      const sleepCall = this.sleep(this.intervalMs);
+      await (abortRacePromise !== void 0 ? Promise.race([sleepCall, abortRacePromise]) : sleepCall);
+      let pollResp;
+      try {
+        pollResp = await client.get({ name });
+      } catch (e) {
+        throw classifyError(e);
+      }
+      if (signal?.aborted === true) {
+        throw new LlmError("File upload polling aborted", {
+          kind: "aborted",
+          retryable: false
+        });
+      }
+      if (pollResp.state === "ACTIVE") {
+        return makeHandle(pollResp, fallback);
+      }
+      if (pollResp.state === "FAILED") {
+        throw new LlmError("File processing failed during polling", {
+          kind: "bad_request",
+          retryable: false
+        });
+      }
+    }
+  }
+  /**
+   * Delete a single uploaded file.
+   * Errors are forwarded to `onDeleteError` and NOT rethrown.
+   */
+  async delete(handle) {
+    try {
+      const client = await this.getClient();
+      await client.delete({ name: handle.name });
+    } catch (err) {
+      this.onDeleteError(handle.name, err);
+    }
+  }
+  /**
+   * Delete multiple files.
+   * Each failure is individually forwarded to `onDeleteError`; none are thrown.
+   */
+  async deleteAll(handles) {
+    await Promise.allSettled(handles.map((h) => this.delete(h)));
+  }
+};
+var DEFAULT_SKEW_SECONDS = 30;
+var DEFAULT_EXTENSION_SECONDS = 3600;
+async function buildCachesClient(auth) {
+  const { GoogleGenAI } = await import('@google/genai');
+  const ai = new GoogleGenAI({ apiKey: auth.apiKey });
+  return {
+    async create(params) {
+      const result = await ai.caches.create(params);
+      return result;
+    },
+    async update(params) {
+      const result = await ai.caches.update(params);
+      return result;
+    },
+    async delete(params) {
+      await ai.caches.delete(params);
+    }
+  };
+}
+var GoogleCacheStore = class {
+  auth;
+  clientOverride;
+  coalesce;
+  skewMs;
+  onDeleteError;
+  logger;
+  now;
+  /** Memoised client promise — built at most once per store instance. */
+  clientPromise;
+  /** In-process cache of live handles, keyed by `${model}:${stableKey}`. */
+  entries = /* @__PURE__ */ new Map();
+  /** In-flight create promises when coalescing is enabled. */
+  inflight = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.auth = opts.auth;
+    this.clientOverride = opts.client;
+    this.coalesce = opts.coalesce ?? false;
+    this.skewMs = (opts.expirySkewSeconds ?? DEFAULT_SKEW_SECONDS) * 1e3;
+    this.logger = opts.logger;
+    this.onDeleteError = opts.onDeleteError ?? ((cacheName, err) => {
+      if (this.logger !== void 0) {
+        this.logger.error(
+          { name: cacheName, error: redactSecrets(classifyError(err).message) },
+          "gemini.cache.delete.failed"
+        );
+      } else {
+        console.error(
+          `[GoogleCacheStore] delete failed for "${cacheName}":`,
+          redactSecrets(classifyError(err).message)
+        );
+      }
+    });
+    this.now = opts.now ?? (() => Date.now());
+  }
+  getClient() {
+    if (this.clientOverride !== void 0) return Promise.resolve(this.clientOverride);
+    if (this.clientPromise === void 0) {
+      this.clientPromise = buildCachesClient(this.auth);
+    }
+    return this.clientPromise;
+  }
+  isLive(handle) {
+    return handle.expiresAt.getTime() - this.skewMs > this.now();
+  }
+  /**
+   * Create a new cached content resource.
+   *
+   * The `expiresAt` on the returned handle is computed from the server's
+   * `expireTime` when available, with a local-clock fallback of
+   * `now + ttlSeconds * 1000`.
+   */
+  async create(input) {
+    const client = await this.getClient();
+    const config = { ttl: `${input.ttlSeconds}s` };
+    if (input.contents !== void 0) config.contents = input.contents;
+    if (input.systemInstruction !== void 0)
+      config.systemInstruction = input.systemInstruction;
+    if (input.displayName !== void 0) config.displayName = input.displayName;
+    let resp;
+    try {
+      resp = await client.create({ model: input.model, config });
+    } catch (e) {
+      throw classifyError(e);
+    }
+    if (resp.name === void 0 || resp.name.length === 0) {
+      throw new LlmError("Cache create response missing required field: name", {
+        kind: "bad_request",
+        retryable: false
+      });
+    }
+    const fallbackExpiry = new Date(this.now() + input.ttlSeconds * 1e3);
+    const expiresAt = resp.expireTime !== void 0 && resp.expireTime.length > 0 ? new Date(resp.expireTime) : fallbackExpiry;
+    return {
+      cacheName: resp.name,
+      model: resp.model ?? input.model,
+      expiresAt
+    };
+  }
+  /**
+   * Return a live cached-content handle, creating one if none exists or the
+   * cached entry has expired (accounting for skew).
+   *
+   * Reuse is PROCESS-SCOPED only — this store instance's in-memory map.
+   *
+   * When `coalesce` is enabled, concurrent calls for the same key share one
+   * in-flight create.
+   */
+  async getOrCreate(key, factory) {
+    const mapKey = `${key.model}:${key.stableKey}`;
+    const existing = this.entries.get(mapKey);
+    if (existing !== void 0 && this.isLive(existing.handle)) {
+      return existing.handle;
+    }
+    if (this.coalesce) {
+      const inFlight = this.inflight.get(mapKey);
+      if (inFlight !== void 0) {
+        return inFlight;
+      }
+    }
+    const doCreate = async () => {
+      const factoryResult = await factory();
+      const handle = await this.create({
+        model: key.model,
+        ttlSeconds: factoryResult.ttlSeconds,
+        ...factoryResult.contents !== void 0 ? { contents: factoryResult.contents } : {},
+        ...factoryResult.systemInstruction !== void 0 ? { systemInstruction: factoryResult.systemInstruction } : {}
+      });
+      this.entries.set(mapKey, { handle, ttlSeconds: factoryResult.ttlSeconds });
+      return handle;
+    };
+    if (this.coalesce) {
+      const promise = doCreate().finally(() => {
+        this.inflight.delete(mapKey);
+      });
+      this.inflight.set(mapKey, promise);
+      return promise;
+    }
+    return doCreate();
+  }
+  /**
+   * Extend the cache TTL if it will expire within `thresholdSeconds`.
+   *
+   * Fail-open: if the update call throws, the original handle is returned
+   * unchanged.  This method NEVER throws.
+   *
+   * @param handle - Handle to potentially refresh.
+   * @param opts.thresholdSeconds - Extend if expiry is within this many seconds.
+   *   Default 300.
+   * @param opts.extensionSeconds - New TTL to set.  Default: original TTL from
+   *   entries map, or 3600 s when the handle was not created via `getOrCreate`.
+   */
+  async refreshIfExpiringSoon(handle, opts) {
+    const thresholdMs = (opts?.thresholdSeconds ?? 300) * 1e3;
+    if (handle.expiresAt.getTime() - this.now() > thresholdMs) {
+      return handle;
+    }
+    let extensionSeconds = opts?.extensionSeconds;
+    if (extensionSeconds === void 0) {
+      for (const entry of this.entries.values()) {
+        if (entry.handle.cacheName === handle.cacheName) {
+          extensionSeconds = entry.ttlSeconds;
+          break;
+        }
+      }
+      extensionSeconds = extensionSeconds ?? DEFAULT_EXTENSION_SECONDS;
+    }
+    try {
+      const client = await this.getClient();
+      const resp = await client.update({
+        name: handle.cacheName,
+        config: { ttl: `${extensionSeconds}s` }
+      });
+      const fallbackExpiry = new Date(this.now() + extensionSeconds * 1e3);
+      const newExpiresAt = resp.expireTime !== void 0 && resp.expireTime.length > 0 ? new Date(resp.expireTime) : fallbackExpiry;
+      const newHandle = {
+        cacheName: handle.cacheName,
+        model: handle.model,
+        expiresAt: newExpiresAt
+      };
+      for (const [k, entry] of this.entries.entries()) {
+        if (entry.handle.cacheName === handle.cacheName) {
+          this.entries.set(k, { handle: newHandle, ttlSeconds: extensionSeconds });
+          break;
+        }
+      }
+      return newHandle;
+    } catch {
+      return handle;
+    }
+  }
+  /**
+   * Delete a cached content resource.
+   *
+   * Errors are forwarded to `onDeleteError` and NOT rethrown.
+   * The handle is removed from the in-process entries map regardless.
+   */
+  async delete(handle) {
+    for (const [k, entry] of this.entries.entries()) {
+      if (entry.handle.cacheName === handle.cacheName) {
+        this.entries.delete(k);
+        break;
+      }
+    }
+    try {
+      const client = await this.getClient();
+      await client.delete({ name: handle.cacheName });
+    } catch (err) {
+      this.onDeleteError(handle.cacheName, err);
+    }
+  }
+};
+
+export { FLEX_DEFAULT_TIMEOUT_MS, GoogleCacheStore, GoogleFileStore, TRANSPORT_TIMEOUT_BUFFER_MS, buildGoogleClient, geminiAdapter, zodToGeminiSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map