@opencode-ai/ai 0.0.0-beta-17793 → 0.0.0-beta-17887

package/dist/protocols/gemini.js

@@ -26,6 +26,9 @@ const requiresThoughtSignatureFallback = (modelID) => {
         return false;
     return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID);
 };
+// Gemini 3 accepts media nested inside function responses; matched Gemini 2.5 variants reject it,
+// so their tool-result attachments lower as a separate user turn instead.
+const routesLegacyToolMedia = (modelID) => /gemini-2[.-]5(?:[.-]|$)/i.test(modelID);
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -197,7 +200,17 @@ const lowerToolCall = (part) => ({
 });
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     const contents = [];
+    const legacyToolMedia = routesLegacyToolMedia(request.model.id);
+    let pendingMedia;
+    const flushMedia = () => {
+        if (!pendingMedia)
+            return;
+        contents.push({ role: "user", parts: [{ text: "Attached media from tool result:" }, ...pendingMedia] });
+        pendingMedia = undefined;
+    };
     for (const message of request.messages) {
+        if (message.role !== "tool")
+            flushMedia();
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message);
             const previous = contents.at(-1);
@@ -227,7 +240,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                 if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
                     return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"]);
                 if (part.type === "text") {
-                    parts.push({ text: part.text });
+                    parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) });
                     continue;
                 }
                 if (part.type === "reasoning") {
@@ -278,6 +291,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                 const value = ProviderShared.normalizeToolFile(item);
                 media.push({ inlineData: { mimeType: value.mime, data: value.base64 } });
             }
+            if (legacyToolMedia && media.length > 0)
+                (pendingMedia ??= []).push(...media);
             parts.push({
                 functionResponse: {
                     id: functionCallId(part.providerMetadata),
@@ -286,7 +301,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                         name: part.name,
                         content: text.join("\n"),
                     },
-                    parts: media.length > 0 ? media : undefined,
+                    parts: legacyToolMedia || media.length === 0 ? undefined : media,
                 },
             });
         }
@@ -298,6 +313,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
         else
             contents.push({ role: "user", parts });
     }
+    flushMedia();
     return contents;
 });
 const resolveOptions = (request) => {
@@ -422,9 +438,11 @@ const finish = (state) => {
     if (finishReason === undefined && state.usage === undefined)
         return [];
     const events = [];
-    const lifecycle = state.reasoningSignature
-        ? Lifecycle.reasoningEnd(state.lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }))
-        : state.lifecycle;
+    let lifecycle = state.lifecycle;
+    if (state.reasoningSignature !== undefined)
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }));
+    if (state.textSignature !== undefined)
+        lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }));
     Lifecycle.finish(lifecycle, events, {
         reason: {
             normalized: promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
@@ -452,16 +470,23 @@ const step = (state, event) => {
     let lifecycle = nextState.lifecycle;
     let nextToolCallId = nextState.nextToolCallId;
     let reasoningSignature = nextState.reasoningSignature;
+    let textSignature = nextState.textSignature;
     for (const part of candidate.content.parts) {
-        if ("thoughtSignature" in part && part.thoughtSignature && "thought" in part && part.thought)
-            reasoningSignature = part.thoughtSignature;
+        const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined;
+        // Gemini attaches replay signatures to thought parts, visible text, or function calls;
+        // each block kind must retain the signature attached to its own parts.
+        if (signature !== undefined && "thought" in part && part.thought)
+            reasoningSignature = signature;
+        else if (signature !== undefined && "text" in part)
+            textSignature = signature;
         if ("text" in part && part.text.length > 0) {
             if (part.thought) {
-                lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", part.text, part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined);
+                lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", part.text, signature ? googleMetadata({ thoughtSignature: signature }) : undefined);
                 continue;
             }
             lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined);
-            lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text);
+            lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text, textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined);
+            textSignature = undefined;
             continue;
         }
         if ("functionCall" in part) {
@@ -489,6 +514,7 @@ const step = (state, event) => {
             lifecycle,
             nextToolCallId,
             reasoningSignature,
+            textSignature,
             finishReason: candidate.finishReason ?? nextState.finishReason,
         },
         events,

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

@@ -4,6 +4,8 @@ export interface Options {
     readonly id: string;
     readonly name: string;
     readonly rotateAfterMs?: number;
+    readonly enabled?: (url: string) => boolean;
+    readonly url?: (url: string) => string;
     readonly headers?: (headers: Headers.Headers) => Headers.Headers;
     readonly driver?: (input: {
         readonly request: Readonly<Record<string, unknown>>;

package/dist/protocols/open-responses-channel.js

@@ -79,12 +79,12 @@ export const transport = (options) => {
         prepare: (input) => Effect.gen(function* () {
             const parts = yield* HttpTransport.jsonRequestParts(input);
             const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length");
-            const channel = input.webSocket
+            const channel = input.webSocket && (options.enabled?.(parts.url) ?? true)
                 ? yield* Effect.gen(function* () {
                     const create = yield* message(parts.jsonBody);
                     const base = driver(options, create.message);
                     return {
-                        url: yield* WebSocketTransport.toWebSocketUrl(parts.url),
+                        url: yield* WebSocketTransport.toWebSocketUrl(options.url?.(parts.url) ?? parts.url),
                         headers,
                         rotateAfterMs: options.rotateAfterMs,
                         driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,

package/dist/protocols/openai-images.js

@@ -61,7 +61,7 @@ export const model = (input) => {
                     return Effect.succeed({ data: image.data, mediaType: image.mediaType });
                 if (image.type === "url")
                     return ImageInputs.decodeDataUrl(image.url, ADAPTER);
-                return Effect.succeed(undefined);
+                return Effect.undefined;
             });
             const multipartMask = mask === undefined
                 ? undefined

package/dist/protocols/openai-responses.d.ts

@@ -3,6 +3,7 @@ import { Route } from "../route/client.js";
 import { Protocol } from "../route/protocol.js";
 import { HttpTransport } from "../route/transport/index.js";
 import { OpenResponses } from "./open-responses.js";
+import { type Options } from "./open-responses-channel.js";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/responses";
 declare const OpenAIResponsesBody: Schema.Struct<{
@@ -461,6 +462,141 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
 }, string>;
+export declare const channelTransport: (options: Omit<Options, "driver">) => import("../route/transport/index.js").Transport<{
+    readonly input: readonly ({
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "item_reference";
+        readonly id: string;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    readonly tools?: readonly ({
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly action?: "generate" | "auto" | "edit" | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
+        readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly output_compression?: number | undefined;
+        readonly input_fidelity?: "low" | "high" | undefined;
+        readonly partial_images?: number | undefined;
+    })[] | undefined;
+    readonly text?: {
+        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | {
+        readonly type: "image_generation";
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+}, import("./open-responses-channel.js").Prepared, string>;
 export declare const transport: import("../route/transport/index.js").Transport<{
     readonly input: readonly ({
         readonly type: "reasoning";

package/dist/protocols/openai-responses.js

@@ -190,12 +190,15 @@ export const protocol = Protocol.make({
 const endpoint = Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL });
 const auth = Auth.none;
 export const httpTransport = HttpTransport.sseJson.with();
-export const transport = OpenResponsesChannel.transport({
+export const channelTransport = (options) => OpenResponsesChannel.transport({
+    ...options,
+    driver: (input) => OpenAIResponsesChannel.driver({ id: options.id, name: options.name, ...input }),
+});
+export const transport = channelTransport({
     id: ADAPTER,
     name: NAME,
     rotateAfterMs: WEBSOCKET_ROTATE_AFTER_MS,
     headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
-    driver: (input) => OpenAIResponsesChannel.driver({ id: ADAPTER, name: NAME, ...input }),
 });
 export const route = Route.make({
     id: ADAPTER,

package/dist/protocols/utils/image-input.js

@@ -8,7 +8,7 @@ const invalid = (module, message) => new AIError({
 export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
 export const decodeDataUrl = (url, module) => {
     if (!url.startsWith("data:"))
-        return Effect.succeed(undefined);
+        return Effect.undefined;
     const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
     if (!match)
         return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"));

package/dist/protocols/utils/lifecycle.d.ts

@@ -7,7 +7,7 @@ export interface State {
 export declare const initial: () => State;
 export declare const stepStart: (state: State, events: LLMEvent[]) => State;
 export declare const textStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
-export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string) => State;
+export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;

package/dist/protocols/utils/lifecycle.js

@@ -13,9 +13,9 @@ export const textStart = (state, events, id, providerMetadata) => {
     events.push(LLMEvent.textStart({ id, providerMetadata }));
     return { ...stepped, text: new Set([...stepped.text, id]) };
 };
-export const textDelta = (state, events, id, text) => {
+export const textDelta = (state, events, id, text, providerMetadata) => {
     const started = textStart(state, events, id);
-    events.push(LLMEvent.textDelta({ id, text }));
+    events.push(LLMEvent.textDelta({ id, text, providerMetadata }));
     return started;
 };
 export const reasoningStart = (state, events, id, providerMetadata) => {

package/dist/providers/azure.js

@@ -1,3 +1,4 @@
+import { Headers } from "effect/unstable/http";
 import { Auth } from "../route/auth.js";
 import {} from "../route/auth-options.js";
 import { ProviderID } from "../schema/index.js";
@@ -7,11 +8,35 @@ import { ProviderShared } from "../protocols/shared.js";
 import { withOpenAIOptions } from "./openai-options.js";
 export const id = ProviderID.make("azure");
 const routeAuth = Auth.remove("authorization");
+const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000;
 const resourceBaseURL = (resourceName) => `https://${resourceName.trim()}.openai.azure.com/openai`;
 const responsesRoute = OpenAIResponses.route.with({
     id: "azure-openai-responses",
     provider: id,
     auth: routeAuth,
+    transport: OpenAIResponses.channelTransport({
+        id: "azure-openai-responses",
+        name: "Azure OpenAI Responses",
+        rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+        enabled: (value) => {
+            const url = new URL(value);
+            return (url.protocol === "https:" &&
+                url.hostname.endsWith(".openai.azure.com") &&
+                url.pathname.endsWith("/openai/v1/responses") &&
+                url.searchParams.get("api-version") === "v1");
+        },
+        url: (value) => {
+            const url = new URL(value);
+            url.searchParams.delete("api-version");
+            return url.toString();
+        },
+        headers: (headers) => {
+            const apiKey = headers["api-key"];
+            if (!apiKey)
+                return headers;
+            return Headers.remove(Headers.set(headers, "authorization", `Bearer ${apiKey}`), "api-key");
+        },
+    }),
 });
 const chatRoute = OpenAIChat.route.with({
     id: "azure-openai-chat",

package/dist/providers/xai.d.ts

@@ -245,7 +245,7 @@ export declare const routes: (Route<{
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
-}, import("../route/transport/http.js").HttpPrepared<string>>)[];
+}, import("../protocols/open-responses-channel.js").Prepared>)[];
 export declare const configure: (input?: LanguageModelOptions) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./open-responses-options.js").OpenResponsesOptionsInput>;

package/dist/providers/xai.js

@@ -8,13 +8,18 @@ import * as OpenAIChat from "../protocols/openai-chat.js";
 import * as OpenAIResponses from "../protocols/openai-responses.js";
 import { XAIImages } from "../protocols/xai-images.js";
 export const id = ProviderID.make("xai");
+const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000;
 const responsesRoute = Route.make({
     id: "openai-responses",
     provider: id,
     providerMetadataKey: "xai",
     protocol: OpenAIResponses.protocol,
     endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-    transport: OpenAIResponses.httpTransport,
+    transport: OpenAIResponses.channelTransport({
+        id: "openai-responses",
+        name: "xAI Responses",
+        rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+    }),
     defaults: { providerOptions: { store: false } },
 });
 const chatRoute = Route.make({

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-17793",
+  "version": "0.0.0-beta-17887",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.110",
-    "@opencode-ai/http-recorder": "0.0.0-beta-17793",
+    "@opencode-ai/http-recorder": "0.0.0-beta-17887",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-beta-17793",
+    "@opencode-ai/schema": "0.0.0-beta-17887",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.110",
     "google-auth-library": "10.5.0"