@veryfront/ext-llm-google 0.1.1185 → 0.1.1189

package/esm/google-thought-signatures.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_GOOGLE_PROVIDER_METADATA_BYTES: number;
+export declare function readGoogleThoughtSignature(part: Record<string, unknown>): string | undefined;
+export declare function createGoogleProviderMetadata(parts: Array<Record<string, unknown>>, groundingMetadata?: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function readGoogleRawAssistantParts(providerMetadata: Record<string, unknown> | undefined): readonly Record<string, unknown>[] | undefined;
+//# sourceMappingURL=google-thought-signatures.d.ts.map

package/esm/google-thought-signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-thought-signatures.d.ts","sourceRoot":"","sources":["../src/google-thought-signatures.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,kCAAkC,QAAkB,CAAC;AA4MlE,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,GAAG,SAAS,CASpB;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC1C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAgCrC;AA4ED,wBAAgB,2BAA2B,CACzC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACpD,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,SAAS,CAsBhD"}

package/esm/google-thought-signatures.js

@@ -0,0 +1,296 @@
+import { readRecord, snapshotJsonValue } from "veryfront/provider/shared";
+import { createGoogleToolCallCorrelationRegistry, readGoogleCodeExecutionResult, readGoogleExecutableCode, readGooglePartDataField, } from "./google-content-parts.js";
+const GOOGLE_METADATA_KEY = "google";
+const RAW_ASSISTANT_PARTS_KEY = "rawAssistantParts";
+const GROUNDING_METADATA_KEY = "groundingMetadata";
+const MAX_GOOGLE_RAW_ASSISTANT_PARTS = 4_096;
+export const MAX_GOOGLE_PROVIDER_METADATA_BYTES = 8 * 1024 * 1024;
+const GOOGLE_PROVIDER_METADATA_SNAPSHOT_OPTIONS = {
+    maxDepth: 64,
+    maxNodes: 65_536,
+    maxBytes: MAX_GOOGLE_PROVIDER_METADATA_BYTES,
+};
+function snapshotGoogleProviderMetadata(value) {
+    return snapshotJsonValue(value, GOOGLE_PROVIDER_METADATA_SNAPSHOT_OPTIONS);
+}
+function asSnapshotRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readGoogleMetadataNamespace(providerMetadata) {
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(providerMetadata, GOOGLE_METADATA_KEY);
+    }
+    catch {
+        throw new TypeError("Google provider metadata could not be inspected");
+    }
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (descriptor.enumerable !== true ||
+        !Object.hasOwn(descriptor, "value")) {
+        throw new TypeError("Google provider metadata namespace must be an enumerable data property");
+    }
+    return descriptor.value;
+}
+function readGoogleRawPartsValue(googleMetadata) {
+    if (googleMetadata === null ||
+        typeof googleMetadata !== "object" ||
+        Array.isArray(googleMetadata)) {
+        throw new TypeError("Google provider metadata must be an object");
+    }
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(googleMetadata, RAW_ASSISTANT_PARTS_KEY);
+    }
+    catch {
+        throw new TypeError("Google provider metadata could not be inspected");
+    }
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (descriptor.enumerable !== true ||
+        !Object.hasOwn(descriptor, "value")) {
+        throw new TypeError("Google raw assistant parts must be an enumerable data property");
+    }
+    return descriptor.value;
+}
+function hasGoogleReplayTriggerProperty(part, key) {
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(part, key);
+    }
+    catch {
+        throw new TypeError("Google assistant part could not be inspected");
+    }
+    if (descriptor === undefined) {
+        return false;
+    }
+    // An accessor might conceal a replay trigger. Treat it as present so the
+    // descriptor-based snapshot rejects it without invoking caller code.
+    return !Object.hasOwn(descriptor, "value") || descriptor.value !== undefined;
+}
+function needsGoogleExactReplay(parts) {
+    let lengthDescriptor;
+    try {
+        lengthDescriptor = Object.getOwnPropertyDescriptor(parts, "length");
+    }
+    catch {
+        throw new TypeError("Google assistant parts could not be inspected");
+    }
+    if (lengthDescriptor === undefined ||
+        !Object.hasOwn(lengthDescriptor, "value") ||
+        !Number.isSafeInteger(lengthDescriptor.value) ||
+        lengthDescriptor.value < 0) {
+        throw new TypeError("Google assistant parts had an invalid length");
+    }
+    const partsLength = lengthDescriptor.value;
+    let partKeys;
+    try {
+        partKeys = Reflect.ownKeys(parts);
+    }
+    catch {
+        throw new TypeError("Google assistant parts could not be inspected");
+    }
+    for (const partKey of partKeys) {
+        if (partKey === "length" || typeof partKey !== "string") {
+            continue;
+        }
+        const partIndex = Number(partKey);
+        if (!Number.isSafeInteger(partIndex) ||
+            partIndex < 0 ||
+            partIndex >= partsLength ||
+            String(partIndex) !== partKey) {
+            continue;
+        }
+        let partDescriptor;
+        try {
+            partDescriptor = Object.getOwnPropertyDescriptor(parts, partKey);
+        }
+        catch {
+            throw new TypeError("Google assistant parts could not be inspected");
+        }
+        if (partDescriptor === undefined) {
+            throw new TypeError("Google assistant parts changed while being inspected");
+        }
+        if (!Object.hasOwn(partDescriptor, "value")) {
+            // Force the protected snapshot path, which rejects array accessors
+            // without invoking them.
+            return true;
+        }
+        const part = partDescriptor.value;
+        if (part === null || typeof part !== "object") {
+            continue;
+        }
+        if (hasGoogleReplayTriggerProperty(part, "thoughtSignature") ||
+            hasGoogleReplayTriggerProperty(part, "executableCode") ||
+            hasGoogleReplayTriggerProperty(part, "codeExecutionResult")) {
+            return true;
+        }
+    }
+    return false;
+}
+function validateReplayableGooglePart(part) {
+    if (part.thought !== undefined && typeof part.thought !== "boolean") {
+        throw new TypeError("Google raw assistant thought marker must be a boolean");
+    }
+    const dataField = readGooglePartDataField(part);
+    switch (dataField) {
+        case "text":
+            if (typeof part.text !== "string") {
+                throw new TypeError("Google raw assistant text must be a string");
+            }
+            break;
+        case "functionCall": {
+            const functionCall = readRecord(part.functionCall);
+            if (!functionCall ||
+                typeof functionCall.name !== "string" ||
+                functionCall.name.length === 0 ||
+                (functionCall.args !== undefined && !readRecord(functionCall.args))) {
+                throw new TypeError("Google raw assistant function call is malformed");
+            }
+            if (functionCall.id !== undefined &&
+                (typeof functionCall.id !== "string" || functionCall.id.length === 0)) {
+                throw new TypeError("Google raw assistant function call id is malformed");
+            }
+            break;
+        }
+        case "executableCode":
+            readGoogleExecutableCode(part.executableCode);
+            break;
+        case "codeExecutionResult":
+            readGoogleCodeExecutionResult(part.codeExecutionResult);
+            break;
+    }
+    return dataField;
+}
+export function readGoogleThoughtSignature(part) {
+    const signature = part.thoughtSignature;
+    if (signature === undefined) {
+        return undefined;
+    }
+    if (typeof signature !== "string" || signature.length === 0) {
+        throw new TypeError("Google thought signature must be a non-empty string");
+    }
+    return signature;
+}
+export function createGoogleProviderMetadata(parts, groundingMetadata) {
+    const needsExactReplay = needsGoogleExactReplay(parts);
+    if (!needsExactReplay && groundingMetadata === undefined) {
+        return undefined;
+    }
+    let ownedParts;
+    if (needsExactReplay) {
+        const partsSnapshot = snapshotGoogleProviderMetadata(parts);
+        if (!Array.isArray(partsSnapshot)) {
+            throw new TypeError("Google raw assistant parts must be an array");
+        }
+        if (partsSnapshot.length > MAX_GOOGLE_RAW_ASSISTANT_PARTS) {
+            throw new TypeError(`Google raw assistant parts exceeded ${MAX_GOOGLE_RAW_ASSISTANT_PARTS} entries`);
+        }
+        ownedParts = validateGoogleRawAssistantParts(partsSnapshot);
+    }
+    const metadata = snapshotGoogleProviderMetadata({
+        [GOOGLE_METADATA_KEY]: {
+            ...(needsExactReplay ? { [RAW_ASSISTANT_PARTS_KEY]: ownedParts } : {}),
+            ...(groundingMetadata !== undefined ? { [GROUNDING_METADATA_KEY]: groundingMetadata } : {}),
+        },
+    });
+    const metadataRecord = asSnapshotRecord(metadata);
+    if (!metadataRecord) {
+        throw new TypeError("Google provider metadata must be an object");
+    }
+    return metadataRecord;
+}
+function validateGoogleRawAssistantParts(rawParts) {
+    if (rawParts.length === 0) {
+        throw new TypeError("Google raw assistant parts must be a non-empty array");
+    }
+    if (rawParts.length > MAX_GOOGLE_RAW_ASSISTANT_PARTS) {
+        throw new TypeError(`Google raw assistant parts exceeded ${MAX_GOOGLE_RAW_ASSISTANT_PARTS} entries`);
+    }
+    let hasThoughtSignature = false;
+    let hasCodeExecution = false;
+    const toolCallRegistry = createGoogleToolCallCorrelationRegistry();
+    for (let partIndex = 0; partIndex < rawParts.length; partIndex += 1) {
+        const rawPart = rawParts[partIndex];
+        if (rawPart === undefined) {
+            throw new TypeError("Google raw assistant parts must be dense");
+        }
+        const part = asSnapshotRecord(rawPart);
+        if (!part) {
+            throw new TypeError("Google raw assistant part must be an object");
+        }
+        const dataField = validateReplayableGooglePart(part);
+        if (readGoogleThoughtSignature(part) !== undefined) {
+            hasThoughtSignature = true;
+        }
+        if (dataField === "functionCall") {
+            const functionCall = readRecord(part.functionCall);
+            const functionCallId = typeof functionCall?.id === "string" ? functionCall.id : undefined;
+            try {
+                toolCallRegistry.registerFunctionCall(partIndex, functionCallId);
+            }
+            catch {
+                throw new TypeError("Google raw assistant tool call id was duplicated");
+            }
+        }
+        else if (dataField === "executableCode") {
+            const executableCode = readGoogleExecutableCode(part.executableCode);
+            hasCodeExecution = true;
+            try {
+                toolCallRegistry.registerCodeExecution(executableCode.providerId);
+            }
+            catch {
+                throw new TypeError("Google raw assistant executable code id was duplicated");
+            }
+        }
+        else if (dataField === "codeExecutionResult") {
+            const result = readGoogleCodeExecutionResult(part.codeExecutionResult);
+            hasCodeExecution = true;
+            try {
+                toolCallRegistry.resolveCodeExecutionResult(result.providerId);
+            }
+            catch {
+                throw new TypeError(result.providerId === undefined
+                    ? "Google raw assistant code execution result had no matching executable code"
+                    : "Google raw assistant code execution result id did not match executable code");
+            }
+        }
+    }
+    if (!hasThoughtSignature && !hasCodeExecution) {
+        throw new TypeError("Google raw assistant parts contained neither a thought signature nor code execution");
+    }
+    try {
+        toolCallRegistry.assertSettled();
+    }
+    catch {
+        throw new TypeError("Google raw assistant executable code had no matching result");
+    }
+    // Return the exact frozen snapshot array that was validated. Do not rebuild
+    // a shallow collection whose contents could diverge before serialization.
+    return rawParts;
+}
+export function readGoogleRawAssistantParts(providerMetadata) {
+    if (providerMetadata === undefined) {
+        return undefined;
+    }
+    const rawGoogleMetadata = readGoogleMetadataNamespace(providerMetadata);
+    if (rawGoogleMetadata === undefined) {
+        return undefined;
+    }
+    const rawParts = readGoogleRawPartsValue(rawGoogleMetadata);
+    if (rawParts === undefined) {
+        return undefined;
+    }
+    // Grounding and future Google metadata fields are not replayed. Snapshot
+    // only the exact wire value that will be validated and transmitted so those
+    // independent fields cannot consume replay budgets or invoke accessors.
+    const rawPartsSnapshot = snapshotGoogleProviderMetadata(rawParts);
+    if (!Array.isArray(rawPartsSnapshot)) {
+        throw new TypeError("Google raw assistant parts must be a non-empty array");
+    }
+    return validateGoogleRawAssistantParts(rawPartsSnapshot);
+}

package/esm/index.d.ts

@@ -4,6 +4,7 @@
  *
  * @module extensions/ext-llm-google
  */
+import "./_dnt.polyfills.js";
 import type { ExtensionFactory } from "veryfront/extensions";
 import { GoogleProvider } from "./google-provider.js";
 declare const extGoogle: ExtensionFactory;

package/esm/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,QAAA,MAAM,SAAS,EAAE,gBA0BhB,CAAC;AAEF,eAAe,SAAS,CAAC;AACzB,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/esm/index.js

@@ -4,10 +4,13 @@
  *
  * @module extensions/ext-llm-google
  */
+import "./_dnt.polyfills.js";
 import { LLMProviderRegistryName } from "veryfront/extensions/llm";
 import { GoogleProvider } from "./google-provider.js";
 const extGoogle = () => {
     const provider = new GoogleProvider();
+    let registryRef;
+    let registeredProvider = false;
     return {
         name: "ext-llm-google",
         version: "0.1.0",
@@ -18,11 +21,17 @@ const extGoogle = () => {
         capabilities: [],
         setup(ctx) {
             const registry = ctx.require(LLMProviderRegistryName);
+            registeredProvider = !registry.has(provider.id);
             registry.register(provider);
+            ctx.provide("LLMProvider:google", registry.get(provider.id) ?? provider);
+            registryRef = registry;
             ctx.logger.debug("[ext-llm-google] Google provider registered");
         },
         teardown() {
-            // No resources to release.
+            if (registeredProvider)
+                registryRef?.unregister(provider.id);
+            registeredProvider = false;
+            registryRef = undefined;
         },
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-llm-google",
-  "version": "0.1.1185",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-llm-google",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -45,7 +45,7 @@
     "capabilities": []
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1185"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/index.d.ts",