@opencode/ai 2.0.26 → 2.0.28

package/README.md

@@ -32,6 +32,11 @@ Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployme
 `Google.configure({ apiKey }).interactions(modelID)` selects the Interactions API; `.model(modelID)` still selects
 GenerateContent. The package entrypoint is `@opencode/ai/providers/google/interactions`.
 
+For Vertex AI, use `GoogleVertexInteractions.configure({ project, location: "global" }).model(modelID)` or
+`@opencode/ai/providers/google-vertex/interactions`. It uses Application Default Credentials by default, accepts
+an explicit `accessToken` or `auth` override, and supports Express mode with `apiKey`. Vertex metadata and raw usage
+live under `providerMetadata.vertex`. The default is still full-history replay with `store: false`.
+
 ```ts
 const model = Google.configure({ apiKey }).interactions("gemini-3.8-flash")
 const response = yield* LLM.generate({
@@ -177,7 +182,7 @@ console.log(response.answers.department.choice)
 console.log(response.answers.refund.probability)
 ```
 
-`TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCodeZen` exposes the same selector and reads
+`TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCode` exposes the same selector and reads
 `OPENCODE_API_KEY`. OpenRouter and Vercel AI Gateway use the same provider shape:
 
 ```ts
@@ -1316,13 +1321,14 @@ APIs have separate entrypoints:
 - `@opencode/ai/providers/openai-compatible/responses`
 - `@opencode/ai/providers/anthropic-compatible`
 - `@opencode/ai/providers/google-vertex/gemini`
+- `@opencode/ai/providers/google-vertex/interactions`
 - `@opencode/ai/providers/google-vertex/chat`
 - `@opencode/ai/providers/google-vertex/responses`
 - `@opencode/ai/providers/google-vertex/messages`
 
 OpenAI Responses has one semantic route and uses HTTP by default. Advanced callers may supply a per-call WebSocket channel executor through `StreamOptions`; transport policy does not change provider settings, model identity, or route identity. The provider-neutral Open Responses implementation owns the reusable WebSocket request and event contract, while each provider opts in with its own handshake and connection policy. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Generic OpenAI-compatible Chat remains at `providers/openai-compatible`; the Responses adapter at `providers/openai-compatible/responses` uses the provider-neutral Open Responses protocol. OpenAI Responses extends that baseline with OpenAI tools, event variants, metadata, and defaults. Generic Anthropic Messages-compatible providers use `providers/anthropic-compatible`, which the named Anthropic provider composes. Google Gemini and Amazon Bedrock expose their single native API through their existing provider paths.
 
-Vertex Gemini, Vertex Chat, Vertex Responses, and Vertex Messages are separate API entrypoints. All accept `project`, `location`, and an optional `accessToken`; when no explicit token or auth override is supplied they lazily use Google Application Default Credentials. Vertex Gemini instead selects express mode when `apiKey` or `GOOGLE_VERTEX_API_KEY` is present. Vertex Chat targets MaaS models through the OpenAI-compatible Chat Completions endpoint, while Vertex Responses targets Grok models and defaults `store` to `false` as required by Vertex. `providers/google-vertex` remains the default alias for `providers/google-vertex/gemini`.
+Vertex Gemini, Vertex Interactions, Vertex Chat, Vertex Responses, and Vertex Messages are separate API entrypoints. All accept `project`, `location`, and an optional `accessToken`; when no explicit token or auth override is supplied they lazily use Google Application Default Credentials. Vertex Gemini and Interactions instead select express mode when `apiKey` or `GOOGLE_VERTEX_API_KEY` is present (explicit `project` or `location` selects ADC over an ambient key). Vertex Chat targets MaaS models through the OpenAI-compatible Chat Completions endpoint, while Vertex Responses targets Grok models and defaults `store` to `false` as required by Vertex. `providers/google-vertex` remains the default alias for `providers/google-vertex/gemini`.
 
 Tuned Vertex Gemini deployments use model ids shaped like `endpoints/1234567890` and require OAuth or ADC; Vertex express-mode API keys support publisher models only.
 

package/dist/cache-policy.js

@@ -143,17 +143,7 @@ const countHints = (request) => countToolHints(request.tools) +
     request.messages.reduce((count, message) => count +
         message.content.reduce((contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0), 0), 0);
 export const applyCachePolicy = (request) => {
-    const route = request.model.route.id;
-    if (!RESPECTS_INLINE_HINTS.has(route))
-        return request;
-    const policy = (route === "openrouter" || route === "vercel-ai-gateway-messages") &&
-        (request.cache === undefined || request.cache === "auto")
-        ? gatewayPolicy(request.model.id)
-        : route === "alibaba-chat" && (request.cache === undefined || request.cache === "auto")
-            ? request.model.id.toLowerCase().startsWith("qwen")
-                ? QWEN
-                : NONE
-            : resolve(request.cache);
+    const policy = selectPolicy(request);
     if (!policy.tools && !policy.system && !policy.messages)
         return request;
     const hint = makeHint(policy.ttlSeconds);
@@ -165,3 +155,22 @@ export const applyCachePolicy = (request) => {
         return request;
     return LLMRequest.update(request, { tools, system, messages });
 };
+// A declared cache format overrides the route allowlist and its model-ID heuristics.
+const selectPolicy = (request) => {
+    const format = request.model.compatibility?.cacheFormat;
+    const route = request.model.route.id;
+    const auto = request.cache === undefined || request.cache === "auto";
+    if (format === "alibaba")
+        return auto ? QWEN : { ...resolve(request.cache), tools: false };
+    if (format === "anthropic")
+        return resolve(request.cache);
+    if (!RESPECTS_INLINE_HINTS.has(route))
+        return NONE;
+    if (!auto)
+        return resolve(request.cache);
+    if (route === "openrouter" || route === "vercel-ai-gateway-messages")
+        return gatewayPolicy(request.model.id);
+    if (route === "alibaba-chat")
+        return request.model.id.toLowerCase().startsWith("qwen") ? QWEN : NONE;
+    return AUTO;
+};

package/dist/experimental/system-one.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest } from "effect/http";
 import { ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreQuestion, } from "./evaluation.js";
 import { Auth } from "../route/auth.js";
 import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";

package/dist/media.d.ts

@@ -100,12 +100,12 @@ export declare class Asset {
         };
         info: {
             readonly format?: string | undefined;
+            readonly encoding?: string | undefined;
             readonly width?: number | undefined;
             readonly height?: number | undefined;
             readonly durationSeconds?: number | undefined;
             readonly sampleRate?: number | undefined;
             readonly channels?: number | undefined;
-            readonly encoding?: string | undefined;
         } | undefined;
         providerMetadata: {
             readonly [x: string]: {

package/dist/media.js

@@ -1,6 +1,7 @@
 export * as Media from "./media.js";
-import { Effect, Encoding, FileSystem, Schema, SchemaGetter } from "effect";
-import { HttpClientRequest } from "effect/unstable/http";
+import { Effect, FileSystem, Schema, SchemaGetter } from "effect";
+import { Base64 } from "effect/encoding";
+import { HttpClientRequest } from "effect/http";
 import { ProviderID } from "./schema/ids.js";
 import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
 import { ProviderMetadata } from "./schema/options.js";
@@ -105,7 +106,7 @@ export class Asset {
         const source = this.source;
         if (source.type !== "bytes" && source.type !== "base64")
             return undefined;
-        const base64 = source.type === "base64" ? source.data : (this.#base64 ??= Encoding.encodeBase64(source.data));
+        const base64 = source.type === "base64" ? source.data : (this.#base64 ??= Base64.encode(source.data));
         const mime = this.mediaType.toLowerCase();
         return { mime, base64, dataUrl: `data:${mime};base64,${base64}` };
     }
@@ -120,7 +121,7 @@ export class Asset {
             if (source.type === "ref")
                 return Effect.fail(invalid(`Cannot materialize provider ref ${source.provider}:${source.id}`));
             const decoded = source.type === "base64"
-                ? Effect.fromResult(Encoding.decodeBase64(source.data)).pipe(Effect.mapError((cause) => invalid(`Media asset contains invalid base64 data`, cause)))
+                ? Effect.fromResult(Base64.decode(source.data)).pipe(Effect.mapError((cause) => invalid(`Media asset contains invalid base64 data`, cause)))
                 : download(source, this.headers);
             return decoded.pipe(Effect.tap((data) => Effect.sync(() => (this.#bytes = data))));
         });
@@ -132,7 +133,7 @@ export class Asset {
                 return Effect.succeed(source.data);
             if (this.#base64 !== undefined)
                 return Effect.succeed(this.#base64);
-            return this.bytes().pipe(Effect.map((data) => (this.#base64 = Encoding.encodeBase64(data))));
+            return this.bytes().pipe(Effect.map((data) => (this.#base64 = Base64.encode(data))));
         });
     }
     dataUrl() {
@@ -145,7 +146,7 @@ export class Asset {
     toJSON() {
         const source = this.source;
         return {
-            source: source.type === "bytes" ? { ...source, data: Encoding.encodeBase64(source.data) } : source,
+            source: source.type === "bytes" ? { ...source, data: Base64.encode(source.data) } : source,
             info: this.info,
             providerMetadata: this.providerMetadata,
         };

package/dist/protocols/alibaba-chat.d.ts

@@ -10,7 +10,7 @@ declare const Options: Schema.Struct<{
     readonly preserveThinking: Schema.optional<Schema.Boolean>;
     readonly clearThinking: Schema.optional<Schema.Boolean>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"disabled" | (string & {}) | "adaptive", "disabled" | (string & {}) | "adaptive">;
+        readonly type: Schema.declare<(string & {}) | "disabled" | "adaptive", (string & {}) | "disabled" | "adaptive">;
     }>>;
     readonly toolStream: Schema.optional<Schema.Boolean>;
     readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
@@ -140,7 +140,7 @@ export declare const protocol: Protocol<{
     readonly temperature?: number | undefined;
     readonly seed?: number | undefined;
     readonly thinking?: {
-        readonly type: "disabled" | (string & {}) | "adaptive";
+        readonly type: (string & {}) | "disabled" | "adaptive";
     } | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";

package/dist/protocols/alibaba-messages.d.ts

@@ -5,7 +5,7 @@ import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 declare const Options: Schema.Struct<{
     readonly effort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"enabled" | "disabled" | (string & {}), "enabled" | "disabled" | (string & {})>;
+        readonly type: Schema.declare<(string & {}) | "enabled" | "disabled", (string & {}) | "enabled" | "disabled">;
         readonly budgetTokens: Schema.optional<Schema.Int>;
         readonly budget_tokens: Schema.optional<Schema.Int>;
     }>>;

package/dist/protocols/anthropic-messages.js

@@ -6,7 +6,7 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 import { HttpTransport } from "../route/transport/index.js";
 import { AIError, HttpOptions, LLMRequest, LLMEvent, mergeJsonRecords, Usage, } from "../schema/index.js";
 import { JsonObject, knownString, optionalArray, optionalNull, ProviderShared } from "./shared.js";

package/dist/protocols/bedrock-converse.js

@@ -1,4 +1,5 @@
-import { Effect, Encoding, Schema } from "effect";
+import { Effect, Schema } from "effect";
+import { Base64 } from "effect/encoding";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
@@ -489,7 +490,7 @@ const mapUsage = (usage, providerMetadataKey) => {
         providerMetadata: { [providerMetadataKey]: usage },
     });
 };
-const encodeRedactedContent = (chunks) => Encoding.encodeBase64(concatBytes(chunks));
+const encodeRedactedContent = (chunks) => Base64.encode(concatBytes(chunks));
 const step = (state, event) => Effect.gen(function* () {
     if (event.contentBlockStart?.start?.toolUse) {
         const index = event.contentBlockStart.contentBlockIndex;
@@ -530,7 +531,7 @@ const step = (state, event) => Effect.gen(function* () {
         const redactedChunk = yield* (() => {
             if (reasoning.redactedContent === undefined)
                 return Effect.succeed(undefined);
-            return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
+            return Effect.fromResult(Base64.decode(reasoning.redactedContent)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
         })();
         const redactedChunks = state.reasoningRedactedContent[index] ?? [];
         if (redactedChunk !== undefined)

package/dist/protocols/bedrock-event-stream.js

@@ -1,6 +1,7 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
-import { Effect, Encoding, Stream } from "effect";
+import { Effect, Stream } from "effect";
+import { Base64 } from "effect/encoding";
 import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js";
 import { Framing } from "../route/framing.js";
 import { ProviderShared } from "./shared.js";
@@ -31,7 +32,7 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
                     route,
                     classification: "incomplete-stream",
                     message: `Incomplete Bedrock Converse event-stream frame: ${remaining.length} buffered bytes remain at end of stream`,
-                    body: Encoding.encodeBase64(remaining),
+                    body: Base64.encode(remaining),
                 }),
             });
         return [state, []];
@@ -45,7 +46,7 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
             break;
         const decoded = yield* Effect.try({
             try: () => eventCodec.decode(view.subarray(0, totalLength)),
-            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`, Encoding.encodeBase64(view.subarray(0, totalLength)), error),
+            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`, Base64.encode(view.subarray(0, totalLength)), error),
         });
         cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength };
         const payload = utf8.decode(decoded.body);

package/dist/protocols/gemini.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
+import { HttpTransport, type Transport, type TransportPrepareInput } from "../route/transport/index.js";
 import { type ProviderOptions } from "../schema/index.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
@@ -100,8 +101,54 @@ declare const GeminiBody: Schema.Struct<{
             readonly thinkingLevel: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">, import("../schema/options.js").OpenString<"minimal" | "low" | "medium" | "high">>>;
         }>>;
     }>>;
+    continuationToken: Schema.optional<Schema.String>;
 }>;
 export type GeminiBody = Schema.Schema.Type<typeof GeminiBody>;
+declare const GeminiUsage: Schema.Struct<{
+    readonly cachedContentTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly thoughtsTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly promptTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly candidatesTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly totalTokenCount: Schema.optional<Schema.NullOr<Schema.Number>>;
+}>;
+type GeminiUsage = Schema.Schema.Type<typeof GeminiUsage>;
+declare const GeminiPromptFeedback: Schema.StructWithRest<Schema.Struct<{
+    readonly blockReason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly blockReasonMessage: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly safetyRatings: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>;
+interface ParserState {
+    readonly route: string;
+    readonly providerMetadataKey: string;
+    readonly finishReason?: string;
+    readonly hasToolCalls: boolean;
+    readonly promptFeedback?: GeminiPromptFeedback;
+    readonly usage?: GeminiUsage;
+    /** Usage of the earlier requests of a response Gemini continued across requests. */
+    readonly continuedUsage?: ReadonlyArray<GeminiUsage>;
+    readonly lifecycle: Lifecycle.State;
+    readonly reasoningSignature?: string;
+    readonly textSignature?: string;
+    readonly reasoningId?: string;
+    readonly textId?: string;
+    readonly nextReasoningId: number;
+    readonly nextTextId: number;
+    readonly seenCallIds?: ReadonlySet<string>;
+}
+/** Marks where the transport starts another request for the same response; provider JSON can never match it. */
+declare class NextRequest {
+}
+export interface Prepared {
+    readonly http: HttpTransport.HttpPrepared<string>;
+    readonly input: TransportPrepareInput<GeminiBody>;
+}
+/**
+ * SSE transport that continues responses Gemini splits across requests. Chunks carry `continuationToken` checkpoints,
+ * and a request that reaches its output cap finishes with `CONTINUATION`. The transport resends the original body with
+ * the latest token, which also resumes a request that ended or dropped before finishing.
+ */
+export declare const transport: Transport<GeminiBody, Prepared, unknown>;
 /**
  * The Gemini protocol — request body construction, body schema, and the
  * streaming-event state machine shared by Google AI Studio and Vertex Gemini.
@@ -190,7 +237,8 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, string, {
+    readonly continuationToken?: string | undefined;
+}, NextRequest | {
     readonly error?: unknown;
     readonly candidates?: readonly {
         readonly content?: {
@@ -213,13 +261,28 @@ export declare const protocol: Protocol<{
         readonly thoughtsTokenCount?: number | null | undefined;
     } | null | undefined;
 }, {
-    route: string;
-    providerMetadataKey: string;
-    hasToolCalls: boolean;
-    lifecycle: Lifecycle.State;
-    nextReasoningId: number;
-    nextTextId: number;
-}>;
+    readonly error?: unknown;
+    readonly candidates?: readonly {
+        readonly content?: {
+            readonly parts?: readonly unknown[] | null | undefined;
+            readonly role?: "model" | "user" | null | undefined;
+        } | null | undefined;
+        readonly finishReason?: string | null | undefined;
+    }[] | null | undefined;
+    readonly promptFeedback?: {
+        readonly [x: string]: unknown;
+        readonly blockReason?: string | null | undefined;
+        readonly blockReasonMessage?: string | null | undefined;
+        readonly safetyRatings?: unknown;
+    } | null | undefined;
+    readonly usageMetadata?: {
+        readonly promptTokenCount?: number | null | undefined;
+        readonly candidatesTokenCount?: number | null | undefined;
+        readonly totalTokenCount?: number | null | undefined;
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
+    } | null | undefined;
+} | NextRequest, ParserState>;
 export declare const route: Route<{
     readonly contents: readonly {
         readonly parts?: readonly ({
@@ -304,5 +367,6 @@ export declare const route: Route<{
         } | undefined;
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
-}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>;
+    readonly continuationToken?: string | undefined;
+}, Prepared, import("../route/client.js").CompactionOperations | undefined>;
 export * as Gemini from "./gemini.js";

package/dist/protocols/gemini.js

@@ -1,10 +1,10 @@
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Schema, Stream } from "effect";
 import { Tool } from "@opencode/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
+import { HttpTransport, } from "../route/transport/index.js";
 import { AIError, LLMEvent, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { Media } from "../media.js";
@@ -12,6 +12,7 @@ import { JsonObject, knownString, lenient, optionalArray, optionalNull, Provider
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 const ADAPTER = "gemini";
+const CONTINUATION = "CONTINUATION";
 // Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
 const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
 // Gemini 2.5 rejects a budget under the model's minimum: 512 on Flash-Lite, the highest, and 128 on Pro.
@@ -162,6 +163,7 @@ const GeminiBodyFields = {
     tools: optionalArray(GeminiTool),
     toolConfig: Schema.optional(GeminiToolConfig),
     generationConfig: Schema.optional(GeminiGenerationConfig),
+    continuationToken: Schema.optional(Schema.String),
 };
 const GeminiBody = Schema.Struct(GeminiBodyFields);
 const GeminiUsage = Schema.Struct({
@@ -403,7 +405,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
 // `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
 // of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
 // to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage, metadataKey) => {
+const mapUsage = (usage, metadataKey, metadata = usage ?? {}) => {
     if (!usage)
         return undefined;
     // Explicit provider nulls decode as `null`; normalize to `undefined` so the
@@ -425,7 +427,26 @@ const mapUsage = (usage, metadataKey) => {
         cacheReadInputTokens: cached,
         reasoningTokens: thoughts,
         totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
-        providerMetadata: providerMetadata(metadataKey, usage),
+        providerMetadata: providerMetadata(metadataKey, metadata),
+    });
+};
+// Each continued request re-bills the output so far as input. Reporting the first request's input with all output keeps
+// input plus output equal to the response's final context size, under-reporting billed input; the summed billed counts
+// remain in provider metadata.
+const mapContinuedUsage = (requests, metadataKey) => {
+    const sum = (field) => ProviderShared.sumTokens(...requests.map((usage) => usage[field] ?? undefined));
+    return mapUsage({
+        promptTokenCount: requests[0].promptTokenCount,
+        cachedContentTokenCount: requests[0].cachedContentTokenCount,
+        candidatesTokenCount: sum("candidatesTokenCount"),
+        thoughtsTokenCount: sum("thoughtsTokenCount"),
+    }, metadataKey, {
+        promptTokenCount: sum("promptTokenCount"),
+        cachedContentTokenCount: sum("cachedContentTokenCount"),
+        candidatesTokenCount: sum("candidatesTokenCount"),
+        thoughtsTokenCount: sum("thoughtsTokenCount"),
+        totalTokenCount: sum("totalTokenCount"),
+        requests: requests.length,
     });
 };
 const mapFinishReason = (finishReason, hasToolCalls) => {
@@ -451,7 +472,7 @@ const finish = (state) => {
     // the "nothing to finish" check below keeps its meaning.
     const promptBlockReason = state.finishReason === undefined ? (state.promptFeedback?.blockReason ?? undefined) : undefined;
     const finishReason = state.finishReason ?? promptBlockReason;
-    if (finishReason === undefined && state.usage === undefined)
+    if (finishReason === undefined && state.usage === undefined && state.continuedUsage === undefined)
         return [];
     const events = [];
     let lifecycle = state.lifecycle;
@@ -468,7 +489,9 @@ const finish = (state) => {
             normalized: promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
             raw: finishReason,
         },
-        usage: state.usage,
+        usage: state.continuedUsage === undefined
+            ? mapUsage(state.usage, state.providerMetadataKey)
+            : mapContinuedUsage([...state.continuedUsage, state.usage ?? {}], state.providerMetadataKey),
         providerMetadata: state.promptFeedback === undefined
             ? undefined
             : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
@@ -476,6 +499,18 @@ const finish = (state) => {
     return events;
 };
 const step = (state, event) => {
+    // Usage is cumulative within one request, so the next request of the same response counts from zero.
+    if (event instanceof NextRequest)
+        return Effect.succeed([
+            {
+                ...state,
+                finishReason: undefined,
+                promptFeedback: undefined,
+                usage: undefined,
+                continuedUsage: [...(state.continuedUsage ?? []), state.usage ?? {}],
+            },
+            [],
+        ]);
     if (ProviderShared.isRecord(event.error)) {
         const body = ProviderShared.encodeJson(event);
         return Effect.fail(new AIError({
@@ -492,21 +527,17 @@ const step = (state, event) => {
     }
     if ("error" in event)
         return Effect.fail(ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)));
+    const candidate = event.candidates?.[0];
     const nextState = {
         ...state,
         promptFeedback: event.promptFeedback ?? state.promptFeedback,
-        usage: event.usageMetadata
-            ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
-            : state.usage,
+        usage: event.usageMetadata ?? state.usage,
+        finishReason: candidate?.finishReason ?? state.finishReason,
     };
-    const candidate = event.candidates?.[0];
     if (candidate?.finishReason && mapFinishReason(candidate.finishReason, state.hasToolCalls) === "error")
         return Effect.fail(ProviderShared.eventError(state.route, `Gemini stopped with ${candidate.finishReason}`, ProviderShared.encodeJson(event)));
     if (!candidate?.content)
-        return Effect.succeed([
-            { ...nextState, finishReason: candidate?.finishReason ?? nextState.finishReason },
-            [],
-        ]);
+        return Effect.succeed([nextState, []]);
     const events = [];
     let hasToolCalls = nextState.hasToolCalls;
     let lifecycle = nextState.lifecycle;
@@ -625,12 +656,75 @@ const step = (state, event) => {
             nextReasoningId,
             nextTextId,
             seenCallIds,
-            finishReason: candidate.finishReason ?? nextState.finishReason,
         },
         events,
     ]);
 };
 // =============================================================================
+// Transport
+// =============================================================================
+const GeminiCheckpoint = Schema.Struct({
+    candidates: optionalNull(Schema.Array(Schema.Struct({
+        finishReason: optionalNull(Schema.String),
+        continuationToken: optionalNull(Schema.String),
+    }))),
+});
+const decodeCheckpoint = Schema.decodeUnknownOption(GeminiCheckpoint);
+/** Marks where the transport starts another request for the same response; provider JSON can never match it. */
+class NextRequest {
+}
+const sse = HttpTransport.sseJson.with();
+/**
+ * SSE transport that continues responses Gemini splits across requests. Chunks carry `continuationToken` checkpoints,
+ * and a request that reaches its output cap finishes with `CONTINUATION`. The transport resends the original body with
+ * the latest token, which also resumes a request that ended or dropped before finishing.
+ */
+export const transport = {
+    id: sse.id,
+    prepare: (input) => sse.prepare(input).pipe(Effect.map((http) => ({ http, input }))),
+    execute: (prepared, request, runtime) => Effect.gen(function* () {
+        const route = request.model.route.id;
+        const label = `${request.model.provider}/${route}`;
+        // Frames are parsed once here, so errors recover each frame's raw text for their body.
+        const raw = new WeakMap();
+        const respond = (execution) => Stream.suspend(() => {
+            let token;
+            let finishReason;
+            let dropped;
+            return execution.frames.pipe(Stream.mapEffect((frame) => ProviderShared.parseJson(route, frame, `Invalid ${label} stream event`).pipe(Effect.map((event) => {
+                if (typeof event === "object" && event !== null)
+                    raw.set(event, frame);
+                const candidate = Option.getOrUndefined(decodeCheckpoint(event))?.candidates?.[0];
+                token = candidate?.continuationToken ?? (candidate?.finishReason ? undefined : token);
+                finishReason = candidate?.finishReason ?? finishReason;
+                return event;
+            }))), Stream.catchIf(
+            // A connection failure may resume; a timeout keeps its meaning and ends the response.
+            (error) => error.reason._tag === "Transport" && error.reason.code !== "Timeout", (error) => {
+                dropped = error;
+                return Stream.empty;
+            }), Stream.concat(Stream.suspend(() => {
+                if (token !== undefined && (finishReason === undefined || finishReason === CONTINUATION))
+                    return Stream.concat(Stream.succeed(new NextRequest()), next(token));
+                if (dropped)
+                    return Stream.fail(dropped);
+                if (finishReason === CONTINUATION)
+                    return Stream.fail(ProviderShared.eventError(label, "Gemini continued the response without a token"));
+                return Stream.empty;
+            })));
+        });
+        const next = (continuationToken) => Stream.unwrap(sse
+            .prepare({ ...prepared.input, body: { ...prepared.input.body, continuationToken } })
+            .pipe(Effect.flatMap((continued) => sse.execute(continued, request, runtime)), Effect.map(respond)));
+        const first = yield* sse.execute(prepared.http, request, runtime);
+        return {
+            frames: respond(first),
+            http: first.http,
+            body: (frame) => (typeof frame === "object" && frame !== null ? raw.get(frame) : undefined),
+        };
+    }),
+};
+// =============================================================================
 // Protocol And Gemini Route
 // =============================================================================
 /**
@@ -646,7 +740,7 @@ export const protocol = Protocol.make({
     // Gemini's schema rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
     sanitizer: "gemini",
     stream: {
-        event: Protocol.jsonEvent(GeminiEvent),
+        event: Schema.Union([Schema.instanceOf(NextRequest), GeminiEvent]),
         initial: (request) => ({
             route: `${request.model.provider}/${request.model.route.id}`,
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
@@ -669,6 +763,6 @@ export const route = Route.make({
         baseURL: DEFAULT_BASE_URL,
     }),
     auth: Auth.none,
-    framing: Framing.sse,
+    transport,
 });
 export * as Gemini from "./gemini.js";

package/dist/protocols/meta-responses.js

@@ -1,4 +1,5 @@
-import { Effect, Encoding, Schema } from "effect";
+import { Effect, Schema } from "effect";
+import { Base64 } from "effect/encoding";
 import { Protocol } from "../route/protocol.js";
 import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.js";
 import { OpenResponses } from "./open-responses.js";
@@ -80,7 +81,7 @@ const HOSTED_TOOLS = {
                 return { type: "error", value: item.error };
             if (!item.result)
                 return yield* ProviderShared.eventError(ADAPTER, "Meta returned an image without data", ProviderShared.encodeJson(raw));
-            const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid image base64", ProviderShared.encodeJson(raw), cause)));
+            const data = yield* Effect.fromResult(Base64.decode(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid image base64", ProviderShared.encodeJson(raw), cause)));
             // Responses image items can omit output_format, including when PNG/JPEG was requested.
             const mime = item.output_format === undefined
                 ? (detectMediaType(data) ?? "application/octet-stream")

package/dist/protocols/mistral-chat.d.ts

@@ -32,7 +32,7 @@ export type ProviderOptionsInput = {
     readonly promptCacheKey?: string;
     readonly [key: string]: unknown;
 };
-declare const MistralBody: Schema.Struct<{
+export declare const MistralBody: Schema.Struct<{
     readonly model: Schema.String;
     readonly messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
         readonly role: Schema.Literal<"system">;

package/dist/protocols/mistral-chat.js

@@ -78,7 +78,7 @@ const MistralOptions = Schema.Struct({
     promptMode: Schema.optional(Schema.Literal("reasoning")),
     promptCacheKey: Schema.optional(Schema.String),
 });
-const MistralBody = Schema.Struct({
+export const MistralBody = Schema.Struct({
     model: Schema.String,
     messages: Schema.Array(MistralMessage),
     tools: optionalArray(MistralTool),
@@ -317,7 +317,9 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         frequency_penalty: request.generation?.frequencyPenalty,
         presence_penalty: request.generation?.presencePenalty,
         stop: request.generation?.stop,
-        prompt_cache_key: request.cache === "none" ? undefined : (options.promptCacheKey ?? request.promptCacheKey),
+        prompt_cache_key: ProviderShared.sendsPromptCacheKey(request)
+            ? (options.promptCacheKey ?? request.promptCacheKey)
+            : undefined,
         safe_prompt: options.safePrompt,
         document_image_limit: options.documentImageLimit,
         document_page_limit: options.documentPageLimit,

package/dist/protocols/open-responses-channel.d.ts

@@ -1,4 +1,4 @@
-import { Headers } from "effect/unstable/http";
+import { Headers } from "effect/http";
 import { HttpTransport, type Transport, type WebSocketChannelDriver } from "../route/transport/index.js";
 import { OpenResponsesContinuation } from "./open-responses-continuation.js";
 export interface Options {