narraeon 0.7.10 → 0.8.0

package/dist/node/runtime/model/FileNativeModelAdapters.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import { appendFile, chmod, mkdir, stat } from "node:fs/promises";
 import { dirname } from "node:path";
 import { hasCLIProxyThinkingSuffix, modelReasoningPolicyIssue, } from "../../protocol/modelConnections.js";
-import { assertModelOutputComplete, ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
+import { assertModelOutputComplete, ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, modelHostFailureRequiresFreshContext, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
 import { renderPromptDeltaMessage, } from "../prompt/FileNativePromptCompiler.js";
+import { validGoogleInteractionsContinuation, } from "./ProviderExchangeState.js";
+import { aggregateGoogleInteractions, projectGoogleInteractions, } from "./GoogleInteractionsStream.js";
 import { aggregateAnthropicModelStream, aggregateChatModelStream, aggregateResponsesModelStream, } from "./ModelHostStream.js";
 import { defaultRuntimeToolDefinitionStrategy, portableRuntimeToolInputSchema, } from "../prompt/FileNativeToolRegistry.js";
 import { AiExchangeCapture, errorDescription, } from "./AiFailureLog.js";
@@ -70,6 +72,13 @@ export class FileNativeModelHost {
                 responseStorage: provider === "openai_responses" ? "disabled" : "provider_default",
                 encryptedReasoningContinuation: provider === "openai_responses" ? "included" : "not_requested",
                 anthropicVersion: provider === "anthropic_messages" ? "2023-06-01" : null,
+                ...(provider === "google_interactions"
+                    ? {
+                        interactionsEndpoint: providerUrl(this.#connection).pathname,
+                        apiRevision: null,
+                        store: false,
+                    }
+                    : {}),
                 dialect: this.#connection.dialect,
                 reasoningEffort: this.#connection.reasoningEffort,
                 reasoningSummary: this.#connection.reasoningSummary,
@@ -118,6 +127,8 @@ export class FileNativeModelHost {
                 return await this.#chat(request, observer?.onDelta, signal);
             if (this.#connection.provider === "openai_responses")
                 return await this.#responses(request, observer?.onDelta, signal);
+            if (this.#connection.provider === "google_interactions")
+                return await this.#google(request, observer?.onDelta, signal, observer?.retainLateExtensionResponse === true, observer?.onGoogleHop, observer?.diagnosticAttempt);
             return await this.#anthropic(request, observer?.onDelta, signal);
         }
         catch (error) {
@@ -129,24 +140,39 @@ export class FileNativeModelHost {
     }
     /** Uses the production encoders and deliberately omits credentials. */
     previewRequest(request) {
-        return this.#requestHost(request).#previewRequest(request);
+        return this.#requestHost(request).#previewRequest(request, this.#connection.provider === "google_interactions");
+    }
+    previewAuthoringRequest(request) {
+        return this.#requestHost(request).#previewRequest(request, true);
     }
-    #previewRequest(request) {
+    #previewRequest(request, redactContinuation = false) {
         assertExchangeCompatibility(this.#connection, request);
         const provider = this.#connection.provider;
         const body = provider === "chat_completions"
             ? chatRequestBody(this.#connection, request)
             : provider === "openai_responses"
                 ? responsesRequestBody(responsesRequestInput(this.#connection, request))
-                : anthropicRequestBody(this.#connection, request);
+                : provider === "google_interactions"
+                    ? googleRequestBody(this.#connection, request, redactContinuation)
+                    : anthropicRequestBody(this.#connection, request);
         return {
             provider,
             method: "POST",
-            endpointPath: providerUrl(this.#connection).pathname,
+            endpointPath: provider === "google_interactions"
+                ? googleDiagnosticPath(this.#connection)
+                : providerUrl(this.#connection).pathname,
             headerNames: provider === "anthropic_messages"
                 ? ["Accept", "anthropic-version", "x-api-key", "Content-Type"]
-                : ["Accept", "Authorization", "Content-Type"],
+                : provider === "google_interactions"
+                    ? ["Accept", "x-goog-api-key", "Content-Type"]
+                    : ["Accept", "Authorization", "Content-Type"],
             body: cloneProviderValue(body),
+            ...(provider === "google_interactions" && redactContinuation
+                ? { redactedProviderContinuation: true }
+                : {}),
+            ...(provider === "google_interactions"
+                ? { systemInstructionSources: googleSystemSources(request) }
+                : {}),
         };
     }
     async #responses(request, onDelta, signal) {
@@ -162,6 +188,240 @@ export class FileNativeModelHost {
             ...(signal === undefined ? {} : { signal }),
         });
     }
+    async #google(request, onDelta, signal, retainLateExtensionResponse = false, onGoogleHop, diagnosticAttempt) {
+        const controller = new AbortController();
+        const capture = providerCapture(this.#failureLog, this.#connection.provider, providerUrl(this.#connection), {
+            ...modelDiagnosticContext(request),
+            ...(diagnosticAttempt === undefined
+                ? {}
+                : { requestAttempt: diagnosticAttempt }),
+        }, JSON.stringify(googleRequestBody(this.#connection, request, true)), googleDiagnosticEndpoint(this.#connection));
+        let abort;
+        let timer;
+        try {
+            return await Promise.race([
+                this.#googleWithinDeadline(request, (delta) => {
+                    if (!controller.signal.aborted)
+                        onDelta?.(delta);
+                }, controller.signal, retainLateExtensionResponse, onGoogleHop, diagnosticAttempt, capture),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        controller.abort();
+                        if (capture !== undefined && this.#failureLog !== undefined) {
+                            void this.#failureLog
+                                .recordFailure({
+                                exchange: capture.snapshot(),
+                                failures: [
+                                    {
+                                        kind: "provider_transport",
+                                        message: "Google Interactions exceeded its total time limit",
+                                    },
+                                ],
+                            })
+                                .catch(() => {
+                                // Failure logging is best effort and cannot delay the timeout.
+                            });
+                        }
+                        reject(new ModelHostOutcomeUnknownError("Google Interactions exceeded its total time limit"));
+                    }, 60 * 60 * 1000);
+                }),
+                new Promise((_, reject) => {
+                    abort = () => {
+                        controller.abort();
+                        if (!retainLateExtensionResponse)
+                            reject(cancelledModelRequest());
+                    };
+                    if (signal?.aborted === true)
+                        abort();
+                    else
+                        signal?.addEventListener("abort", abort, { once: true });
+                }),
+            ]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (abort !== undefined)
+                signal?.removeEventListener("abort", abort);
+            controller.abort();
+        }
+    }
+    async #googleWithinDeadline(request, onDelta, signal, retainLateExtensionResponse, onGoogleHop, diagnosticAttempt, capture) {
+        const bodyJson = JSON.stringify(googleRequestBody(this.#connection, request));
+        const frozenBody = JSON.parse(bodyJson);
+        const url = providerUrl(this.#connection);
+        const preview = this.#previewRequest(request, true);
+        const evidence = [];
+        const report = (hop) => {
+            capture?.setGoogleHops(evidence);
+            const snapshot = structuredClone(hop);
+            try {
+                void Promise.resolve(onGoogleHop?.(snapshot)).catch(() => {
+                    // Optional diagnostics cannot affect the model request.
+                });
+            }
+            catch {
+                // Synchronous observers are optional diagnostics too.
+            }
+        };
+        signal.addEventListener("abort", () => {
+            const hop = evidence.at(-1);
+            if (hop?.status === "attempted") {
+                hop.status = "interrupted";
+                void report(hop);
+            }
+        }, { once: true });
+        return capturedProviderOperation(this.#failureLog, capture, async (observe) => {
+            const steps = [];
+            const usages = [];
+            const seenTokens = new Set();
+            let token;
+            let payload;
+            do {
+                if (signal.aborted)
+                    throw cancelledModelRequest();
+                const hop = {
+                    exchange: request.exchange ?? 1,
+                    attempt: diagnosticAttempt ?? request.requestAttempt ?? 1,
+                    hop: evidence.length + 1,
+                    tokenSupplied: token !== undefined,
+                    status: "attempted",
+                    ...(token === undefined ? { request: preview } : {}),
+                };
+                evidence.push(hop);
+                try {
+                    const dispatched = dispatchProviderRequest(this.#fetch, url, {
+                        method: "POST",
+                        headers: {
+                            Accept: "text/event-stream",
+                            "x-goog-api-key": this.#connection.apiKey,
+                            "Content-Type": "application/json",
+                        },
+                        redirect: "error",
+                        body: token === undefined
+                            ? bodyJson
+                            : JSON.stringify({
+                                ...frozenBody,
+                                continuation_token: token,
+                            }),
+                        ...(signal === undefined ? {} : { signal }),
+                    }, "Google Interactions");
+                    void dispatched.catch(() => {
+                        // The same rejection is classified after the diagnostic write.
+                    });
+                    void report(hop);
+                    const response = await dispatched;
+                    hop.httpStatus = response.status;
+                    observe(new Response(null, { status: response.status }));
+                    if (signal.aborted && !retainLateExtensionResponse)
+                        throw cancelledModelRequest();
+                    if (!response.ok) {
+                        hop.status = "rejected";
+                        void report(hop);
+                        if (token !== undefined) {
+                            discardGoogleErrorBody(response);
+                            throw new ModelHostOutcomeUnknownError("A later Google Interactions continuation request failed after earlier progress");
+                        }
+                        throw await googleInitialRejection(response);
+                    }
+                    if (!isProviderEventStream(response)) {
+                        discardGoogleErrorBody(response);
+                        throw unknownProviderResponse("Google Interactions");
+                    }
+                    payload = await providerStreamResult(response, "Google Interactions", (body) => aggregateGoogleInteractions(body, onDelta, (raw) => {
+                        const usage = safeGoogleUsage(raw);
+                        if (usage !== null) {
+                            hop.usage = usage;
+                            void report(hop);
+                        }
+                    }), signal);
+                    const safeUsage = safeGoogleUsage(payload.usage);
+                    if (safeUsage !== null)
+                        hop.usage = safeUsage;
+                    if ((token !== undefined ||
+                        payload.status === "requires_continuation") &&
+                        !payload.completeLifecycle)
+                        throw new ModelHostOutcomeUnknownError("Google Interactions continuation stream lifecycle is incomplete");
+                    steps.push(...payload.steps);
+                    usages.push(safeUsage);
+                    hop.status =
+                        payload.status === "completed" ||
+                            payload.status === "requires_action" ||
+                            payload.status === "requires_continuation" ||
+                            payload.status === "failed" ||
+                            payload.status === "cancelled" ||
+                            payload.status === "incomplete"
+                            ? payload.status
+                            : "interrupted";
+                    void report(hop);
+                    if (payload.status === "requires_continuation") {
+                        if (signal.aborted)
+                            throw cancelledModelRequest();
+                        if (typeof payload.continuationToken !== "string" ||
+                            !payload.continuationToken ||
+                            seenTokens.has(payload.continuationToken) ||
+                            usages.length >= 16)
+                            throw new ModelHostOutcomeUnknownError("Google Interactions continuation cannot proceed safely");
+                        token = payload.continuationToken;
+                        seenTokens.add(token);
+                    }
+                }
+                catch (error) {
+                    if (hop.status === "attempted") {
+                        hop.status = "interrupted";
+                        void report(hop);
+                    }
+                    throw error;
+                }
+            } while (payload.status === "requires_continuation");
+            payload.steps = steps;
+            if (signalWasAborted(signal) && !retainLateExtensionResponse)
+                throw cancelledModelRequest();
+            const projection = projectGoogleInteractions(payload);
+            const total = (field) => {
+                let sum = 0;
+                for (const raw of usages) {
+                    const value = isRecord(raw) ? providerNumber(raw[field]) : null;
+                    if (value === null)
+                        return null;
+                    sum += value;
+                }
+                return Number.isSafeInteger(sum) ? sum : null;
+            };
+            return {
+                ...projection,
+                usage: {
+                    ...usageRecord({
+                        inputTokens: total("total_input_tokens"),
+                        uncachedInputTokens: null,
+                        cacheReadTokens: total("total_cached_tokens"),
+                        cacheWriteTokens: null,
+                        reasoningTokens: total("total_thought_tokens"),
+                        outputTokens: total("total_output_tokens"),
+                        totalTokens: total("total_tokens"),
+                    }, usages.length > 1
+                        ? [
+                            "inputTokens",
+                            "cacheReadTokens",
+                            "reasoningTokens",
+                            "outputTokens",
+                            "totalTokens",
+                        ]
+                        : []),
+                    accounting: "google_interactions",
+                    ...(usages.length > 1
+                        ? {
+                            providerRaw: {
+                                hops: usages.map((usage) => isRecord(usage) ? structuredClone(usage) : null),
+                            },
+                        }
+                        : isRecord(usages[0])
+                            ? { providerRaw: structuredClone(usages[0]) }
+                            : {}),
+                },
+            };
+        }, true);
+    }
     async #chat(request, onDelta, signal) {
         const body = chatRequestBody(this.#connection, request);
         const bodyJson = JSON.stringify(body);
@@ -398,10 +658,16 @@ function modelDiagnosticContext(request) {
         ...(request.exchange === undefined ? {} : { exchange: request.exchange }),
     };
 }
-function providerCapture(failureLog, provider, endpoint, context, requestBody) {
+function providerCapture(failureLog, provider, endpoint, context, requestBody, endpointLabel) {
     return failureLog === undefined
         ? undefined
-        : new AiExchangeCapture({ provider, endpoint, context, requestBody });
+        : new AiExchangeCapture({
+            provider,
+            endpoint,
+            context,
+            requestBody,
+            ...(endpointLabel === undefined ? {} : { endpointLabel }),
+        });
 }
 function captureDelta(capture, downstream) {
     if (capture === undefined)
@@ -412,7 +678,7 @@ function captureDelta(capture, downstream) {
         downstream?.(delta);
     };
 }
-async function capturedProviderOperation(failureLog, capture, operation) {
+async function capturedProviderOperation(failureLog, capture, operation, sanitizeGoogleErrors = false) {
     const observeResponse = (response) => capture?.captureResponse(response) ?? response;
     try {
         const value = await operation(observeResponse);
@@ -423,26 +689,33 @@ async function capturedProviderOperation(failureLog, capture, operation) {
     catch (error) {
         if (error instanceof ModelHostCancelledError)
             throw error;
+        const reportedError = sanitizeGoogleErrors
+            ? error instanceof ModelHostFailureError
+                ? modelHostFailureRequiresFreshContext(error)
+                    ? new ModelHostFailureError("Google Interactions context limit exceeded; start a fresh context", { details: { code: "context_length_exceeded" } })
+                    : new ModelHostFailureError("Google Interactions request was rejected")
+                : new ModelHostOutcomeUnknownError("Google Interactions request outcome could not be confirmed")
+            : error;
         if (capture !== undefined && failureLog !== undefined) {
             const exchange = capture.snapshot();
             const failure = {
                 kind: exchange.response === undefined
                     ? "provider_transport"
-                    : error instanceof ModelHostFailureError
+                    : reportedError instanceof ModelHostFailureError
                         ? "provider_rejection"
                         : "provider_response_format",
-                message: error instanceof Error
-                    ? error.message
+                message: reportedError instanceof Error
+                    ? reportedError.message
                     : "Provider request processing failed.",
-                ...(error instanceof ModelHostFailureError &&
-                    error.details !== undefined
-                    ? { details: error.details }
+                ...(reportedError instanceof ModelHostFailureError &&
+                    reportedError.details !== undefined
+                    ? { details: reportedError.details }
                     : {}),
-                error: errorDescription(error),
+                error: errorDescription(reportedError),
             };
             await failureLog.recordFailure({ exchange, failures: [failure] });
         }
-        throw error;
+        throw reportedError;
     }
 }
 async function trace(kind, value) {
@@ -463,6 +736,185 @@ async function trace(kind, value) {
         // Explicit acceptance diagnostics must never change provider semantics.
     }
 }
+function googleSystemSources(request) {
+    const logical = request.bootstrap.logicalMessages.filter((message) => message.role !== "player_input" &&
+        (request.bootstrap.provider.preload === undefined ||
+            message.role !== "world_context"));
+    const ordered = logical.some((message) => message.messageRole !== undefined);
+    const firstConversation = logical.findIndex((message) => (message.messageRole ?? "system") !== "system");
+    const leading = ordered
+        ? logical.slice(0, firstConversation < 0 ? logical.length : firstConversation)
+        : logical.filter((message) => message.role === "runtime_system" ||
+            message.role === "author_instruction");
+    const sources = leading.map((message) => ({
+        ...(message.promptId === undefined ? {} : { promptId: message.promptId }),
+        sources: message.blocks.map(({ source }) => source),
+    }));
+    const current = request.worldRevisionBoundaries?.entries.findLast(({ epochId }) => epochId === request.worldRevisionBoundaries?.currentEpochId);
+    if (current !== undefined)
+        sources.push({
+            sources: [
+                `runtime:world-revision-epoch:${current.epochId}:system-boundary`,
+            ],
+        });
+    return sources;
+}
+function googleLateSystemSource(request) {
+    let conversation = false;
+    for (const message of request.bootstrap.logicalMessages) {
+        if (message.role === "player_input" ||
+            (request.bootstrap.provider.preload !== undefined &&
+                message.role === "world_context"))
+            continue;
+        if ((message.messageRole ?? "system") !== "system")
+            conversation = true;
+        else if (conversation)
+            return [message.promptId, ...message.blocks.map(({ source }) => source)]
+                .filter((item) => item !== undefined)
+                .join(", ");
+    }
+    return "";
+}
+function googleRequestBody(connection, request, redactContinuation = false) {
+    const messages = request.bootstrap.provider.messages;
+    const system = [];
+    const input = [];
+    let conversationStarted = false;
+    const text = (value) => [{ type: "text", text: value }];
+    const contentText = (value) => {
+        if (typeof value === "string")
+            return value;
+        if (Array.isArray(value) &&
+            value.every((part) => isRecord(part) &&
+                part.type === "text" &&
+                typeof part.text === "string"))
+            return value.map((part) => part.text).join("\n\n");
+        throw new Error("Google Interactions cannot encode non-text bootstrap content");
+    };
+    const preload = request.bootstrap.provider.preload;
+    const appendPreload = () => {
+        if (preload !== undefined)
+            input.push({
+                type: "user_input",
+                content: text("Runtime preload: initial world materials, not a player action or model response."),
+            }, {
+                type: "function_call",
+                id: preload.callId,
+                name: "runtime_load_context",
+                arguments: {},
+            }, {
+                type: "function_result",
+                call_id: preload.callId,
+                name: "runtime_load_context",
+                result: text(preload.markdown),
+            });
+    };
+    for (const [index, message] of messages.entries()) {
+        if (index === bootstrapPrefixEnd(request))
+            appendPreload();
+        if (message.role === "system") {
+            if (conversationStarted)
+                throw new Error(`Google Interactions cannot encode System message ${index + 1} after User/Assistant${googleLateSystemSource(request) ? `: ${googleLateSystemSource(request)}` : ""}`);
+            system.push(contentText(message.content));
+        }
+        else {
+            conversationStarted = true;
+            input.push({
+                type: message.role === "user" ? "user_input" : "model_output",
+                content: text(contentText(message.content)),
+            });
+        }
+    }
+    if (bootstrapPrefixEnd(request) === messages.length)
+        appendPreload();
+    const calls = new Map();
+    const boundaries = request.worldRevisionBoundaries;
+    const currentBoundary = boundaries?.entries.findLast(({ epochId }) => epochId === boundaries.currentEpochId);
+    if (currentBoundary !== undefined)
+        system.push(`# Runtime world-revision epoch boundary\n\nThe current epoch is ${currentBoundary.epochId}, based on ${currentBoundary.baseHead}. All prior search cursors and read authorizations are invalid. Re-read before writing, except for materials legitimately preloaded in the current revision.`);
+    for (const [itemIndex, item] of request.appended.entries()) {
+        if (item.kind === "assistant") {
+            if (item.providerState?.protocol !== "google_interactions" ||
+                !validGoogleInteractionsContinuation(item.providerState.steps))
+                throw continuationError("Google Interactions");
+            for (const step of item.providerState.steps) {
+                if (isRecord(step) &&
+                    step.type === "function_call" &&
+                    typeof step.id === "string" &&
+                    typeof step.name === "string")
+                    calls.set(step.id, step.name);
+            }
+            input.push(...(redactContinuation
+                ? item.providerState.steps.map(() => ({
+                    type: "runtime_redacted_provider_step",
+                }))
+                : cloneProviderValue(item.providerState.steps)));
+        }
+        else if (item.kind === "tool") {
+            const name = calls.get(item.toolCallId);
+            if (name === undefined)
+                throw continuationError("Google Interactions tool result");
+            input.push({
+                type: "function_result",
+                name,
+                call_id: item.toolCallId,
+                result: text(item.markdown),
+                ...(item.isError === true ? { is_error: true } : {}),
+            });
+        }
+        else if (item.kind === "prompt_delta") {
+            const boundary = boundaries?.entries.find((entry) => entry.itemIndex === itemIndex);
+            if (boundary !== undefined) {
+                const message = item.logicalMessages[0];
+                if (item.logicalMessages.length !== 1 ||
+                    message?.role !== "runtime_system" ||
+                    message.markdown !== boundary.markdown ||
+                    message.blocks.length !== 1 ||
+                    message.blocks[0]?.source !==
+                        `runtime:world-revision-epoch:${boundary.epochId}` ||
+                    message.blocks[0]?.markdown !== boundary.markdown)
+                    throw new Error("Invalid Runtime world-revision epoch boundary");
+                input.push({
+                    type: "user_input",
+                    content: text(`# Runtime notice: world-revision epoch transition\n\n${boundary.markdown}`),
+                });
+                continue;
+            }
+            for (const message of item.logicalMessages)
+                input.push({
+                    type: "user_input",
+                    content: text(renderPromptDeltaMessage(message.role, message.markdown)),
+                });
+        }
+        else
+            input.push({ type: "user_input", content: text(item.text) });
+    }
+    const tools = providerToolDefinitions(request);
+    return {
+        model: connection.modelId,
+        store: false,
+        stream: true,
+        ...(system.length === 0 ? {} : { system_instruction: system.join("\n\n") }),
+        input,
+        ...(tools.length === 0
+            ? {}
+            : {
+                tools: tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema,
+                })),
+            }),
+        generation_config: {
+            max_output_tokens: request.maxOutputTokens,
+            ...(hasFrozenToolPolicy(request) &&
+                providerAllowedTools(request).length === 0
+                ? { tool_choice: "none" }
+                : {}),
+        },
+    };
+}
 function chatRequestBody(connection, request) {
     const tools = providerToolDefinitions(request);
     const allowedTools = providerAllowedTools(request);
@@ -1018,11 +1470,133 @@ function providerUrl(connection) {
         ? "/chat/completions"
         : connection.provider === "openai_responses"
             ? "/responses"
-            : "/messages";
+            : connection.provider === "google_interactions"
+                ? "/interactions"
+                : "/messages";
     const path = url.pathname.replace(/\/+$/u, "");
     url.pathname = path.endsWith(suffix) ? path : `${path}${suffix}`;
     return url;
 }
+function googleDiagnosticPath(connection) {
+    const url = providerUrl(connection);
+    return containsGoogleCredential(url.pathname, connection.apiKey)
+        ? ""
+        : url.pathname;
+}
+function googleDiagnosticEndpoint(connection) {
+    const url = providerUrl(connection);
+    const endpoint = `${url.protocol}//${url.host}${googleDiagnosticPath(connection)}`;
+    return containsGoogleCredential(endpoint, connection.apiKey) ? "" : endpoint;
+}
+function containsGoogleCredential(value, key) {
+    if (key === "")
+        return false;
+    const needle = key.toLowerCase();
+    let current = value;
+    for (let depth = 0; depth < 3; depth++) {
+        if (current.toLowerCase().includes(needle) ||
+            current.toLowerCase().includes(encodeURIComponent(key).toLowerCase()))
+            return true;
+        try {
+            const decoded = decodeURIComponent(current);
+            if (decoded === current)
+                break;
+            current = decoded;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+}
+/** Classify a first-hop rejection in memory; never retain the provider's echo. */
+async function googleInitialRejection(response) {
+    if (![400, 401, 403, 404, 405, 413, 415, 422, 429].includes(response.status)) {
+        discardGoogleErrorBody(response);
+        return new ModelHostOutcomeUnknownError("Google Interactions request outcome could not be confirmed");
+    }
+    let body = "";
+    if (response.body !== null) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        let complete = false;
+        let bytes = 0;
+        try {
+            for (;;) {
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    complete = true;
+                    body += decoder.decode();
+                    break;
+                }
+                bytes += chunk.value.byteLength;
+                if (bytes > 64 * 1024)
+                    break;
+                body += decoder.decode(chunk.value, { stream: true });
+            }
+        }
+        catch {
+            return new ModelHostOutcomeUnknownError("Google Interactions request outcome could not be confirmed");
+        }
+        finally {
+            if (!complete)
+                void reader.cancel().catch(() => undefined);
+            reader.releaseLock();
+        }
+        if (!complete)
+            return new ModelHostOutcomeUnknownError("Google Interactions request outcome could not be confirmed");
+    }
+    const contentType = response.headers
+        .get("content-type")
+        ?.split(";", 1)[0]
+        ?.trim()
+        .toLowerCase();
+    const evidence = googleRejectionEvidence(body, contentType === "application/json" ||
+        contentType?.endsWith("+json") === true);
+    if (evidence === null)
+        return new ModelHostOutcomeUnknownError("Google Interactions request outcome could not be confirmed");
+    return modelHostFailureRequiresFreshContext(new ModelHostFailureError(evidence))
+        ? new ModelHostFailureError("Google Interactions context limit exceeded; start a fresh context", { details: { code: "context_length_exceeded" } })
+        : new ModelHostFailureError("Google Interactions request was rejected");
+}
+function discardGoogleErrorBody(response) {
+    try {
+        void response.body?.cancel().catch(() => undefined);
+    }
+    catch {
+        // Discarding an optional error body must not alter the request outcome.
+    }
+}
+function googleRejectionEvidence(body, requireJson) {
+    if (body.trim() === "")
+        return null;
+    try {
+        const payload = JSON.parse(body);
+        if (typeof payload === "string")
+            return payload.trim() === "" ? null : payload;
+        if (!isRecord(payload))
+            return null;
+        const error = isRecord(payload.error) ? payload.error : {};
+        const evidence = [
+            error.message,
+            error.code,
+            error.reason,
+            payload.message,
+            payload.code,
+            payload.error,
+        ]
+            .filter((value) => typeof value === "string")
+            .join("\n");
+        return evidence.trim() === "" ? null : evidence;
+    }
+    catch {
+        // An unstructured error may itself be the Provider's rejection message.
+        const trimmed = body.trimStart();
+        return requireJson || trimmed.startsWith("{") || trimmed.startsWith("[")
+            ? null
+            : body;
+    }
+}
 function parseArguments(value) {
     try {
         return JSON.parse(value);
@@ -1337,6 +1911,24 @@ function normalizeResponsesUsage(value) {
         totalTokens: providerNumber(usage.total_tokens),
     }, ["uncachedInputTokens"]);
 }
+function safeGoogleUsage(value) {
+    if (!isRecord(value))
+        return null;
+    const result = {};
+    for (const field of [
+        "total_input_tokens",
+        "total_cached_tokens",
+        "total_thought_tokens",
+        "total_output_tokens",
+        "total_tool_use_tokens",
+        "total_tokens",
+    ]) {
+        const count = value[field];
+        if (typeof count === "number" && Number.isSafeInteger(count) && count >= 0)
+            result[field] = count;
+    }
+    return result;
+}
 function providerNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0
         ? value