@gullabs/google 0.6.1 → 0.8.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var core = require('@gullabs/core');
+var zod = require('zod');
 
 // src/adapter.ts
 function requireApiKey(auth) {
@@ -24,6 +25,10 @@ async function buildGoogleClient(auth) {
       async generateContent(params) {
         const result = await ai.models.generateContent(params);
         return result;
+      },
+      async countTokens(params) {
+        const result = await ai.models.countTokens(params);
+        return result;
       }
     }
   };
@@ -69,6 +74,7 @@ function isGeminiCapacityError(err) {
 // src/adapter.ts
 var ALLOWED_GOOGLE_PROVIDER_OPTION_KEYS = /* @__PURE__ */ new Set([
   "cachedContent",
+  "flexFallback",
   "httpOptions",
   "safetySettings",
   "tools"
@@ -199,7 +205,7 @@ function mapGoogleProviderOptions(googleOpts, model, structuredOutputRequested,
     throw badGoogleProviderOptions(
       `providerOptions.google contains unsupported keys [${unknownKeys.join(
         ", "
-      )}] for model "${model}". Allowed keys: cachedContent, httpOptions, safetySettings, tools.`
+      )}] for model "${model}". Allowed keys: cachedContent, flexFallback, httpOptions, safetySettings, tools.`
     );
   }
   const mapped = {};
@@ -211,6 +217,14 @@ function mapGoogleProviderOptions(googleOpts, model, structuredOutputRequested,
     }
     mapped.cachedContent = googleOpts["cachedContent"];
   }
+  if (googleOpts["flexFallback"] !== void 0) {
+    if (typeof googleOpts["flexFallback"] !== "boolean") {
+      throw badGoogleProviderOptions(
+        `providerOptions.google.flexFallback must be a boolean for model "${model}".`
+      );
+    }
+    mapped.flexFallback = googleOpts["flexFallback"];
+  }
   if (googleOpts["httpOptions"] !== void 0) {
     if (!isPlainRecord(googleOpts["httpOptions"])) {
       throw badGoogleProviderOptions(
@@ -347,42 +361,51 @@ function mapUsage(meta) {
   };
   return usage;
 }
+function 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 core.assertNever(p);
+  }
+}
+function mapMessagesToGeminiContents(messages) {
+  return messages.map((msg) => ({
+    role: msg.role === "assistant" ? "model" : "user",
+    parts: msg.parts.map(mapPart)
+  }));
+}
 function geminiAdapter(opts) {
   return {
     id: "google",
     async run(req, ctx) {
+      if (req.provider !== "google") {
+        throw new core.LlmError(
+          `geminiAdapter received a request for provider "${req.provider}", expected "google".`,
+          { kind: "bad_request", retryable: false }
+        );
+      }
       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 core.assertNever(p);
-        }
-      };
-      const contents = req.messages.map((msg) => ({
-        role: msg.role === "assistant" ? "model" : "user",
-        parts: msg.parts.map(mapPart)
-      }));
+      const contents = mapMessagesToGeminiContents(req.messages);
       const genConfig = req.config;
       const config = {};
       if (req.system !== void 0) {
@@ -566,7 +589,7 @@ function geminiAdapter(opts) {
           cause: classified.cause ?? rawErr,
           ...servedServiceTier !== void 0 ? { servedServiceTier } : {}
         });
-        if (config.serviceTier === "flex" && genConfig.flexFallback !== false && isGeminiCapacityError(typed)) {
+        if (config.serviceTier === "flex" && googleProviderConfig.flexFallback !== false && isGeminiCapacityError(typed)) {
           config.serviceTier = "standard";
           servedServiceTier = "standard";
           const fallbackTimeout = genConfig.timeoutMs !== void 0 ? genConfig.timeoutMs + TRANSPORT_TIMEOUT_BUFFER_MS : STANDARD_DEFAULT_TIMEOUT_MS;
@@ -671,9 +694,2006 @@ function geminiAdapter(opts) {
         })()
       };
       return result;
+    },
+    async countTokens(req, ctx) {
+      if (req.provider !== "google") {
+        throw new core.LlmError(
+          `geminiAdapter received a request for provider "${req.provider}", expected "google".`,
+          { kind: "bad_request", retryable: false }
+        );
+      }
+      const contents = mapMessagesToGeminiContents(req.messages);
+      const params = {
+        model: req.model,
+        contents,
+        ...req.system !== void 0 || ctx.signal !== void 0 ? {
+          config: {
+            ...req.system !== void 0 ? { systemInstruction: { parts: [{ text: req.system }] } } : {},
+            ...ctx.signal !== void 0 ? { abortSignal: ctx.signal } : {}
+          }
+        } : {}
+      };
+      try {
+        const buildClient = opts?._clientFactory ?? buildGoogleClient;
+        const client = opts?.client !== void 0 ? opts.client : await buildClient(ctx.auth);
+        const response = await client.models.countTokens(params);
+        if (response.totalTokens === void 0) {
+          throw new core.LlmError(
+            "Gemini countTokens response is malformed: missing required field: totalTokens",
+            { kind: "server", retryable: true, provider: "google" }
+          );
+        }
+        const details = response.cachedContentTokenCount !== void 0 ? { cached: response.cachedContentTokenCount } : void 0;
+        return {
+          totalTokens: response.totalTokens,
+          ...details !== void 0 ? { details } : {},
+          raw: response
+        };
+      } catch (rawErr) {
+        if (rawErr instanceof core.LlmError) throw rawErr;
+        const classified = core.classifyError(rawErr);
+        throw new core.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
+        });
+      }
     }
   };
 }
+
+// src/pricing.ts
+var pricingVersion = "gemini-2026-06-28";
+var TIER_FACTOR = Object.freeze({
+  standard: 1,
+  flex: 0.5,
+  batch: 0.5
+});
+var GEMINI_PRICING = Object.freeze({
+  // ── Gemini 2.5 Pro ──  $1.25/$10 (≤200k), $2.50/$15 (>200k); cached $0.125/$0.25
+  "gemini-2.5-pro": {
+    inputPerM: 125e4,
+    cachedPerM: 125e3,
+    outputPerM: 1e7,
+    gt200k: {
+      inputPerM: 25e5,
+      cachedPerM: 25e4,
+      outputPerM: 15e6
+    }
+  },
+  // ── Gemini 2.5 Flash ──  input $0.30 (text), output $2.50, cached $0.03
+  "gemini-2.5-flash": {
+    inputPerM: 3e5,
+    cachedPerM: 3e4,
+    outputPerM: 25e5
+  },
+  // ── Gemini 2.5 Flash-Lite ──  input $0.10 (text), output $0.40, cached $0.01
+  "gemini-2.5-flash-lite": {
+    inputPerM: 1e5,
+    cachedPerM: 1e4,
+    outputPerM: 4e5
+  },
+  // ── Gemini 3.5 Flash ──  input $1.50, output $9.00, cached $0.15
+  "gemini-3.5-flash": {
+    inputPerM: 15e5,
+    cachedPerM: 15e4,
+    outputPerM: 9e6
+  },
+  // ── Gemini 3.1 Flash-Lite ──  input $0.25 (text), output $1.50, cached $0.025
+  "gemini-3.1-flash-lite": {
+    inputPerM: 25e4,
+    cachedPerM: 25e3,
+    outputPerM: 15e5
+  },
+  // ── Gemini 3.1 Pro (preview) ──  $2.00/$12 (≤200k), $4.00/$18 (>200k); cached $0.20/$0.40
+  "gemini-3.1-pro-preview": {
+    inputPerM: 2e6,
+    cachedPerM: 2e5,
+    outputPerM: 12e6,
+    gt200k: {
+      inputPerM: 4e6,
+      cachedPerM: 4e5,
+      outputPerM: 18e6
+    }
+  },
+  // ── Gemini 3 Flash (preview) ──  input $0.50, output $3.00, cached $0.05 (90% discount)
+  "gemini-3-flash-preview": {
+    inputPerM: 5e5,
+    cachedPerM: 5e4,
+    outputPerM: 3e6
+  }
+});
+
+// src/cost.ts
+function lookupRates(model) {
+  const exact = GEMINI_PRICING[model];
+  if (exact !== void 0) return exact;
+  let bestKey = "";
+  let bestRates;
+  for (const key of Object.keys(GEMINI_PRICING)) {
+    if (model.startsWith(key) && key.length > bestKey.length) {
+      bestKey = key;
+      bestRates = GEMINI_PRICING[key];
+    }
+  }
+  return bestRates;
+}
+function geminiPricingSource() {
+  return {
+    version: pricingVersion,
+    price(model, usage, tier) {
+      return core.computeCost(model, usage, tier, lookupRates, TIER_FACTOR, pricingVersion);
+    },
+    hasModel(model) {
+      return lookupRates(model) !== void 0;
+    },
+    listModels() {
+      return Object.keys(GEMINI_PRICING);
+    }
+  };
+}
+var Gemini25ProConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-pro.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-pro."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-pro."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-pro."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-pro."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-2.5-pro."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-pro. Thinking off is not supported."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.number().int().min(128).max(32768).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-pro."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Pro thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-pro."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-pro."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-pro."
+    })
+  }),
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-pro.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-pro."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-pro."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-pro."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-pro."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-2.5-pro."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-pro. Thinking off is not supported."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.number().int().min(128).max(32768).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-pro."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Pro thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-pro."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-pro."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-pro."
+    })
+  })
+]).meta({
+  title: "Gemini25ProConfig",
+  description: "Strict generateContent config for model gemini-2.5-pro. Budget reasoning, tunable sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", temperature: 0.7, reasoning: { effort: "high" } }]
+});
+var Gemini25FlashConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-flash.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-flash."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-flash."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-flash."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-flash."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-2.5-flash."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-flash."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.number().int().min(0).max(24576).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-flash."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Flash thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-flash."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-flash."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-flash."
+    })
+  }),
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-flash.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-flash."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-flash."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-flash."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-flash."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-2.5-flash."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-flash."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.number().int().min(0).max(24576).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-flash."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Flash thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-flash."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-flash."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-flash."
+    })
+  })
+]).meta({
+  title: "Gemini25FlashConfig",
+  description: "Strict generateContent config for model gemini-2.5-flash. Budget reasoning, tunable sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", temperature: 0.7, reasoning: { effort: "none" } }]
+});
+var Gemini25FlashLiteConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-flash-lite.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-flash-lite."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-flash-lite."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-flash-lite."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-flash-lite."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-2.5-flash-lite."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-flash-lite."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.union([zod.z.literal(0), zod.z.number().int().min(512).max(24576)]).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-flash-lite. Zero disables thinking; non-zero values must be 512..24576."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Flash-Lite thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-flash-lite."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-flash-lite."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-flash-lite."
+    })
+  }),
+  zod.z.strictObject({
+    temperature: zod.z.number().min(0).max(2).optional().meta({
+      title: "Temperature",
+      description: "Sampling temperature for gemini-2.5-flash-lite.",
+      examples: [0.7]
+    }),
+    topP: zod.z.number().min(0).max(1).optional().meta({
+      title: "Top P",
+      description: "Nucleus sampling probability for gemini-2.5-flash-lite."
+    }),
+    topK: zod.z.number().int().positive().optional().meta({
+      title: "Top K",
+      description: "Top-k sampling limit for gemini-2.5-flash-lite."
+    }),
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-2.5-flash-lite."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-2.5-flash-lite."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-2.5-flash-lite."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-2.5-flash-lite."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        budgetTokens: zod.z.union([zod.z.literal(0), zod.z.number().int().min(512).max(24576)]).meta({
+          title: "Reasoning Budget Tokens",
+          description: "thinkingBudget token range for gemini-2.5-flash-lite. Zero disables thinking; non-zero values must be 512..24576."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 2.5 Flash-Lite thinkingBudget configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-2.5-flash-lite."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-2.5-flash-lite."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-2.5-flash-lite."
+    })
+  })
+]).meta({
+  title: "Gemini25FlashLiteConfig",
+  description: "Strict generateContent config for model gemini-2.5-flash-lite. Budget reasoning, tunable sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", temperature: 0.7, reasoning: { budgetTokens: 0 } }]
+});
+var Gemini35FlashConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.5-flash."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.5-flash."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-3.5-flash."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.5-flash; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.5 Flash thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.5-flash."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.5-flash."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.5-flash."
+    })
+  }),
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.5-flash."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.5-flash."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-3.5-flash."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.5-flash; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.5 Flash thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.5-flash."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.5-flash."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.5-flash."
+    })
+  })
+]).meta({
+  title: "Gemini35FlashConfig",
+  description: "Strict generateContent config for model gemini-3.5-flash. Level reasoning, fixed sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", reasoning: { effort: "high" } }]
+});
+var Gemini31FlashLiteConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.1-flash-lite."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.1-flash-lite."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-3.1-flash-lite."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.1-flash-lite; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.1 Flash-Lite thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.1-flash-lite."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.1-flash-lite."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.1-flash-lite."
+    })
+  }),
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.1-flash-lite."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.1-flash-lite."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-3.1-flash-lite."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.1-flash-lite; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.1 Flash-Lite thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.1-flash-lite."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.1-flash-lite."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.1-flash-lite."
+    })
+  })
+]).meta({
+  title: "Gemini31FlashLiteConfig",
+  description: "Strict generateContent config for model gemini-3.1-flash-lite. Level reasoning, fixed sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", reasoning: { effort: "medium" } }]
+});
+var Gemini31ProPreviewConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.1-pro-preview."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.1-pro-preview."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-3.1-pro-preview."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.1-pro-preview. Thinking off is not supported."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.1 Pro Preview thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.1-pro-preview."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.1-pro-preview."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.1-pro-preview."
+    })
+  }),
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3.1-pro-preview."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3.1-pro-preview."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-3.1-pro-preview."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3.1-pro-preview. Thinking off is not supported."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3.1 Pro Preview thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3.1-pro-preview."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3.1-pro-preview."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3.1-pro-preview."
+    })
+  })
+]).meta({
+  title: "Gemini31ProPreviewConfig",
+  description: "Strict generateContent config for model gemini-3.1-pro-preview. Level reasoning, fixed sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", reasoning: { effort: "high" } }]
+});
+var Gemini3FlashPreviewConfigSchema = zod.z.union([
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3-flash-preview."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3-flash-preview."
+    }),
+    serviceTier: zod.z.literal("flex").meta({
+      title: "Service Tier",
+      description: "Explicit flex tier for gemini-3-flash-preview."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3-flash-preview; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3 Flash Preview thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3-flash-preview."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        }),
+        flexFallback: zod.z.boolean().optional().meta({
+          title: "Flex Fallback",
+          description: "Allow provider fallback from flex when flex was explicitly selected."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3-flash-preview."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3-flash-preview."
+    })
+  }),
+  zod.z.strictObject({
+    maxOutputTokens: zod.z.number().int().positive().optional().meta({
+      title: "Max Output Tokens",
+      description: "Maximum output token cap for gemini-3-flash-preview."
+    }),
+    stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+      title: "Stop Sequences",
+      description: "Up to five stop sequences for gemini-3-flash-preview."
+    }),
+    serviceTier: zod.z.literal("standard").optional().meta({
+      title: "Service Tier",
+      description: "Standard tier or omitted tier for gemini-3-flash-preview."
+    }),
+    reasoning: zod.z.union([
+      zod.z.strictObject({
+        effort: zod.z.enum(["none", "low", "medium", "high"]).meta({
+          title: "Reasoning Effort",
+          description: "Reasoning effort for gemini-3-flash-preview; none maps to minimal thinking."
+        }),
+        includeThoughts: zod.z.boolean().optional().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      }),
+      zod.z.strictObject({
+        includeThoughts: zod.z.boolean().meta({
+          title: "Include Thoughts",
+          description: "Return provider thought summaries when supported."
+        })
+      })
+    ]).optional().meta({
+      title: "Reasoning",
+      description: "Gemini 3 Flash Preview thinkingLevel configuration."
+    }),
+    timeoutMs: zod.z.number().int().positive().optional().meta({
+      title: "Timeout",
+      description: "Logical request timeout in milliseconds."
+    }),
+    providerOptions: zod.z.strictObject({
+      google: zod.z.strictObject({
+        cachedContent: zod.z.string().min(1).optional().meta({
+          title: "Cached Content",
+          description: "Google cached content resource name."
+        }),
+        safetySettings: zod.z.array(
+          zod.z.strictObject({
+            category: zod.z.string().min(1).meta({
+              title: "Safety Category",
+              description: "Google safety category identifier."
+            }),
+            threshold: zod.z.string().min(1).meta({
+              title: "Safety Threshold",
+              description: "Google safety threshold identifier."
+            })
+          })
+        ).optional().meta({
+          title: "Safety Settings",
+          description: "Allowlisted Google safety settings."
+        }),
+        tools: zod.z.array(
+          zod.z.strictObject({
+            googleSearch: zod.z.strictObject({}).meta({
+              title: "Google Search",
+              description: "Google Search grounding tool."
+            })
+          })
+        ).min(1).optional().meta({
+          title: "Tools",
+          description: "Allowlisted Google tools for gemini-3-flash-preview."
+        }),
+        httpOptions: zod.z.strictObject({
+          timeout: zod.z.number().int().positive().optional().meta({
+            title: "HTTP Timeout",
+            description: "Per-request Google transport timeout in milliseconds."
+          })
+        }).optional().meta({
+          title: "HTTP Options",
+          description: "Allowlisted Google transport options."
+        })
+      }).optional().meta({
+        title: "Google Provider Options",
+        description: "Allowlisted Google provider options for gemini-3-flash-preview."
+      })
+    }).optional().meta({
+      title: "Provider Options",
+      description: "Provider-specific options accepted for gemini-3-flash-preview."
+    })
+  })
+]).meta({
+  title: "Gemini3FlashPreviewConfig",
+  description: "Strict generateContent config for model gemini-3-flash-preview. Level reasoning, fixed sampling, flex/standard tiers, structured output, grounding, priced.",
+  examples: [{ serviceTier: "flex", reasoning: { effort: "medium" } }]
+});
+var Gemma431bItConfigSchema = zod.z.strictObject({
+  temperature: zod.z.number().min(0).max(2).optional().meta({
+    title: "Temperature",
+    description: "Sampling temperature for gemma-4-31b-it.",
+    examples: [0.7]
+  }),
+  topP: zod.z.number().min(0).max(1).optional().meta({
+    title: "Top P",
+    description: "Nucleus sampling probability for gemma-4-31b-it."
+  }),
+  topK: zod.z.number().int().positive().optional().meta({
+    title: "Top K",
+    description: "Top-k sampling limit for gemma-4-31b-it."
+  }),
+  maxOutputTokens: zod.z.number().int().positive().optional().meta({
+    title: "Max Output Tokens",
+    description: "Maximum output token cap for gemma-4-31b-it."
+  }),
+  stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+    title: "Stop Sequences",
+    description: "Up to five stop sequences for gemma-4-31b-it."
+  }),
+  reasoning: zod.z.union([
+    zod.z.strictObject({
+      effort: zod.z.enum(["none", "high"]).meta({
+        title: "Reasoning Effort",
+        description: "Reasoning effort for gemma-4-31b-it."
+      }),
+      includeThoughts: zod.z.boolean().optional().meta({
+        title: "Include Thoughts",
+        description: "Return provider thought summaries when supported."
+      })
+    }),
+    zod.z.strictObject({
+      includeThoughts: zod.z.boolean().meta({
+        title: "Include Thoughts",
+        description: "Return provider thought summaries when supported."
+      })
+    })
+  ]).optional().meta({
+    title: "Reasoning",
+    description: "Gemma 4 31B IT thinkingLevel configuration."
+  }),
+  timeoutMs: zod.z.number().int().positive().optional().meta({
+    title: "Timeout",
+    description: "Logical request timeout in milliseconds."
+  }),
+  providerOptions: zod.z.strictObject({
+    google: zod.z.strictObject({
+      cachedContent: zod.z.string().min(1).optional().meta({
+        title: "Cached Content",
+        description: "Google cached content resource name."
+      }),
+      safetySettings: zod.z.array(
+        zod.z.strictObject({
+          category: zod.z.string().min(1).meta({
+            title: "Safety Category",
+            description: "Google safety category identifier."
+          }),
+          threshold: zod.z.string().min(1).meta({
+            title: "Safety Threshold",
+            description: "Google safety threshold identifier."
+          })
+        })
+      ).optional().meta({
+        title: "Safety Settings",
+        description: "Allowlisted Google safety settings."
+      }),
+      tools: zod.z.array(
+        zod.z.strictObject({
+          googleSearch: zod.z.strictObject({}).meta({
+            title: "Google Search",
+            description: "Google Search grounding tool."
+          })
+        })
+      ).min(1).optional().meta({
+        title: "Tools",
+        description: "Allowlisted Google tools for gemma-4-31b-it."
+      }),
+      httpOptions: zod.z.strictObject({
+        timeout: zod.z.number().int().positive().optional().meta({
+          title: "HTTP Timeout",
+          description: "Per-request Google transport timeout in milliseconds."
+        })
+      }).optional().meta({
+        title: "HTTP Options",
+        description: "Allowlisted Google transport options."
+      })
+    }).optional().meta({
+      title: "Google Provider Options",
+      description: "Allowlisted Google provider options for gemma-4-31b-it."
+    })
+  }).optional().meta({
+    title: "Provider Options",
+    description: "Provider-specific options accepted for gemma-4-31b-it."
+  })
+}).meta({
+  title: "Gemma431bItConfig",
+  description: "Strict generateContent config for model gemma-4-31b-it. Level reasoning, tunable sampling, no service tier, structured output, grounding, intentionally unpriced.",
+  examples: [{ temperature: 0.7, reasoning: { effort: "high" } }]
+});
+var Gemma426bA4bItConfigSchema = zod.z.strictObject({
+  temperature: zod.z.number().min(0).max(2).optional().meta({
+    title: "Temperature",
+    description: "Sampling temperature for gemma-4-26b-a4b-it.",
+    examples: [0.7]
+  }),
+  topP: zod.z.number().min(0).max(1).optional().meta({
+    title: "Top P",
+    description: "Nucleus sampling probability for gemma-4-26b-a4b-it."
+  }),
+  topK: zod.z.number().int().positive().optional().meta({
+    title: "Top K",
+    description: "Top-k sampling limit for gemma-4-26b-a4b-it."
+  }),
+  maxOutputTokens: zod.z.number().int().positive().optional().meta({
+    title: "Max Output Tokens",
+    description: "Maximum output token cap for gemma-4-26b-a4b-it."
+  }),
+  stopSequences: zod.z.array(zod.z.string()).max(5).optional().meta({
+    title: "Stop Sequences",
+    description: "Up to five stop sequences for gemma-4-26b-a4b-it."
+  }),
+  reasoning: zod.z.union([
+    zod.z.strictObject({
+      effort: zod.z.enum(["none", "high"]).meta({
+        title: "Reasoning Effort",
+        description: "Reasoning effort for gemma-4-26b-a4b-it."
+      }),
+      includeThoughts: zod.z.boolean().optional().meta({
+        title: "Include Thoughts",
+        description: "Return provider thought summaries when supported."
+      })
+    }),
+    zod.z.strictObject({
+      includeThoughts: zod.z.boolean().meta({
+        title: "Include Thoughts",
+        description: "Return provider thought summaries when supported."
+      })
+    })
+  ]).optional().meta({
+    title: "Reasoning",
+    description: "Gemma 4 26B A4B IT thinkingLevel configuration."
+  }),
+  timeoutMs: zod.z.number().int().positive().optional().meta({
+    title: "Timeout",
+    description: "Logical request timeout in milliseconds."
+  }),
+  providerOptions: zod.z.strictObject({
+    google: zod.z.strictObject({
+      cachedContent: zod.z.string().min(1).optional().meta({
+        title: "Cached Content",
+        description: "Google cached content resource name."
+      }),
+      safetySettings: zod.z.array(
+        zod.z.strictObject({
+          category: zod.z.string().min(1).meta({
+            title: "Safety Category",
+            description: "Google safety category identifier."
+          }),
+          threshold: zod.z.string().min(1).meta({
+            title: "Safety Threshold",
+            description: "Google safety threshold identifier."
+          })
+        })
+      ).optional().meta({
+        title: "Safety Settings",
+        description: "Allowlisted Google safety settings."
+      }),
+      tools: zod.z.array(
+        zod.z.strictObject({
+          googleSearch: zod.z.strictObject({}).meta({
+            title: "Google Search",
+            description: "Google Search grounding tool."
+          })
+        })
+      ).min(1).optional().meta({
+        title: "Tools",
+        description: "Allowlisted Google tools for gemma-4-26b-a4b-it."
+      }),
+      httpOptions: zod.z.strictObject({
+        timeout: zod.z.number().int().positive().optional().meta({
+          title: "HTTP Timeout",
+          description: "Per-request Google transport timeout in milliseconds."
+        })
+      }).optional().meta({
+        title: "HTTP Options",
+        description: "Allowlisted Google transport options."
+      })
+    }).optional().meta({
+      title: "Google Provider Options",
+      description: "Allowlisted Google provider options for gemma-4-26b-a4b-it."
+    })
+  }).optional().meta({
+    title: "Provider Options",
+    description: "Provider-specific options accepted for gemma-4-26b-a4b-it."
+  })
+}).meta({
+  title: "Gemma426bA4bItConfig",
+  description: "Strict generateContent config for model gemma-4-26b-a4b-it. Level reasoning, tunable sampling, no service tier, structured output, grounding, intentionally unpriced.",
+  examples: [{ temperature: 0.7, reasoning: { effort: "none" } }]
+});
+var GEMINI_25_PRO_REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high"
+];
+var GEMINI_LEVEL_REASONING_EFFORTS = [
+  "none",
+  "low",
+  "medium",
+  "high"
+];
+var GEMINI_LEVEL_PRO_PREVIEW_REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high"
+];
+var GEMINI_25_FLASH_REASONING_EFFORTS = [
+  "none",
+  "low",
+  "medium",
+  "high"
+];
+var GEMMA_REASONING_EFFORTS = [
+  "none",
+  "high"
+];
+var geminiModelDescriptors = [
+  {
+    model: "gemini-2.5-pro",
+    provider: "google",
+    pricingFamily: "gemini-2.5-pro",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "budget",
+      admittedReasoningEfforts: GEMINI_25_PRO_REASONING_EFFORTS,
+      sampling: "tunable",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini25ProConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini25ProConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini25ProConfigSchema)
+  },
+  {
+    model: "gemini-2.5-flash",
+    provider: "google",
+    pricingFamily: "gemini-2.5-flash",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "budget",
+      admittedReasoningEfforts: GEMINI_25_FLASH_REASONING_EFFORTS,
+      sampling: "tunable",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini25FlashConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini25FlashConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini25FlashConfigSchema)
+  },
+  {
+    model: "gemini-2.5-flash-lite",
+    provider: "google",
+    pricingFamily: "gemini-2.5-flash-lite",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "budget",
+      admittedReasoningEfforts: GEMINI_25_FLASH_REASONING_EFFORTS,
+      sampling: "tunable",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini25FlashLiteConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini25FlashLiteConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini25FlashLiteConfigSchema)
+  },
+  {
+    model: "gemini-3.5-flash",
+    provider: "google",
+    pricingFamily: "gemini-3.5-flash",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMINI_LEVEL_REASONING_EFFORTS,
+      sampling: "fixed",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini35FlashConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini35FlashConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini35FlashConfigSchema)
+  },
+  {
+    model: "gemini-3.1-flash-lite",
+    provider: "google",
+    pricingFamily: "gemini-3.1-flash-lite",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMINI_LEVEL_REASONING_EFFORTS,
+      sampling: "fixed",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini31FlashLiteConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini31FlashLiteConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini31FlashLiteConfigSchema)
+  },
+  {
+    model: "gemini-3.1-pro-preview",
+    provider: "google",
+    pricingFamily: "gemini-3.1-pro-preview",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMINI_LEVEL_PRO_PREVIEW_REASONING_EFFORTS,
+      sampling: "fixed",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini31ProPreviewConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini31ProPreviewConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini31ProPreviewConfigSchema)
+  },
+  {
+    model: "gemini-3-flash-preview",
+    provider: "google",
+    pricingFamily: "gemini-3-flash-preview",
+    capabilities: {
+      reasoning: true,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      vision: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMINI_LEVEL_REASONING_EFFORTS,
+      sampling: "fixed",
+      caching: { explicit: true, minTokens: 2048 },
+      grounding: true,
+      serviceTiers: ["flex", "standard"]
+    },
+    configSchema: Gemini3FlashPreviewConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemini3FlashPreviewConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemini3FlashPreviewConfigSchema)
+  }
+];
+var gemmaModelDescriptors = [
+  {
+    model: "gemma-4-31b-it",
+    provider: "google",
+    capabilities: {
+      reasoning: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMMA_REASONING_EFFORTS,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      grounding: true,
+      vision: true,
+      sampling: "tunable"
+    },
+    configSchema: Gemma431bItConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemma431bItConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemma431bItConfigSchema)
+  },
+  {
+    model: "gemma-4-26b-a4b-it",
+    provider: "google",
+    capabilities: {
+      reasoning: true,
+      reasoningApi: "level",
+      admittedReasoningEfforts: GEMMA_REASONING_EFFORTS,
+      structuredOutput: true,
+      nativeStructuredOutput: true,
+      grounding: true,
+      vision: true,
+      sampling: "tunable"
+    },
+    configSchema: Gemma426bA4bItConfigSchema,
+    configJsonSchema: core.toConfigJsonSchema(Gemma426bA4bItConfigSchema),
+    validateConfig: core.zodToStandardSchema(Gemma426bA4bItConfigSchema)
+  }
+];
+var defaultGeminiRegistry = core.createModelRegistry([
+  ...geminiModelDescriptors,
+  ...gemmaModelDescriptors
+]);
+
+// src/provider.ts
+function googleProvider(opts) {
+  return {
+    adapter: geminiAdapter(opts),
+    modelDescriptors: [...geminiModelDescriptors, ...gemmaModelDescriptors],
+    pricingSource: geminiPricingSource()
+  };
+}
 var DEFAULT_INTERVAL_MS = 3e3;
 var DEFAULT_TIMEOUT_MS = 3e5;
 var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -775,8 +2795,9 @@ var GoogleFileStore = class {
     const { name, uri } = uploadResp;
     if (name === void 0 || name.length === 0 || uri === void 0 || uri.length === 0) {
       throw new core.LlmError("File upload response missing required fields (name or uri)", {
-        kind: "bad_request",
-        retryable: false
+        kind: "server",
+        retryable: false,
+        provider: "google"
       });
     }
     const fallback = { name, uri, mimeType };
@@ -889,6 +2910,7 @@ var GoogleCacheStore = class {
   onDeleteError;
   logger;
   now;
+  preflight;
   /** Memoised client promise — built at most once per store instance. */
   clientPromise;
   /** In-process cache of live handles, keyed by `${model}:${stableKey}`. */
@@ -915,6 +2937,7 @@ var GoogleCacheStore = class {
       }
     });
     this.now = opts.now ?? (() => Date.now());
+    this.preflight = opts.preflight;
   }
   getClient() {
     if (this.clientOverride !== void 0) return Promise.resolve(this.clientOverride);
@@ -934,6 +2957,19 @@ var GoogleCacheStore = class {
    * `now + ttlSeconds * 1000`.
    */
   async create(input) {
+    if (this.preflight !== void 0) {
+      const counted = await this.preflight.countTokens({
+        model: input.model,
+        ...input.contents !== void 0 ? { contents: input.contents } : {},
+        ...input.systemInstruction !== void 0 ? { systemInstruction: input.systemInstruction } : {}
+      });
+      if (counted < this.preflight.minTokens) {
+        throw new core.LlmError(
+          `GoogleCacheStore preflight: counted ${counted} token(s), below the configured minimum of ${this.preflight.minTokens} for model "${input.model}".`,
+          { kind: "bad_request", retryable: false }
+        );
+      }
+    }
     const client = await this.getClient();
     const config = { ttl: `${input.ttlSeconds}s` };
     if (input.contents !== void 0) config.contents = input.contents;
@@ -948,8 +2984,9 @@ var GoogleCacheStore = class {
     }
     if (resp.name === void 0 || resp.name.length === 0) {
       throw new core.LlmError("Cache create response missing required field: name", {
-        kind: "bad_request",
-        retryable: false
+        kind: "server",
+        retryable: false,
+        provider: "google"
       });
     }
     const fallbackExpiry = new Date(this.now() + input.ttlSeconds * 1e3);
@@ -1111,16 +3148,195 @@ function normalizeGroundingCitations(groundingMetadata) {
   }
   return citations;
 }
+function badRequest(message) {
+  return new core.LlmError(message, { kind: "bad_request", retryable: false });
+}
+function definedKeys(obj) {
+  return Object.keys(obj).filter(
+    (key) => obj[key] !== void 0
+  );
+}
+function mapMediaResolutionLevel(level, location) {
+  switch (level) {
+    case "MEDIA_RESOLUTION_LOW":
+      return "low";
+    case "MEDIA_RESOLUTION_MEDIUM":
+      return "medium";
+    case "MEDIA_RESOLUTION_HIGH":
+      return "high";
+    default:
+      throw badRequest(
+        `${location}: unsupported Part.mediaResolution.level "${level}" \u2014 any-llm only supports MEDIA_RESOLUTION_LOW, MEDIA_RESOLUTION_MEDIUM, MEDIA_RESOLUTION_HIGH.`
+      );
+  }
+}
+function convertMediaResolution(mediaResolution, location) {
+  const extraKeys = definedKeys(mediaResolution).filter((key) => key !== "level");
+  if (extraKeys.length > 0) {
+    throw badRequest(
+      `${location}: Part.mediaResolution keys [${extraKeys.join(", ")}] are not representable in any-llm \u2014 only mediaResolution.level is supported.`
+    );
+  }
+  if (mediaResolution.level === void 0) {
+    throw badRequest(
+      `${location}: Part.mediaResolution is present but carries no level \u2014 an explicit-but-empty mediaResolution is ambiguous; set level or omit the field.`
+    );
+  }
+  return mapMediaResolutionLevel(mediaResolution.level, location);
+}
+function convertPart(part, location) {
+  const keys = definedKeys(part);
+  const baseKeys = keys.filter(
+    (key) => key === "text" || key === "inlineData" || key === "fileData"
+  );
+  if (baseKeys.length === 0) {
+    if (keys.length === 0) {
+      throw badRequest(
+        `${location}: Part has no recognized fields set (expected exactly one of text, inlineData, fileData).`
+      );
+    }
+    throw badRequest(
+      `${location}: Part keys [${keys.join(", ")}] are not supported by geminiContentToMessages \u2014 only text, inlineData, and fileData parts can be represented in any-llm.`
+    );
+  }
+  if (baseKeys.length > 1) {
+    throw badRequest(
+      `${location}: Part has more than one of text/inlineData/fileData set ([${baseKeys.join(", ")}]) \u2014 geminiContentToMessages requires exactly one.`
+    );
+  }
+  const base = baseKeys[0];
+  const extraKeys = keys.filter(
+    (key) => key !== base && !(base !== "text" && key === "mediaResolution")
+  );
+  if (extraKeys.length > 0) {
+    throw badRequest(
+      `${location}: Part keys [${extraKeys.join(", ")}] cannot be represented in any-llm alongside ${base} \u2014 nothing is silently dropped.`
+    );
+  }
+  if (part.text !== void 0) {
+    return { kind: "text", text: part.text };
+  }
+  if (part.inlineData !== void 0) {
+    const inlineData = part.inlineData;
+    const inlineExtraKeys = definedKeys(inlineData).filter(
+      (key) => key !== "mimeType" && key !== "data"
+    );
+    if (inlineExtraKeys.length > 0) {
+      throw badRequest(
+        `${location}: Part.inlineData keys [${inlineExtraKeys.join(", ")}] are not representable in any-llm.`
+      );
+    }
+    if (inlineData.mimeType === void 0) {
+      throw badRequest(`${location}: Part.inlineData.mimeType is required.`);
+    }
+    if (inlineData.data === void 0) {
+      throw badRequest(`${location}: Part.inlineData.data is required.`);
+    }
+    return {
+      kind: "inline-media",
+      mimeType: inlineData.mimeType,
+      data: inlineData.data,
+      ...part.mediaResolution !== void 0 ? { mediaResolution: convertMediaResolution(part.mediaResolution, location) } : {}
+    };
+  }
+  if (part.fileData !== void 0) {
+    const fileData = part.fileData;
+    const fileExtraKeys = definedKeys(fileData).filter(
+      (key) => key !== "fileUri" && key !== "mimeType"
+    );
+    if (fileExtraKeys.length > 0) {
+      throw badRequest(
+        `${location}: Part.fileData keys [${fileExtraKeys.join(", ")}] are not representable in any-llm.`
+      );
+    }
+    if (fileData.fileUri === void 0) {
+      throw badRequest(`${location}: Part.fileData.fileUri is required.`);
+    }
+    if (fileData.mimeType === void 0) {
+      throw badRequest(`${location}: Part.fileData.mimeType is required.`);
+    }
+    return {
+      kind: "file-uri",
+      uri: fileData.fileUri,
+      mimeType: fileData.mimeType,
+      ...part.mediaResolution !== void 0 ? { mediaResolution: convertMediaResolution(part.mediaResolution, location) } : {}
+    };
+  }
+  throw badRequest(`${location}: Part has no recognized fields set.`);
+}
+function convertRole(role, location) {
+  if (role === "user") return "user";
+  if (role === "model") return "assistant";
+  throw badRequest(
+    `${location}: Content.role "${String(role)}" is not supported \u2014 only "user" and "model" are recognized. any-llm never infers a missing role.`
+  );
+}
+function convertSystemInstruction(systemInstruction) {
+  if (typeof systemInstruction === "string") {
+    return systemInstruction;
+  }
+  const envelopeExtraKeys = definedKeys(systemInstruction).filter(
+    (key) => key !== "parts"
+  );
+  if (envelopeExtraKeys.length > 0) {
+    throw badRequest(
+      `systemInstruction: Content keys [${envelopeExtraKeys.join(", ")}] are not supported on a system instruction \u2014 only parts is allowed.`
+    );
+  }
+  const parts = systemInstruction.parts ?? [];
+  const textFragments = [];
+  parts.forEach((part, index) => {
+    const keys = definedKeys(part);
+    if (keys.length !== 1 || keys[0] !== "text" || part.text === void 0) {
+      const offending = keys.filter((key) => key !== "text");
+      const named = offending.length > 0 ? offending : keys;
+      throw badRequest(
+        `systemInstruction.parts[${index}]: only text parts are allowed in a system instruction \u2014 part keys [${named.length > 0 ? named.join(", ") : "none"}] are not supported.`
+      );
+    }
+    textFragments.push(part.text);
+  });
+  return textFragments.join("");
+}
+function geminiContentToMessages(input) {
+  const system = input.systemInstruction !== void 0 ? convertSystemInstruction(input.systemInstruction) : void 0;
+  const messages = input.contents.map((content, contentIndex) => {
+    const location = `contents[${contentIndex}]`;
+    const envelopeExtraKeys = definedKeys(content).filter(
+      (key) => key !== "role" && key !== "parts"
+    );
+    if (envelopeExtraKeys.length > 0) {
+      throw badRequest(
+        `${location}: Content keys [${envelopeExtraKeys.join(", ")}] are not supported \u2014 only role and parts are allowed.`
+      );
+    }
+    const role = convertRole(content.role, location);
+    const parts = (content.parts ?? []).map(
+      (part, partIndex) => convertPart(part, `${location}.parts[${partIndex}]`)
+    );
+    return { role, parts };
+  });
+  return { ...system !== void 0 ? { system } : {}, messages };
+}
 
 exports.FLEX_DEFAULT_TIMEOUT_MS = FLEX_DEFAULT_TIMEOUT_MS;
+exports.GEMINI_PRICING = GEMINI_PRICING;
 exports.GoogleCacheStore = GoogleCacheStore;
 exports.GoogleFileStore = GoogleFileStore;
 exports.STANDARD_DEFAULT_TIMEOUT_MS = STANDARD_DEFAULT_TIMEOUT_MS;
+exports.TIER_FACTOR = TIER_FACTOR;
 exports.TRANSPORT_TIMEOUT_BUFFER_MS = TRANSPORT_TIMEOUT_BUFFER_MS;
 exports.buildGoogleClient = buildGoogleClient;
+exports.defaultGeminiRegistry = defaultGeminiRegistry;
 exports.geminiAdapter = geminiAdapter;
+exports.geminiContentToMessages = geminiContentToMessages;
+exports.geminiModelDescriptors = geminiModelDescriptors;
+exports.geminiPricingSource = geminiPricingSource;
+exports.gemmaModelDescriptors = gemmaModelDescriptors;
+exports.googleProvider = googleProvider;
 exports.isGeminiCapacityError = isGeminiCapacityError;
 exports.normalizeGroundingCitations = normalizeGroundingCitations;
+exports.pricingVersion = pricingVersion;
 exports.requireApiKey = requireApiKey;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map