@veryfront/ext-llm-google 0.1.1186 → 0.1.1190

package/README.md

@@ -36,7 +36,7 @@ const response = await ai.chat("google/gemini-2.5-pro", {
 ### Embeddings
 
 ```ts
-const result = await ai.embed("google/text-embedding-005", {
+const result = await ai.embed("google/gemini-embedding-2", {
   values: ["search query"],
 });
 ```
@@ -47,7 +47,7 @@ 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`
+- **Embeddings:** `gemini-embedding-2`
 
 ## Configuration
 
@@ -98,8 +98,17 @@ Set `budgetTokens` directly to override the effort mapping:
 reasoning: { enabled: true, budgetTokens: 4096 }
 ```
 
+Explicit budgets must be non-negative safe integers. The `-1` dynamic-budget
+sentinel is reserved for `effort: "max"` and is rejected when supplied through
+`budgetTokens`.
+
 When thinking is enabled, Gemini returns `thought` parts that the runtime emits as `reasoning-start` / `reasoning-delta` / `reasoning-end` stream events.
 
+Gemini `thoughtSignature` fields are retained with the exact assistant parts that produced them and replayed automatically on later turns, including parallel function-call responses.
+Streaming and replay share one deterministic raw-position tool-ID registry.
+Exact replay retains at most 4,096 raw assistant parts and 8 MiB; surviving
+canonical calls and results must match the raw history in occurrence order.
+
 ## 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:
@@ -111,12 +120,24 @@ const response = await ai.chat("google/gemini-2.5-pro", {
 });
 ```
 
-When a cached content resource is attached, the response `usageMetadata.cachedContentTokenCount` is surfaced as `cacheReadInputTokens` on the result.
+When a cached content resource is attached, the response
+`usageMetadata.cachedContentTokenCount` is surfaced as the canonical
+`cacheReadInputTokens` field and the compatible `cachedInputTokens` alias on
+the result.
 
 ## Provider Tools
 
 Gemini supports provider-native tools alongside function declarations. Use the `provider` tool type with a `google.*` id:
 
+The extension intentionally supports only the provider tools whose request and
+response contracts are normalized end to end:
+
+- `google.code_execution` with name `code_execution`
+- `google.google_search` with name `google_search`
+
+Unknown or duplicate provider-tool IDs, tools for another provider, mismatched
+names, and unsupported argument fields throw before the HTTP request is sent.
+
 ### Code Execution
 
 ```ts
@@ -125,15 +146,47 @@ tools: [
 ];
 ```
 
+Google `executableCode` / `codeExecutionResult` parts are exposed as correlated
+`code_execution` tool calls and results with `providerExecuted: true`. Failed
+and deadline-exceeded outcomes are marked as tool errors. The original ordered
+Google parts, including provider IDs and thought signatures, are retained for
+exact replay on subsequent turns.
+
 ### Google Search
 
 ```ts
 tools: [
-  { type: "provider", name: "google_search", id: "google.google_search", args: {} },
+  {
+    type: "provider",
+    name: "google_search",
+    id: "google.google_search",
+    args: {
+      searchTypes: { webSearch: {}, imageSearch: {} },
+      timeRangeFilter: {
+        startTime: "2026-01-01T00:00:00Z",
+        endTime: "2026-07-01T00:00:00Z",
+      },
+    },
+  },
 ];
 ```
 
-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.
+Both Google Search argument groups are optional; `{}` keeps Google's default web
+search behavior. A time range requires both RFC 3339 timestamps. The nested
+`webSearch` and `imageSearch` configurations are currently empty objects, as
+defined by Google's API.
+
+Provider tools can be combined with regular function tools in the same request.
+Google Search does not produce a client-executed tool call. Instead, Google
+returns a candidate-level `groundingMetadata` object containing queries,
+grounding chunks, and citation indices. The direct adapter result retains the
+legacy top-level `groundingMetadata` property, and direct and streaming results
+also expose the same opaque object at
+`providerMetadata.google.groundingMetadata`, which survives runtime
+normalization. The object envelope and stable citation list fields
+(`groundingChunks`, `groundingSupports`, `webSearchQueries`, and
+`imageSearchQueries`) are validated for shape. Other nested fields remain
+Google-owned so new metadata can pass through without an extension release.
 
 ## Safety Settings
 
@@ -199,12 +252,18 @@ The following settings emit `unsupported-setting` warnings and are silently drop
 
 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        |
+| Error Class               | Trigger                                       | Retryable |
+| ------------------------- | --------------------------------------------- | --------- |
+| `ProviderOverloadedError` | HTTP 503                                      | Yes       |
+| `ProviderQuotaError`      | HTTP 429 `RESOURCE_EXHAUSTED`, no retry delay | No        |
+| `ProviderRateLimitError`  | HTTP 429 with `Retry-After` or `RetryInfo`    | Yes       |
+| `ProviderRequestError`    | Other HTTP errors                             | No        |
+
+Google returns `RESOURCE_EXHAUSTED` for both the daily quota and short-window
+per-minute limits. A retry delay — the `Retry-After` header or a
+`google.rpc.RetryInfo` entry in `error.details` — separates them: with one the
+error is a retryable rate limit carrying the delay, without one it is a hard
+quota error that cannot succeed again until the daily window resets.
 
 If the extension is not installed and a `google/*` model is requested:
 
@@ -226,22 +285,22 @@ The unified `toolChoice` option maps to Gemini's `functionCallingConfig`:
 
 ```bash
 # From the repository root
-deno test --no-check --allow-all extensions/ext-google/
+deno test --no-check --allow-all extensions/ext-llm-google/src/
 
 # Or from the extension directory
-cd extensions/ext-google
+cd extensions/ext-llm-google
 deno task test
 ```
 
 The test suite covers:
 
 - Generate and stream request/response mapping
-- Extended thinking (thinkingConfig budget mapping, thought-part streaming)
+- Extended thinking (validated thinkingConfig budgets, 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)
+- Provider tools (correlated code_execution calls/results and google_search)
 - Safety settings and cached content

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,12 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}

package/esm/_dnt.polyfills.js

@@ -0,0 +1,15 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+export {};

package/esm/google-content-parts.d.ts

@@ -0,0 +1,45 @@
+export declare const GOOGLE_CODE_EXECUTION_TOOL_NAME = "code_execution";
+export type GoogleSupportedPartDataField = "text" | "functionCall" | "executableCode" | "codeExecutionResult";
+export type GoogleExecutableCode = {
+    providerId?: string;
+    language: "PYTHON";
+    code: string;
+};
+export type GoogleCodeExecutionResult = {
+    providerId?: string;
+    outcome: "OUTCOME_OK" | "OUTCOME_FAILED" | "OUTCOME_DEADLINE_EXCEEDED";
+    output: string;
+    isError: boolean;
+};
+export type GoogleToolCallCorrelationRegistry = {
+    registerFunctionCall(partIndex: number, providerId: string | undefined): string;
+    registerCodeExecution(providerId: string | undefined): string;
+    resolveCodeExecutionResult(providerId: string | undefined): string;
+    assertSettled(): void;
+};
+/**
+ * Owns Gemini's tool-call id allocation and code-execution pairing rules.
+ *
+ * The response normalizer and exact-replay validator must derive identical
+ * ids for anonymous code execution. Keeping the allocator here prevents those
+ * two protocol boundaries from drifting independently.
+ */
+export declare function createGoogleToolCallCorrelationRegistry(): GoogleToolCallCorrelationRegistry;
+/**
+ * Validates the documented `Part.data` oneof and returns the supported field.
+ *
+ * The extension intentionally fails closed for media/file/function-response
+ * output parts until it has a canonical runtime representation for them.
+ */
+export declare function readGooglePartDataField(part: Record<string, unknown>): GoogleSupportedPartDataField;
+export declare function readGoogleExecutableCode(value: unknown): GoogleExecutableCode;
+export declare function readGoogleCodeExecutionResult(value: unknown): GoogleCodeExecutionResult;
+export declare function googleCodeExecutionInput(executableCode: GoogleExecutableCode): {
+    language: "PYTHON";
+    code: string;
+};
+export declare function googleCodeExecutionOutput(result: GoogleCodeExecutionResult): {
+    outcome: GoogleCodeExecutionResult["outcome"];
+    output: string;
+};
+//# sourceMappingURL=google-content-parts.d.ts.map

package/esm/google-content-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-content-parts.d.ts","sourceRoot":"","sources":["../src/google-content-parts.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,+BAA+B,mBAAmB,CAAC;AAsBhE,MAAM,MAAM,4BAA4B,GACpC,MAAM,GACN,cAAc,GACd,gBAAgB,GAChB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,YAAY,GAAG,gBAAgB,GAAG,2BAA2B,CAAC;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAChF,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAC9D,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IACnE,aAAa,IAAI,IAAI,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,uCAAuC,IAAI,iCAAiC,CAgE3F;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,4BAA4B,CAyB9B;AAeD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAiB7E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAyBvF;AAED,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,oBAAoB,GACnC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAKtC;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,yBAAyB,GAChC;IACD,OAAO,EAAE,yBAAyB,CAAC,SAAS,CAAC,CAAC;IAC9C,MAAM,EAAE,MAAM,CAAC;CAChB,CAKA"}

package/esm/google-content-parts.js

@@ -0,0 +1,164 @@
+import { readRecord } from "veryfront/provider/shared";
+export const GOOGLE_CODE_EXECUTION_TOOL_NAME = "code_execution";
+const GOOGLE_PART_DATA_FIELDS = [
+    "text",
+    "inlineData",
+    "functionCall",
+    "functionResponse",
+    "fileData",
+    "executableCode",
+    "codeExecutionResult",
+    "toolCall",
+    "toolResponse",
+];
+const GOOGLE_PART_METADATA_FIELDS = new Set([
+    "mediaResolution",
+    "partMetadata",
+    "thought",
+    "thoughtSignature",
+    "videoMetadata",
+]);
+/**
+ * Owns Gemini's tool-call id allocation and code-execution pairing rules.
+ *
+ * The response normalizer and exact-replay validator must derive identical
+ * ids for anonymous code execution. Keeping the allocator here prevents those
+ * two protocol boundaries from drifting independently.
+ */
+export function createGoogleToolCallCorrelationRegistry() {
+    const usedToolCallIds = new Set();
+    const pendingCodeExecutionsByProviderId = new Map();
+    const pendingAnonymousCodeExecutions = [];
+    let anonymousCodeExecutionIndex = 0;
+    const reserve = (id) => {
+        if (usedToolCallIds.has(id)) {
+            throw new TypeError("Google tool call id was duplicated");
+        }
+        usedToolCallIds.add(id);
+        return id;
+    };
+    return {
+        registerFunctionCall(partIndex, providerId) {
+            return reserve(providerId ?? `tool-${partIndex}`);
+        },
+        registerCodeExecution(providerId) {
+            if (providerId !== undefined) {
+                const id = reserve(providerId);
+                pendingCodeExecutionsByProviderId.set(providerId, id);
+                return id;
+            }
+            let id;
+            do {
+                id = `google-code-execution-${anonymousCodeExecutionIndex++}`;
+            } while (usedToolCallIds.has(id));
+            usedToolCallIds.add(id);
+            pendingAnonymousCodeExecutions.push(id);
+            return id;
+        },
+        resolveCodeExecutionResult(providerId) {
+            if (providerId === undefined) {
+                const id = pendingAnonymousCodeExecutions.shift();
+                if (id === undefined) {
+                    throw new TypeError("Google code execution result had no matching executable code");
+                }
+                return id;
+            }
+            const id = pendingCodeExecutionsByProviderId.get(providerId);
+            if (id === undefined) {
+                throw new TypeError("Google code execution result id did not match executable code");
+            }
+            pendingCodeExecutionsByProviderId.delete(providerId);
+            return id;
+        },
+        assertSettled() {
+            if (pendingCodeExecutionsByProviderId.size > 0 ||
+                pendingAnonymousCodeExecutions.length > 0) {
+                throw new TypeError("Google executable code had no matching execution result");
+            }
+        },
+    };
+}
+/**
+ * Validates the documented `Part.data` oneof and returns the supported field.
+ *
+ * The extension intentionally fails closed for media/file/function-response
+ * output parts until it has a canonical runtime representation for them.
+ */
+export function readGooglePartDataField(part) {
+    const unknownField = Object.keys(part).find((field) => !GOOGLE_PART_DATA_FIELDS.includes(field) && !GOOGLE_PART_METADATA_FIELDS.has(field));
+    if (unknownField !== undefined) {
+        throw new TypeError(`Google part field "${unknownField}" is unknown`);
+    }
+    const presentFields = GOOGLE_PART_DATA_FIELDS.filter((field) => part[field] !== undefined);
+    if (presentFields.length !== 1) {
+        throw new TypeError("Google part must contain exactly one data field");
+    }
+    const field = presentFields[0];
+    switch (field) {
+        case "text":
+        case "functionCall":
+        case "executableCode":
+        case "codeExecutionResult":
+            return field;
+        default:
+            throw new TypeError(`Google part data field "${field}" is unsupported`);
+    }
+}
+function readOptionalProviderId(record, subject) {
+    if (record.id === undefined) {
+        return undefined;
+    }
+    if (typeof record.id !== "string" || record.id.length === 0) {
+        throw new TypeError(`Google ${subject} id must be a non-empty string`);
+    }
+    return record.id;
+}
+export function readGoogleExecutableCode(value) {
+    const record = readRecord(value);
+    if (!record ||
+        record.language !== "PYTHON" ||
+        typeof record.code !== "string" ||
+        record.code.length === 0) {
+        throw new TypeError("Google executable code is malformed");
+    }
+    const providerId = readOptionalProviderId(record, "executable code");
+    return {
+        ...(providerId !== undefined ? { providerId } : {}),
+        language: "PYTHON",
+        code: record.code,
+    };
+}
+export function readGoogleCodeExecutionResult(value) {
+    const record = readRecord(value);
+    if (!record) {
+        throw new TypeError("Google code execution result is malformed");
+    }
+    const providerId = readOptionalProviderId(record, "code execution result");
+    const outcome = record.outcome;
+    if (outcome !== "OUTCOME_OK" &&
+        outcome !== "OUTCOME_FAILED" &&
+        outcome !== "OUTCOME_DEADLINE_EXCEEDED") {
+        throw new TypeError("Google code execution result outcome is malformed");
+    }
+    if (record.output !== undefined && typeof record.output !== "string") {
+        throw new TypeError("Google code execution result output is malformed");
+    }
+    return {
+        ...(providerId !== undefined ? { providerId } : {}),
+        outcome,
+        output: typeof record.output === "string" ? record.output : "",
+        isError: outcome !== "OUTCOME_OK",
+    };
+}
+export function googleCodeExecutionInput(executableCode) {
+    return {
+        language: executableCode.language,
+        code: executableCode.code,
+    };
+}
+export function googleCodeExecutionOutput(result) {
+    return {
+        outcome: result.outcome,
+        output: result.output,
+    };
+}

package/esm/google-grounding-metadata.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validate the stable list fields needed to preserve citation integrity while
+ * retaining all other Google-owned metadata fields opaquely.
+ */
+export declare function readGoogleGroundingMetadata(value: unknown): Record<string, unknown>;
+/**
+ * Merge one streaming GroundingMetadata delta into the aggregate result.
+ *
+ * Google documents groundingChunks as incremental in streaming responses and
+ * defines support indices across every response. Supports are therefore
+ * appended too, while query strings are accumulated without duplicates.
+ * Scalar/object fields and unknown future fields use the latest value.
+ */
+export declare function mergeGoogleGroundingMetadata(current: Record<string, unknown> | undefined, incoming: unknown): Record<string, unknown>;
+//# sourceMappingURL=google-grounding-metadata.d.ts.map

package/esm/google-grounding-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-grounding-metadata.d.ts","sourceRoot":"","sources":["../src/google-grounding-metadata.ts"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBzB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC5C,QAAQ,EAAE,OAAO,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB"}

package/esm/google-grounding-metadata.js

@@ -0,0 +1,87 @@
+import { readRecord } from "veryfront/provider/shared";
+const APPENDED_OBJECT_ARRAY_FIELDS = [
+    "groundingChunks",
+    "groundingSupports",
+];
+const MERGED_STRING_ARRAY_FIELDS = [
+    "webSearchQueries",
+    "imageSearchQueries",
+];
+function readObjectArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`Google grounding metadata ${field} must be an array`);
+    }
+    return value.map((item) => {
+        const record = readRecord(item);
+        if (!record) {
+            throw new TypeError(`Google grounding metadata ${field} item must be an object`);
+        }
+        return record;
+    });
+}
+function readStringArray(value, field) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new TypeError(`Google grounding metadata ${field} must be a string array`);
+    }
+    return value;
+}
+/**
+ * Validate the stable list fields needed to preserve citation integrity while
+ * retaining all other Google-owned metadata fields opaquely.
+ */
+export function readGoogleGroundingMetadata(value) {
+    const metadata = readRecord(value);
+    if (!metadata) {
+        throw new TypeError("Google grounding metadata must be an object");
+    }
+    const normalized = { ...metadata };
+    for (const field of APPENDED_OBJECT_ARRAY_FIELDS) {
+        if (metadata[field] !== undefined) {
+            normalized[field] = readObjectArray(metadata[field], field);
+        }
+    }
+    for (const field of MERGED_STRING_ARRAY_FIELDS) {
+        if (metadata[field] !== undefined) {
+            normalized[field] = readStringArray(metadata[field], field);
+        }
+    }
+    return normalized;
+}
+/**
+ * Merge one streaming GroundingMetadata delta into the aggregate result.
+ *
+ * Google documents groundingChunks as incremental in streaming responses and
+ * defines support indices across every response. Supports are therefore
+ * appended too, while query strings are accumulated without duplicates.
+ * Scalar/object fields and unknown future fields use the latest value.
+ */
+export function mergeGoogleGroundingMetadata(current, incoming) {
+    const normalizedIncoming = readGoogleGroundingMetadata(incoming);
+    const merged = {
+        ...(current ?? {}),
+        ...normalizedIncoming,
+    };
+    for (const field of APPENDED_OBJECT_ARRAY_FIELDS) {
+        const previousItems = current?.[field];
+        const incomingItems = normalizedIncoming[field];
+        if (incomingItems !== undefined) {
+            merged[field] = [
+                ...(Array.isArray(previousItems) ? previousItems : []),
+                ...incomingItems,
+            ];
+        }
+    }
+    for (const field of MERGED_STRING_ARRAY_FIELDS) {
+        const previousItems = current?.[field];
+        const incomingItems = normalizedIncoming[field];
+        if (incomingItems !== undefined) {
+            merged[field] = [
+                ...new Set([
+                    ...(Array.isArray(previousItems) ? previousItems : []),
+                    ...incomingItems,
+                ]),
+            ];
+        }
+    }
+    return merged;
+}

package/esm/google-provider.d.ts

@@ -7,8 +7,9 @@
  * @module extensions/ext-llm-google/google-provider
  */
 import type { LLMProvider, LLMProviderConfig } from "veryfront/extensions/llm";
-import type { EmbeddingRuntime, ModelRuntime } from "veryfront/provider/types";
+import type { EmbeddingRuntime, ModelRuntime, RuntimeAssistantContentPart } from "veryfront/provider/types";
 import { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema } from "veryfront/provider/shared";
+import { type OpenAICompatibleLanguageOptions } from "./google-request-builder.js";
 export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, unwrapToolInputSchema, };
 export interface GoogleRuntimeConfig {
     apiKey: string;
@@ -16,11 +17,11 @@ export interface GoogleRuntimeConfig {
     name?: string;
     fetch?: typeof globalThis.fetch;
 }
-export declare function createGoogleModelRuntime(config: GoogleRuntimeConfig, modelId: string): ModelRuntime;
+export declare function createGoogleModelRuntime(config: GoogleRuntimeConfig, modelId: string): ModelRuntime<OpenAICompatibleLanguageOptions, RuntimeAssistantContentPart>;
 export declare function createGoogleEmbeddingRuntime(config: GoogleRuntimeConfig, modelId: string): EmbeddingRuntime;
 export declare class GoogleProvider implements LLMProvider {
     readonly id = "google";
-    createModel(modelId: string, config: LLMProviderConfig): ModelRuntime;
+    createModel(modelId: string, config: LLMProviderConfig): ModelRuntime<OpenAICompatibleLanguageOptions, RuntimeAssistantContentPart>;
     createEmbedding(modelId: string, config: LLMProviderConfig): EmbeddingRuntime;
 }
 //# sourceMappingURL=google-provider.d.ts.map

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

@@ -1 +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,EACtB,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,GACtB,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"}
+{"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,EACV,gBAAgB,EAChB,YAAY,EACZ,2BAA2B,EAC5B,MAAM,0BAA0B,CAAC;AAClC,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,EACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,6BAA6B,CAAC;AAwBrC,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,GACtB,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;AAmdD,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,YAAY,CAAC,+BAA+B,EAAE,2BAA2B,CAAC,CA2E5E;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,gBAAgB,CAiFlB;AAED,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,EAAE,YAAY;IAEvB,WAAW,CACT,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,iBAAiB,GACxB,YAAY,CAAC,+BAA+B,EAAE,2BAA2B,CAAC;IAY7E,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,gBAAgB;CAW9E"}