@veryfront/ext-llm-google 0.1.985

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+Veryfront Code
+Copyright 2026 Veryfront GmbH

package/README.md

@@ -0,0 +1,247 @@
+# @veryfront/ext-llm-google
+
+> **Category:** LLM | **Contract:** `LLMProvider` | **Built-in**
+
+Provides Google Gemini models for Veryfront agents and chat, enabling `google/*` models for chat and embeddings via the `LLMProviderRegistry`.
+
+## Registration
+
+This extension is auto-enabled by core bootstrap. Add it to `veryfront.config.ts` only when you need to override the built-in registration:
+
+```ts
+import extGoogle from "@veryfront/ext-llm-google";
+
+export default defineConfig({
+  extensions: [extGoogle()],
+});
+```
+
+## Environment Variables
+
+| Variable                       | Required | Description                                                                    |
+| ------------------------------ | -------- | ------------------------------------------------------------------------------ |
+| `GOOGLE_API_KEY`               | Yes      | Your Google AI API key (from [AI Studio](https://aistudio.google.com/apikey)). |
+| `GOOGLE_GENERATIVE_AI_API_KEY` | No       | Alternative name for the API key (checked as fallback).                        |
+
+## Usage
+
+Once credentials are configured, use `google/*` model strings anywhere Veryfront expects a model identifier:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: [{ role: "user", content: "Hello" }],
+});
+```
+
+### Embeddings
+
+```ts
+const result = await ai.embed("google/text-embedding-005", {
+  values: ["search query"],
+});
+```
+
+## Supported Models
+
+Any model accessible through the Google Generative Language API:
+
+- **Flagship:** `gemini-2.5-pro`, `gemini-2.5-flash`
+- **Stable:** `gemini-2.0-flash`, `gemini-1.5-pro`, `gemini-1.5-flash`
+- **Embeddings:** `text-embedding-005`, `text-embedding-004`
+
+## Configuration
+
+The extension accepts configuration through `LLMProviderConfig` when creating runtimes:
+
+| Option       | Type           | Default                                            | Description                            |
+| ------------ | -------------- | -------------------------------------------------- | -------------------------------------- |
+| `credential` | `string`       | —                                                  | API key (typically from env var).      |
+| `baseURL`    | `string`       | `https://generativelanguage.googleapis.com/v1beta` | API base URL override.                 |
+| `name`       | `string`       | `"google"`                                         | Display name for errors and telemetry. |
+| `fetch`      | `typeof fetch` | `globalThis.fetch`                                 | Custom fetch implementation.           |
+
+## Model Defaults
+
+Gemini models use the Google `generateContent` / `streamGenerateContent` endpoints. Request mapping:
+
+- `maxOutputTokens` → `generationConfig.maxOutputTokens`
+- `temperature` → `generationConfig.temperature`
+- `topP` → `generationConfig.topP`
+- `topK` → `generationConfig.topK`
+- `stopSequences` → `generationConfig.stopSequences`
+- `seed` → `generationConfig.seed`
+- System messages → `systemInstruction.parts`
+
+## Extended Thinking
+
+Gemini 2.5+ models support extended thinking via the unified `reasoning` option:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: messages,
+  reasoning: { enabled: true, effort: "high" },
+});
+```
+
+Effort levels map to Gemini `thinkingConfig.thinkingBudget`:
+
+| Effort   | Budget Tokens |
+| -------- | ------------- |
+| `low`    | 512           |
+| `medium` | 2048          |
+| `high`   | 8192          |
+| `max`    | -1 (dynamic)  |
+
+Set `budgetTokens` directly to override the effort mapping:
+
+```ts
+reasoning: { enabled: true, budgetTokens: 4096 }
+```
+
+When thinking is enabled, Gemini returns `thought` parts that the runtime emits as `reasoning-start` / `reasoning-delta` / `reasoning-end` stream events.
+
+## Prompt Caching
+
+Gemini uses a separate cached-content resource model. Create a cache via the Gemini REST API or SDK, then pass the resource name on each request:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: messages,
+  googleCachedContent: "cachedContents/abc123",
+});
+```
+
+When a cached content resource is attached, the response `usageMetadata.cachedContentTokenCount` is surfaced as `cacheReadInputTokens` on the result.
+
+## Provider Tools
+
+Gemini supports provider-native tools alongside function declarations. Use the `provider` tool type with a `google.*` id:
+
+### Code Execution
+
+```ts
+tools: [
+  { type: "provider", name: "code_execution", id: "google.code_execution", args: {} },
+];
+```
+
+### Google Search
+
+```ts
+tools: [
+  { type: "provider", name: "google_search", id: "google.google_search", args: {} },
+];
+```
+
+Provider tools can be combined with regular function tools in the same request. When Google Search is used, the response includes `groundingMetadata` with web search queries, grounding chunks, and citation indices.
+
+## Safety Settings
+
+Configure per-request safety filters via `googleSafetySettings`:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: messages,
+  googleSafetySettings: [
+    { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_ONLY_HIGH" },
+    { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
+  ],
+});
+```
+
+See [Gemini safety settings](https://ai.google.dev/gemini-api/docs/safety-settings) for available categories and thresholds.
+
+## Provider Options
+
+Pass Gemini-specific options through `providerOptions`:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: messages,
+  providerOptions: {
+    google: {
+      generationConfig: { responseMimeType: "application/json" },
+    },
+  },
+});
+```
+
+Provider options are merged into the request body after the standard fields, allowing access to any Gemini API feature not covered by the unified interface.
+
+## User Identification and Labels
+
+Gemini supports per-request `labels` for tracking and attribution:
+
+```ts
+const response = await ai.chat("google/gemini-2.5-pro", {
+  prompt: messages,
+  userId: "user_42", // maps to labels.user_id
+  requestLabels: { // explicit labels (wins over userId)
+    team: "search",
+    experiment: "v2",
+  },
+});
+```
+
+When `requestLabels` is set, it takes precedence. Otherwise, `userId` is sent as `labels.user_id`.
+
+## Unsupported Settings
+
+The following settings emit `unsupported-setting` warnings and are silently dropped:
+
+| Setting            | Reason                                                                                              |
+| ------------------ | --------------------------------------------------------------------------------------------------- |
+| `presencePenalty`  | Gemini `generateContent` does not accept presence penalty.                                          |
+| `frequencyPenalty` | Gemini `generateContent` does not accept frequency penalty.                                         |
+| `responseFormat`   | Gemini uses `generationConfig.responseMimeType` + `responseSchema` instead (use `providerOptions`). |
+
+## Error Handling
+
+The extension surfaces typed provider errors:
+
+| Error Class               | Trigger                       | Retryable |
+| ------------------------- | ----------------------------- | --------- |
+| `ProviderOverloadedError` | HTTP 503                      | Yes       |
+| `ProviderQuotaError`      | HTTP 429 `RESOURCE_EXHAUSTED` | No        |
+| `ProviderRateLimitError`  | HTTP 429 with `Retry-After`   | Yes       |
+| `ProviderRequestError`    | Other HTTP errors             | No        |
+
+If the extension is not installed and a `google/*` model is requested:
+
+> Google provider not installed. Add @veryfront/ext-llm-google to use google/* models.
+
+## Tool Choice
+
+The unified `toolChoice` option maps to Gemini's `functionCallingConfig`:
+
+| Input                                  | Gemini Mode | Effect                               |
+| -------------------------------------- | ----------- | ------------------------------------ |
+| `"auto"`                               | `AUTO`      | Model decides whether to call tools. |
+| `"any"` / `"required"`                 | `ANY`       | Model must call at least one tool.   |
+| `"none"`                               | `NONE`      | Model must not call tools.           |
+| `{ type: "tool", name: "fn" }`         | `ANY`       | Pinned to one function.              |
+| `{ type: "tools", names: ["a", "b"] }` | `ANY`       | Restricted to named subset.          |
+
+## Running Tests
+
+```bash
+# From the repository root
+deno test --no-check --allow-all extensions/ext-google/
+
+# Or from the extension directory
+cd extensions/ext-google
+deno task test
+```
+
+The test suite covers:
+
+- Generate and stream request/response mapping
+- Extended thinking (thinkingConfig budget mapping, thought-part streaming)
+- Embedding runtime (single and batch)
+- Error classification (503, 429 RESOURCE_EXHAUSTED)
+- Unsupported-setting warnings (presencePenalty, frequencyPenalty)
+- User ID and request label forwarding
+- Tool choice normalization (auto, any, none, single-tool, multi-tool)
+- Grounding metadata pass-through (google_search)
+- Provider tools (code_execution, google_search)
+- Safety settings and cached content

package/esm/google-provider.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Google provider - implements the {@link LLMProvider} contract for Google's
+ * Generative Language API (direct + via Veryfront Cloud).
+ *
+ * Ported from `src/provider/runtime-loader.ts` as part of PR 13.
+ *
+ * @module extensions/ext-llm-google/google-provider
+ */
+import type { LLMProvider, LLMProviderConfig } from "veryfront/extensions/llm";
+import type { EmbeddingRuntime, ModelRuntime } from "veryfront/provider/types";
+import { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema, withToolInputStatusTransitions } from "veryfront/provider/shared";
+export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema, withToolInputStatusTransitions, };
+export interface GoogleRuntimeConfig {
+    apiKey: string;
+    baseURL?: string;
+    name?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare function createGoogleModelRuntime(config: GoogleRuntimeConfig, modelId: string): ModelRuntime;
+export declare function createGoogleEmbeddingRuntime(config: GoogleRuntimeConfig, modelId: string): EmbeddingRuntime;
+export declare class GoogleProvider implements LLMProvider {
+    readonly id = "google";
+    createModel(modelId: string, config: LLMProviderConfig): ModelRuntime;
+    createEmbedding(modelId: string, config: LLMProviderConfig): EmbeddingRuntime;
+}
+//# sourceMappingURL=google-provider.d.ts.map

package/esm/google-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-provider.d.ts","sourceRoot":"","sources":["../src/google-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC/E,OAAO,EACL,kBAAkB,EAMlB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EAKpB,+BAA+B,EAC/B,qBAAqB,EACrB,8BAA8B,EAC/B,MAAM,2BAA2B,CAAC;AAgBnC,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,+BAA+B,EAC/B,qBAAqB,EACrB,8BAA8B,GAC/B,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAsFD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAkEd;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CA6ClB;AAED,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,EAAE,YAAY;IAEvB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,YAAY;IAYrE,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,gBAAgB;CAW9E"}

package/esm/google-provider.js

@@ -0,0 +1,191 @@
+/**
+ * Google provider - implements the {@link LLMProvider} contract for Google's
+ * Generative Language API (direct + via Veryfront Cloud).
+ *
+ * Ported from `src/provider/runtime-loader.ts` as part of PR 13.
+ *
+ * @module extensions/ext-llm-google/google-provider
+ */
+import { buildProviderError, createGoogleRequestInit, createWarningCollector, getGoogleEmbeddingUrl, getGoogleGenerateContentUrl, getGoogleStreamGenerateContentUrl, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, readRecord, requestJson, requestStream, stringifyJsonValue, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema, withToolInputStatusTransitions, } from "veryfront/provider/shared";
+import { buildGoogleGenerateContentRequest, } from "./google-request-builder.js";
+import { extractFirstGoogleCandidate, extractGoogleCandidateParts, extractGoogleUsage, normalizeGoogleFinishReason, streamGoogleCompatibleParts, } from "./google-stream.js";
+// Re-export error classes so extension tests can import them from this module
+// and from `veryfront/provider/shared` interchangeably.
+export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema, withToolInputStatusTransitions, };
+// ---------------------------------------------------------------------------
+// Google-specific types
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Google helper functions
+// ---------------------------------------------------------------------------
+function extractGoogleEmbedding(payload) {
+    const record = readRecord(payload);
+    const embeddings = record?.embeddings;
+    if (Array.isArray(embeddings) && embeddings.length > 0) {
+        const firstEmbedding = readRecord(embeddings[0]);
+        const values = firstEmbedding?.values;
+        if (isNumberArray(values)) {
+            return values;
+        }
+    }
+    const embedding = readRecord(record?.embedding);
+    const values = embedding?.values;
+    if (isNumberArray(values)) {
+        return values;
+    }
+    throw new Error("Invalid Google embedding response: embedding vector missing");
+}
+function extractGoogleUsageTokens(payload) {
+    const record = readRecord(payload);
+    const usageMetadata = readRecord(record?.usageMetadata);
+    const promptTokenCount = usageMetadata?.promptTokenCount;
+    return typeof promptTokenCount === "number" ? promptTokenCount : undefined;
+}
+function buildGoogleGenerateResult(payload) {
+    const parts = extractGoogleCandidateParts(payload);
+    const content = [];
+    for (const [index, part] of parts.entries()) {
+        if (typeof part.text === "string" && part.text.length > 0) {
+            content.push({ type: "text", text: part.text });
+            continue;
+        }
+        const functionCall = readRecord(part.functionCall);
+        if (typeof functionCall?.name === "string") {
+            content.push({
+                type: "tool-call",
+                toolCallId: typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`,
+                toolName: functionCall.name,
+                input: stringifyJsonValue(functionCall.args ?? {}),
+            });
+        }
+    }
+    // Gemini grounding (google_search / google_search_retrieval) returns
+    // a per-candidate groundingMetadata object with web search queries,
+    // grounding chunks, and citation indices into the response text.
+    // Pass it through opaquely so callers can render footnotes / source
+    // chips / "Search results" UI without parsing the wire shape.
+    const candidate = extractFirstGoogleCandidate(payload);
+    const groundingMetadata = readRecord(candidate?.groundingMetadata);
+    return {
+        content,
+        finishReason: normalizeGoogleFinishReason(candidate?.finishReason),
+        usage: extractGoogleUsage(payload),
+        ...(groundingMetadata ? { groundingMetadata } : {}),
+    };
+}
+export function createGoogleModelRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    return {
+        provider: config.name ?? "google",
+        modelId,
+        specificationVersion: "v3",
+        supportedUrls: {},
+        doGenerate(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getGoogleGenerateContentUrl(config.baseURL, modelId);
+            const warnings = createWarningCollector();
+            const body = buildGoogleGenerateContentRequest(config.name ?? "google", options, warnings);
+            return requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                providerKind: "google",
+                init: createGoogleRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((payload) => {
+                const drained = warnings.drain();
+                return {
+                    ...buildGoogleGenerateResult(payload),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+        doStream(optionsForRuntime) {
+            const options = optionsForRuntime;
+            const url = getGoogleStreamGenerateContentUrl(config.baseURL, modelId);
+            const warnings = createWarningCollector();
+            const body = buildGoogleGenerateContentRequest(config.name ?? "google", options, warnings);
+            return requestStream({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                providerKind: "google",
+                init: createGoogleRequestInit({
+                    apiKey: config.apiKey,
+                    extraHeaders: options.headers,
+                    body: JSON.stringify(body),
+                    signal: options.abortSignal,
+                }),
+            }).then((responseStream) => {
+                const drained = warnings.drain();
+                return {
+                    stream: ReadableStream.from(withToolInputStatusTransitions(streamGoogleCompatibleParts(responseStream))),
+                    ...(drained.length > 0 ? { warnings: drained } : {}),
+                };
+            });
+        },
+    };
+}
+export function createGoogleEmbeddingRuntime(config, modelId) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    return {
+        provider: config.name ?? "google",
+        modelId,
+        supportsParallelCalls: true,
+        doEmbed({ values, abortSignal }) {
+            if (values.length === 0) {
+                return Promise.resolve({
+                    embeddings: [],
+                    warnings: [],
+                    rawResponse: { embeddings: [] },
+                });
+            }
+            const url = getGoogleEmbeddingUrl(config.baseURL, modelId);
+            return Promise.all(values.map((value) => requestJson({
+                url,
+                fetchImpl,
+                providerLabel: config.name ?? "google",
+                providerKind: "google",
+                init: createGoogleRequestInit({
+                    apiKey: config.apiKey,
+                    body: JSON.stringify({
+                        content: {
+                            parts: [{ text: value }],
+                        },
+                    }),
+                    signal: abortSignal,
+                }),
+            }))).then((payloads) => ({
+                embeddings: payloads.map(extractGoogleEmbedding),
+                usage: {
+                    tokens: payloads.reduce((total, payload) => total + (extractGoogleUsageTokens(payload) ?? 0), 0),
+                },
+                rawResponse: payloads,
+                warnings: [],
+            }));
+        },
+    };
+}
+export class GoogleProvider {
+    id = "google";
+    createModel(modelId, config) {
+        return createGoogleModelRuntime({
+            apiKey: config.credential,
+            baseURL: config.baseURL,
+            name: config.name ?? "google",
+            fetch: config.fetch,
+        }, modelId);
+    }
+    createEmbedding(modelId, config) {
+        return createGoogleEmbeddingRuntime({
+            apiKey: config.credential,
+            baseURL: config.baseURL,
+            name: config.name ?? "google",
+            fetch: config.fetch,
+        }, modelId);
+    }
+}

package/esm/google-request-builder.d.ts

@@ -0,0 +1,94 @@
+import type { RuntimePromptMessage } from "veryfront/provider/shared";
+export type RuntimeToolDefinition = {
+    type: "function";
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+} | {
+    type: "provider";
+    name: string;
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+};
+type ProviderReasoningEffort = "low" | "medium" | "high" | "max";
+type ProviderReasoningOption = {
+    enabled?: boolean;
+    effort?: ProviderReasoningEffort;
+    budgetTokens?: number;
+};
+export type OpenAICompatibleLanguageOptions = {
+    prompt: RuntimePromptMessage[];
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    stopSequences?: string[];
+    tools?: RuntimeToolDefinition[];
+    toolChoice?: unknown;
+    seed?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    headers?: HeadersInit;
+    providerOptions?: Record<string, unknown>;
+    includeRawChunks?: boolean;
+    abortSignal?: AbortSignal;
+    cacheControl?: unknown;
+    reasoning?: ProviderReasoningOption;
+    userId?: string;
+    requestLabels?: Record<string, string>;
+    serviceTier?: "auto" | "default" | "flex" | "scale";
+    parallelToolCalls?: boolean;
+    responseFormat?: {
+        type: "text";
+    } | {
+        type: "json";
+    } | {
+        type: "json_schema";
+        name: string;
+        schema: unknown;
+        description?: string;
+        strict?: boolean;
+    };
+    anthropicContainer?: unknown;
+    googleCachedContent?: string;
+    googleSafetySettings?: Array<{
+        category: string;
+        threshold: string;
+    }>;
+    mcpServers?: Array<Record<string, unknown>>;
+};
+type WarningCollector = {
+    push(warning: {
+        type: "unsupported-setting" | "other";
+        setting?: string;
+        details?: string;
+        provider: string;
+    }): void;
+    drain(): Array<{
+        type: "unsupported-setting" | "other";
+        setting?: string;
+        details?: string;
+        provider: string;
+    }>;
+};
+type GoogleCompatibleContent = {
+    role: "user" | "model";
+    parts: Array<Record<string, unknown>>;
+};
+type GoogleCompatibleRequest = {
+    contents: GoogleCompatibleContent[];
+    systemInstruction?: {
+        parts: Array<{
+            text: string;
+        }>;
+    };
+    tools?: Array<Record<string, unknown>>;
+    toolConfig?: {
+        functionCallingConfig: Record<string, unknown>;
+    };
+    generationConfig?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+export declare function buildGoogleGenerateContentRequest(providerName: string, options: OpenAICompatibleLanguageOptions, warnings: WarningCollector): GoogleCompatibleRequest;
+export {};
+//# sourceMappingURL=google-request-builder.d.ts.map

package/esm/google-request-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-request-builder.d.ts","sourceRoot":"","sources":["../src/google-request-builder.ts"],"names":[],"mappings":"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"}

package/esm/google-request-builder.js

@@ -0,0 +1,253 @@
+import { readProviderOptions, readRecord, unwrapToolInputSchema } from "veryfront/provider/shared";
+function toGoogleContents(prompt) {
+    const systemParts = [];
+    const contents = [];
+    for (const message of prompt) {
+        switch (message.role) {
+            case "system":
+                if (message.content.length > 0) {
+                    systemParts.push(message.content);
+                }
+                break;
+            case "user":
+                contents.push({
+                    role: "user",
+                    parts: toGoogleUserParts(message.content),
+                });
+                break;
+            case "assistant": {
+                const parts = [];
+                for (const part of message.content) {
+                    if (part.type === "text") {
+                        parts.push({ text: part.text });
+                        continue;
+                    }
+                    if (part.type === "reasoning") {
+                        continue;
+                    }
+                    parts.push({
+                        functionCall: {
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            args: part.input,
+                        },
+                    });
+                }
+                contents.push({ role: "model", parts });
+                break;
+            }
+            case "tool":
+                contents.push({
+                    role: "user",
+                    parts: message.content.map((part) => ({
+                        functionResponse: {
+                            id: part.toolCallId,
+                            name: part.toolName,
+                            response: {
+                                result: part.output.value,
+                            },
+                        },
+                    })),
+                });
+                break;
+        }
+    }
+    return {
+        ...(systemParts.length > 0
+            ? { systemInstruction: { parts: systemParts.map((text) => ({ text })) } }
+            : {}),
+        contents,
+    };
+}
+function toGoogleUserParts(parts) {
+    const content = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            if (part.text.length > 0) {
+                content.push({ text: part.text });
+            }
+            continue;
+        }
+        if (part.type === "image" || part.mediaType.startsWith("image/")) {
+            content.push({
+                fileData: {
+                    mimeType: part.mediaType,
+                    fileUri: part.url,
+                },
+            });
+        }
+    }
+    return content;
+}
+function toGoogleTools(tools) {
+    if (!tools) {
+        return undefined;
+    }
+    const functionDeclarations = [];
+    const providerEntries = [];
+    for (const tool of tools) {
+        if (tool.type === "function") {
+            functionDeclarations.push({
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                parameters: unwrapToolInputSchema(tool.inputSchema),
+            });
+            continue;
+        }
+        if (!tool.id.startsWith("google.")) {
+            continue;
+        }
+        const providerType = tool.id.slice("google.".length);
+        if (providerType.length === 0) {
+            continue;
+        }
+        const camelKey = providerType.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
+        providerEntries.push({ [camelKey]: tool.args ?? {} });
+    }
+    const result = [];
+    if (functionDeclarations.length > 0) {
+        result.push({ functionDeclarations });
+    }
+    result.push(...providerEntries);
+    return result.length > 0 ? result : undefined;
+}
+function normalizeGoogleToolChoice(toolChoice) {
+    if (toolChoice === undefined) {
+        return undefined;
+    }
+    if (typeof toolChoice === "string") {
+        switch (toolChoice) {
+            case "none":
+                return { functionCallingConfig: { mode: "NONE" } };
+            case "any":
+            case "required":
+                return { functionCallingConfig: { mode: "ANY" } };
+            default:
+                return { functionCallingConfig: { mode: "AUTO" } };
+        }
+    }
+    const record = readRecord(toolChoice);
+    if (!record)
+        return undefined;
+    if (record.type === "tool" && typeof record.name === "string") {
+        return {
+            functionCallingConfig: {
+                mode: "ANY",
+                allowedFunctionNames: [record.name],
+            },
+        };
+    }
+    if (record.type === "tools" && Array.isArray(record.names)) {
+        const names = record.names.filter((n) => typeof n === "string");
+        if (names.length > 0) {
+            return {
+                functionCallingConfig: {
+                    mode: "ANY",
+                    allowedFunctionNames: names,
+                },
+            };
+        }
+    }
+    if (record.type === "auto") {
+        return { functionCallingConfig: { mode: "AUTO" } };
+    }
+    if (record.type === "none") {
+        return { functionCallingConfig: { mode: "NONE" } };
+    }
+    if (record.type === "any" || record.type === "required") {
+        return { functionCallingConfig: { mode: "ANY" } };
+    }
+    return undefined;
+}
+function resolveGoogleThinkingConfig(option) {
+    if (!option || option.enabled !== true) {
+        return undefined;
+    }
+    const config = { includeThoughts: true };
+    if (typeof option.budgetTokens === "number") {
+        config.thinkingBudget = option.budgetTokens;
+        return config;
+    }
+    switch (option.effort) {
+        case "low":
+            config.thinkingBudget = 512;
+            break;
+        case "high":
+            config.thinkingBudget = 8192;
+            break;
+        case "max":
+            config.thinkingBudget = -1;
+            break;
+        case "medium":
+        default:
+            config.thinkingBudget = 2048;
+            break;
+    }
+    return config;
+}
+function buildGoogleGenerationConfig(options) {
+    const thinkingConfig = resolveGoogleThinkingConfig(options.reasoning);
+    const config = {
+        ...(options.maxOutputTokens !== undefined ? { maxOutputTokens: options.maxOutputTokens } : {}),
+        ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options.topP !== undefined ? { topP: options.topP } : {}),
+        ...(options.topK !== undefined ? { topK: options.topK } : {}),
+        ...(options.stopSequences && options.stopSequences.length > 0
+            ? { stopSequences: options.stopSequences }
+            : {}),
+        ...(options.seed !== undefined ? { seed: options.seed } : {}),
+        ...(thinkingConfig ? { thinkingConfig } : {}),
+    };
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+export function buildGoogleGenerateContentRequest(providerName, options, warnings) {
+    if (options.presencePenalty !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "google",
+            setting: "presencePenalty",
+            details: "Gemini generateContent does not accept presencePenalty; the value was dropped.",
+        });
+    }
+    if (options.frequencyPenalty !== undefined) {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "google",
+            setting: "frequencyPenalty",
+            details: "Gemini generateContent does not accept frequencyPenalty; the value was dropped.",
+        });
+    }
+    if (options.responseFormat && options.responseFormat.type !== "text") {
+        warnings.push({
+            type: "unsupported-setting",
+            provider: "google",
+            setting: "responseFormat",
+            details: "Gemini uses generationConfig.responseMimeType + responseSchema for structured outputs, which is a separate surface and not yet wired through this option.",
+        });
+    }
+    const { systemInstruction, contents } = toGoogleContents(options.prompt);
+    const generationConfig = buildGoogleGenerationConfig(options);
+    const labels = options.requestLabels && Object.keys(options.requestLabels).length > 0
+        ? options.requestLabels
+        : typeof options.userId === "string" && options.userId.length > 0
+            ? { user_id: options.userId }
+            : undefined;
+    const body = {
+        contents,
+        ...(systemInstruction ? { systemInstruction } : {}),
+        ...(toGoogleTools(options.tools) ? { tools: toGoogleTools(options.tools) } : {}),
+        ...(normalizeGoogleToolChoice(options.toolChoice)
+            ? { toolConfig: normalizeGoogleToolChoice(options.toolChoice) }
+            : {}),
+        ...(generationConfig ? { generationConfig } : {}),
+        ...(labels ? { labels } : {}),
+        ...(typeof options.googleCachedContent === "string" && options.googleCachedContent.length > 0
+            ? { cachedContent: options.googleCachedContent }
+            : {}),
+        ...(options.googleSafetySettings && options.googleSafetySettings.length > 0
+            ? { safetySettings: options.googleSafetySettings }
+            : {}),
+    };
+    Object.assign(body, readProviderOptions(options.providerOptions, "google", providerName));
+    return body;
+}

package/esm/google-stream.d.ts

@@ -0,0 +1,10 @@
+import { type RuntimeUsage } from "veryfront/provider/shared";
+export declare function normalizeGoogleFinishReason(raw: unknown): string | {
+    unified: string;
+    raw: string;
+} | null;
+export declare function extractGoogleUsage(payload: unknown): RuntimeUsage | undefined;
+export declare function extractFirstGoogleCandidate(payload: unknown): Record<string, unknown> | undefined;
+export declare function extractGoogleCandidateParts(payload: unknown): Array<Record<string, unknown>>;
+export declare function streamGoogleCompatibleParts(stream: ReadableStream<Uint8Array>): AsyncIterable<unknown>;
+//# sourceMappingURL=google-stream.d.ts.map

package/esm/google-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-stream.d.ts","sourceRoot":"","sources":["../src/google-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAElB,MAAM,2BAA2B,CAAC;AAEnC,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,GACX,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgBlD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAsB7E;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAQjG;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAY5F;AAED,wBAAuB,2BAA2B,CAChD,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,GACjC,aAAa,CAAC,OAAO,CAAC,CAgHxB"}

package/esm/google-stream.js

@@ -0,0 +1,158 @@
+import { parseSseChunk, readRecord, stringifyJsonValue, } from "veryfront/provider/shared";
+export function normalizeGoogleFinishReason(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    switch (raw) {
+        case "STOP":
+            return { unified: "stop", raw };
+        case "MAX_TOKENS":
+            return { unified: "length", raw };
+        case "SAFETY":
+        case "RECITATION":
+            return { unified: "content-filter", raw };
+        default:
+            return raw.toLowerCase();
+    }
+}
+export function extractGoogleUsage(payload) {
+    const record = readRecord(payload);
+    const usage = readRecord(record?.usageMetadata);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = usage.promptTokenCount;
+    const outputTokens = usage.candidatesTokenCount;
+    const totalTokens = usage.totalTokenCount;
+    const cachedContentTokenCount = usage.cachedContentTokenCount;
+    const thoughtsTokenCount = usage.thoughtsTokenCount;
+    return {
+        inputTokens: typeof inputTokens === "number" ? inputTokens : undefined,
+        outputTokens: typeof outputTokens === "number" ? outputTokens : undefined,
+        totalTokens: typeof totalTokens === "number" ? totalTokens : undefined,
+        ...(typeof cachedContentTokenCount === "number"
+            ? { cacheReadInputTokens: cachedContentTokenCount }
+            : {}),
+        ...(typeof thoughtsTokenCount === "number" ? { reasoningTokens: thoughtsTokenCount } : {}),
+    };
+}
+export function extractFirstGoogleCandidate(payload) {
+    const record = readRecord(payload);
+    const candidates = record?.candidates;
+    if (!Array.isArray(candidates) || candidates.length === 0) {
+        return undefined;
+    }
+    return readRecord(candidates[0]);
+}
+export function extractGoogleCandidateParts(payload) {
+    const candidate = extractFirstGoogleCandidate(payload);
+    const content = readRecord(candidate?.content);
+    const parts = content?.parts;
+    if (!Array.isArray(parts)) {
+        return [];
+    }
+    return parts.flatMap((part) => {
+        const record = readRecord(part);
+        return record ? [record] : [];
+    });
+}
+export async function* streamGoogleCompatibleParts(stream) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const seenToolCalls = new Set();
+    let reasoningId = null;
+    let reasoningIndex = 0;
+    let finishReason = null;
+    let usage;
+    for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const parsed = parseSseChunk(buffer);
+        buffer = parsed.remainder;
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            usage = extractGoogleUsage(event) ?? usage;
+            const candidate = extractFirstGoogleCandidate(event);
+            const normalizedFinishReason = normalizeGoogleFinishReason(candidate?.finishReason);
+            if (normalizedFinishReason) {
+                finishReason = normalizedFinishReason;
+            }
+            for (const [index, part] of extractGoogleCandidateParts(event).entries()) {
+                const isThought = part.thought === true;
+                if (isThought && typeof part.text === "string" && part.text.length > 0) {
+                    if (!reasoningId) {
+                        reasoningId = `reasoning-${reasoningIndex++}`;
+                        yield {
+                            type: "reasoning-start",
+                            id: reasoningId,
+                        };
+                    }
+                    yield {
+                        type: "reasoning-delta",
+                        id: reasoningId,
+                        delta: part.text,
+                    };
+                    continue;
+                }
+                if (reasoningId) {
+                    yield {
+                        type: "reasoning-end",
+                        id: reasoningId,
+                    };
+                    reasoningId = null;
+                }
+                if (typeof part.text === "string" && part.text.length > 0) {
+                    yield { type: "text-delta", delta: part.text };
+                    continue;
+                }
+                const functionCall = readRecord(part.functionCall);
+                if (typeof functionCall?.name !== "string") {
+                    continue;
+                }
+                const toolCallId = typeof functionCall.id === "string" ? functionCall.id : `tool-${index}`;
+                if (seenToolCalls.has(toolCallId)) {
+                    continue;
+                }
+                const serializedInput = stringifyJsonValue(functionCall.args ?? {});
+                seenToolCalls.add(toolCallId);
+                yield {
+                    type: "tool-input-start",
+                    id: toolCallId,
+                    toolName: functionCall.name,
+                };
+                yield {
+                    type: "tool-input-delta",
+                    id: toolCallId,
+                    delta: serializedInput,
+                };
+                yield {
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: functionCall.name,
+                    input: serializedInput,
+                };
+            }
+        }
+    }
+    if (buffer.trim().length > 0) {
+        const parsed = parseSseChunk(`${buffer}\n\n`);
+        for (const event of parsed.events) {
+            if (event === "[DONE]") {
+                continue;
+            }
+            usage = extractGoogleUsage(event) ?? usage;
+        }
+    }
+    if (reasoningId) {
+        yield {
+            type: "reasoning-end",
+            id: reasoningId,
+        };
+    }
+    yield {
+        type: "finish",
+        finishReason,
+        ...(usage ? { usage } : {}),
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @veryfront/ext-llm-google — registers the Google provider into the
+ * core `LLMProviderRegistry`.
+ *
+ * @module extensions/ext-llm-google
+ */
+import type { ExtensionFactory } from "veryfront/extensions";
+import { GoogleProvider } from "./google-provider.js";
+declare const extGoogle: ExtensionFactory;
+export default extGoogle;
+export { GoogleProvider };
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,QAAA,MAAM,SAAS,EAAE,gBAmBhB,CAAC;AAEF,eAAe,SAAS,CAAC;AACzB,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/esm/index.js

@@ -0,0 +1,30 @@
+/**
+ * @veryfront/ext-llm-google — registers the Google provider into the
+ * core `LLMProviderRegistry`.
+ *
+ * @module extensions/ext-llm-google
+ */
+import { LLMProviderRegistryName } from "veryfront/extensions/llm";
+import { GoogleProvider } from "./google-provider.js";
+const extGoogle = () => {
+    const provider = new GoogleProvider();
+    return {
+        name: "ext-llm-google",
+        version: "0.1.0",
+        contracts: {
+            provides: ["LLMProvider:google"],
+            requires: [LLMProviderRegistryName],
+        },
+        capabilities: [],
+        setup(ctx) {
+            const registry = ctx.require(LLMProviderRegistryName);
+            registry.register(provider);
+            ctx.logger.info("[ext-llm-google] Google provider registered");
+        },
+        teardown() {
+            // No resources to release.
+        },
+    };
+};
+export default extGoogle;
+export { GoogleProvider };

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@veryfront/ext-llm-google",
+  "version": "0.1.985",
+  "description": "Veryfront first-party extension package for ext-llm-google",
+  "keywords": [
+    "veryfront",
+    "extension",
+    "ext-llm-google"
+  ],
+  "author": "Veryfront",
+  "homepage": "https://github.com/veryfront/veryfront-code/tree/main/extensions/ext-llm-google",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veryfront/veryfront-code.git",
+    "directory": "extensions/ext-llm-google"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veryfront/veryfront-code/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./esm/index.d.ts"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "veryfront": {
+    "extension": true,
+    "contracts": {
+      "provides": [
+        "LLMProvider:google"
+      ],
+      "requires": [
+        "LLMProviderRegistry"
+      ]
+    },
+    "capabilities": []
+  },
+  "peerDependencies": {
+    "veryfront": "^0.1.985"
+  },
+  "type": "module",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ]
+}