@opencode-ai/ai 0.0.0-beta-18155 → 0.0.0-beta-18230

package/dist/image-client.d.ts

@@ -1,7 +1,7 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor.js";
+import { type AIError } from "./schema/index.js";
 import type { ImageOptions, ImageRequestFor, ImageResponse } from "./image.js";
-import type { AIError } from "./schema/index.js";
 export type Execute = RequestExecutor.Interface["execute"];
 export interface Interface {
     readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;

package/dist/image-client.js

@@ -1,5 +1,7 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor.js";
+import { mergeHttpOptions } from "./schema/index.js";
+import { sanitizeSurrogates } from "./utils/sanitize.js";
 export class Service extends Context.Service()("@opencode/ImageClient") {
 }
 export const generate = (request) => Effect.gen(function* () {
@@ -9,7 +11,14 @@ export const generate = (request) => Effect.gen(function* () {
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     return Service.of({
-        generate: (request) => request.model.route.generate(request, executor.execute),
+        generate: (request) => request.model.route.generate({
+            ...sanitizeSurrogates({
+                ...request,
+                model: undefined,
+                http: mergeHttpOptions(request.model.http, request.http),
+            }),
+            model: request.model,
+        }, executor.execute),
     });
 }));
 export const ImageClient = {

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

@@ -584,15 +584,7 @@ export declare const protocol: Protocol<{
         readonly type?: string | undefined;
         readonly message?: string | undefined;
     } | undefined;
-    readonly delta?: {
-        readonly type?: string | undefined;
-        readonly text?: string | undefined;
-        readonly thinking?: string | undefined;
-        readonly signature?: string | undefined;
-        readonly partial_json?: string | undefined;
-        readonly stop_reason?: string | null | undefined;
-        readonly stop_sequence?: string | null | undefined;
-    } | undefined;
+    readonly delta?: unknown;
     readonly index?: number | undefined;
     readonly usage?: {
         readonly [x: string]: unknown;
@@ -609,18 +601,7 @@ export declare const protocol: Protocol<{
             readonly thinking_tokens?: number | undefined;
         } | null | undefined;
     } | undefined;
-    readonly content_block?: {
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly data?: string | undefined;
-        readonly name?: string | undefined;
-        readonly input?: unknown;
-        readonly text?: string | undefined;
-        readonly content?: unknown;
-        readonly thinking?: string | undefined;
-        readonly signature?: string | undefined;
-        readonly tool_use_id?: string | undefined;
-    } | undefined;
+    readonly content_block?: unknown;
 }, {
     tools: Partial<Record<number, ToolStream.PendingTool>>;
     reasoningSignatures: {};

package/dist/protocols/anthropic-messages.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
@@ -264,6 +264,7 @@ const AnthropicStreamBlock = Schema.Struct({
     tool_use_id: Schema.optional(Schema.String),
     content: Schema.optional(Schema.Unknown),
 });
+const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock);
 const AnthropicStreamDelta = Schema.Struct({
     type: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
@@ -273,12 +274,13 @@ const AnthropicStreamDelta = Schema.Struct({
     stop_reason: optionalNull(Schema.String),
     stop_sequence: optionalNull(Schema.String),
 });
+const decodeAnthropicStreamDelta = Schema.decodeUnknownOption(AnthropicStreamDelta);
 const AnthropicEvent = Schema.Struct({
     type: Schema.String,
     index: Schema.optional(Schema.Number),
     message: Schema.optional(Schema.Struct({ usage: Schema.optional(AnthropicUsage) })),
-    content_block: Schema.optional(AnthropicStreamBlock),
-    delta: Schema.optional(AnthropicStreamDelta),
+    content_block: Schema.optional(Schema.Unknown),
+    delta: Schema.optional(Schema.Unknown),
     usage: Schema.optional(AnthropicUsage),
     // `type` and `message` are both required per Anthropic's spec, but
     // OpenAI-compatible proxies and gateway translations occasionally drop one
@@ -1044,6 +1046,8 @@ const onContentBlockStart = (state, event) => {
 const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(function* (state, event) {
     const delta = event.delta;
     if (delta?.type === "text_delta" && delta.text) {
+        if (!state.lifecycle.text.has(`text-${event.index ?? 0}`))
+            return [state, NO_EVENTS];
         const events = [];
         return [
             { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, `text-${event.index ?? 0}`, delta.text) },
@@ -1051,6 +1055,8 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
         ];
     }
     if (delta?.type === "thinking_delta" && delta.thinking) {
+        if (!state.lifecycle.reasoning.has(`reasoning-${event.index ?? 0}`))
+            return [state, NO_EVENTS];
         const events = [];
         return [
             {
@@ -1062,6 +1068,8 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     }
     if (delta?.type === "signature_delta" && delta.signature) {
         const index = event.index ?? 0;
+        if (!state.lifecycle.reasoning.has(`reasoning-${index}`))
+            return [state, NO_EVENTS];
         return [
             {
                 ...state,
@@ -1148,25 +1156,62 @@ const onError = (event) => Effect.fail(new AIError({
     method: "stream",
     reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
 }));
+const isKnownStreamBlockType = (type) => type === "text" ||
+    type === "thinking" ||
+    type === "redacted_thinking" ||
+    type === "tool_use" ||
+    type === "server_tool_use" ||
+    isServerToolResultType(type);
+const isKnownStreamDeltaType = (type) => type === "text_delta" || type === "thinking_delta" || type === "signature_delta" || type === "input_json_delta";
+const invalidStreamEvent = (event) => Effect.fail(ProviderShared.eventError(ADAPTER, "Invalid anthropic/anthropic-messages stream event", ProviderShared.encodeJson(event)));
 const step = (state, event) => {
+    if (!SSE_EVENTS.has(event.type))
+        return Effect.succeed([state, NO_EVENTS]);
+    if (event.type !== "content_block_start" &&
+        event.content_block !== undefined &&
+        Option.isNone(decodeAnthropicStreamBlock(event.content_block)))
+        return invalidStreamEvent(event);
+    if (event.type !== "content_block_delta" &&
+        event.delta !== undefined &&
+        Option.isNone(decodeAnthropicStreamDelta(event.delta)))
+        return invalidStreamEvent(event);
     if (event.type === "message_start")
         return Effect.succeed(onMessageStart(state, event));
     if (event.type === "content_block_start") {
-        const block = event.content_block;
-        if (block && (block.type === "tool_use" || block.type === "server_tool_use")) {
+        if (!ProviderShared.isRecord(event.content_block) || typeof event.content_block.type !== "string")
+            return invalidStreamEvent(event);
+        if (!isKnownStreamBlockType(event.content_block.type))
+            return Effect.succeed([state, NO_EVENTS]);
+        const decoded = decodeAnthropicStreamBlock(event.content_block);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        const block = decoded.value;
+        if (block.type === "tool_use" || block.type === "server_tool_use") {
             if (event.index === undefined)
                 return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic ${block.type} missing index`));
             if (!block.id)
                 return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic tool_use missing id at index ${event.index}`));
         }
-        return Effect.succeed(onContentBlockStart(state, event));
+        return Effect.succeed(onContentBlockStart(state, { ...event, content_block: block }));
+    }
+    if (event.type === "content_block_delta") {
+        if (!ProviderShared.isRecord(event.delta))
+            return invalidStreamEvent(event);
+        if (typeof event.delta.type === "string" && !isKnownStreamDeltaType(event.delta.type))
+            return Effect.succeed([state, NO_EVENTS]);
+        const decoded = decodeAnthropicStreamDelta(event.delta);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        return onContentBlockDelta(state, { ...event, delta: decoded.value });
     }
-    if (event.type === "content_block_delta")
-        return onContentBlockDelta(state, event);
     if (event.type === "content_block_stop")
         return onContentBlockStop(state, event);
-    if (event.type === "message_delta")
-        return Effect.succeed(onMessageDelta(state, event));
+    if (event.type === "message_delta") {
+        const decoded = decodeAnthropicStreamDelta(event.delta);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        return Effect.succeed(onMessageDelta(state, { ...event, delta: decoded.value }));
+    }
     if (event.type === "message_stop")
         return onMessageStop(state);
     if (event.type === "error")

package/dist/protocols/bedrock-converse.d.ts

@@ -273,6 +273,14 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly metrics?: unknown;
     } | undefined;
+    readonly exception?: {
+        readonly type: string;
+        readonly details: {
+            readonly message?: string | undefined;
+            readonly originalMessage?: string | undefined;
+            readonly originalStatusCode?: number | undefined;
+        };
+    } | undefined;
     readonly messageStart?: {
         readonly role: string;
     } | undefined;
@@ -307,31 +315,6 @@ export declare const protocol: Protocol<{
         readonly stopReason: string;
         readonly additionalModelResponseFields?: unknown;
     } | undefined;
-    readonly internalServerException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly modelStreamErrorException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly validationException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly throttlingException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly serviceUnavailableException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
 }, {
     readonly metadata?: {
         readonly usage?: {
@@ -343,6 +326,14 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly metrics?: unknown;
     } | undefined;
+    readonly exception?: {
+        readonly type: string;
+        readonly details: {
+            readonly message?: string | undefined;
+            readonly originalMessage?: string | undefined;
+            readonly originalStatusCode?: number | undefined;
+        };
+    } | undefined;
     readonly messageStart?: {
         readonly role: string;
     } | undefined;
@@ -377,31 +368,6 @@ export declare const protocol: Protocol<{
         readonly stopReason: string;
         readonly additionalModelResponseFields?: unknown;
     } | undefined;
-    readonly internalServerException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly modelStreamErrorException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly validationException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly throttlingException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly serviceUnavailableException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
 }, ParserState>;
 export declare const route: Route<{
     readonly messages: readonly ({

package/dist/protocols/bedrock-converse.js

@@ -149,11 +149,7 @@ const BedrockEvent = Schema.Struct({
         usage: Schema.optional(BedrockUsageSchema),
         metrics: Schema.optional(Schema.Unknown),
     })),
-    internalServerException: Schema.optional(BedrockStreamException),
-    modelStreamErrorException: Schema.optional(BedrockStreamException),
-    validationException: Schema.optional(BedrockStreamException),
-    throttlingException: Schema.optional(BedrockStreamException),
-    serviceUnavailableException: Schema.optional(BedrockStreamException),
+    exception: Schema.optional(Schema.Struct({ type: Schema.String, details: BedrockStreamException })),
 });
 // =============================================================================
 // Request Lowering
@@ -507,20 +503,13 @@ const step = (state, event) => Effect.gen(function* () {
             [],
         ];
     }
-    const exception = [
-        ["internalServerException", event.internalServerException],
-        ["modelStreamErrorException", event.modelStreamErrorException],
-        ["serviceUnavailableException", event.serviceUnavailableException],
-        ["throttlingException", event.throttlingException],
-        ["validationException", event.validationException],
-    ].find((entry) => entry[1] !== undefined);
-    if (exception) {
+    if (event.exception) {
         return yield* new AIError({
             module: ADAPTER,
             method: "stream",
             reason: classifyProviderFailure({
-                message: exception[1]?.message ?? exception[1]?.originalMessage ?? "Bedrock Converse stream error",
-                code: exception[0],
+                message: event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error",
+                code: event.exception.type,
             }),
         });
     }

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

@@ -56,7 +56,7 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
         // against ad-hoc `JSON.parse` calls.
         const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload"));
         delete parsed.p;
-        out.push({ [eventType]: parsed });
+        out.push(messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed });
     }
     return [cursor, out];
 });

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

@@ -133,7 +133,12 @@ export const driver = (input) => {
                 ...observation,
                 checkpoint: {
                     protocol: PROTOCOL,
-                    value: { version: VERSION, responseID, request, output: output.slice() },
+                    value: {
+                        version: VERSION,
+                        responseID,
+                        request,
+                        output: event.response?.output ? [...event.response.output] : output.slice(),
+                    },
                 },
             };
         }),

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

@@ -387,6 +387,7 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly arguments: Schema.optional<Schema.String>;
     readonly text: Schema.optional<Schema.String>;
     readonly item_id: Schema.optional<Schema.String>;
+    readonly output_index: Schema.optional<Schema.Number>;
     readonly summary_index: Schema.optional<Schema.Number>;
     readonly item: Schema.optional<Schema.StructWithRest<Schema.Struct<{
         readonly type: Schema.String;
@@ -402,6 +403,14 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
         readonly incomplete_details: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly reason: Schema.optional<Schema.String>;
         }>>>;
+        readonly output: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly id: Schema.optional<Schema.String>;
+            readonly call_id: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly arguments: Schema.optional<Schema.String>;
+            readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly input_tokens: Schema.optional<Schema.Number>;
             readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
@@ -453,6 +462,7 @@ export interface ParserState {
     readonly tools: ToolStream.State<string>;
     readonly hasFunctionCall: boolean;
     readonly lifecycle: Lifecycle.State;
+    readonly outputItems: Readonly<Record<number, string>>;
     readonly messageItems: ReadonlySet<string>;
     readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
@@ -653,10 +663,11 @@ export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
 export declare const providerMetadata: (state: ParserState, metadata: Record<string, unknown>) => ProviderMetadata;
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>];
 export declare const terminal: (event: Event) => boolean;
+export declare const outputItemID: (state: ParserState, event: Event) => string | undefined;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const providerFailure: (id: string, event: Event, fallback: string) => AIError;
-export declare const step: (state: ParserState, event: Event) => AIError | Effect.Effect<StepResult, never, never> | Effect.Effect<[ParserState, readonly ({
+export declare const step: (state: ParserState, input: Event) => AIError | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;
 } | {
@@ -838,7 +849,7 @@ export declare const step: (state: ParserState, event: Event) => AIError | Effec
         };
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-})[]], AIError, never>;
+})[]], AIError, never> | Effect.Effect<StepResult, never, never>;
 /**
  * The provider-neutral Open Responses protocol. Provider-specific Responses
  * implementations compose this baseline with their own tools and event variants.
@@ -987,6 +998,15 @@ export declare const protocol: Protocol<{
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
         readonly error?: {
             readonly type?: string | null | undefined;
             readonly code?: string | null | undefined;
@@ -1014,6 +1034,7 @@ export declare const protocol: Protocol<{
     readonly param?: string | null | undefined;
     readonly status_code?: unknown;
     readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
     readonly summary_index?: number | undefined;
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{

package/dist/protocols/open-responses.js

@@ -207,12 +207,14 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     arguments: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
     item_id: Schema.optional(Schema.String),
+    output_index: Schema.optional(Schema.Number),
     summary_index: Schema.optional(Schema.Number),
     item: Schema.optional(StreamItem),
     response: Schema.optional(Schema.StructWithRest(Schema.Struct({
         id: Schema.optional(Schema.String),
         service_tier: optionalNull(Schema.String),
         incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
+        output: Schema.optional(Schema.Array(StreamItem)),
         usage: optionalNull(OpenResponsesUsage),
         error: optionalNull(OpenResponsesErrorPayload),
     }), [Schema.Record(Schema.String, Schema.Unknown)])),
@@ -462,16 +464,11 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
             });
         }
     }
-    // With store:false, Responses APIs only accept previous reasoning items when the
-    // complete item has encrypted state. Summary blocks for one item may carry
-    // that state only on the last block, so filter after they have been joined.
-    return store === false
-        ? input.filter((item) => !("type" in item) || item.type !== "reasoning" || typeof item.encrypted_content === "string")
-        : input;
+    return input;
 });
 const lowerOptions = (request) => {
     const options = OpenResponsesOptions.resolve(request);
-    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
+    const cacheKey = ProviderShared.promptCacheKey(request);
     const parallelToolCalls = resolveParallelToolCalls(request);
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
@@ -603,6 +600,7 @@ const onOutputTextDone = (state, event, id) => {
     const events = [];
     return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events];
 };
+export const outputItemID = (state, event) => event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id);
 export const onReasoningDelta = (state, event, itemID) => {
     const item = state.reasoningItems[itemID];
     if (!event.delta || !item)
@@ -855,27 +853,37 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     return [state, NO_EVENTS];
 });
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
+    const reconciled = event.type === "response.completed"
+        ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
+            if (!item.id ||
+                ((item.type !== "function_call" || !current.tools[item.id]) &&
+                    (item.type !== "reasoning" || !current.reasoningItems[item.id])))
+                return Effect.succeed([current, events]);
+            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
+        })
+        : [state, NO_EVENTS];
+    const current = reconciled[0];
     // Some compatible providers omit output_item.done even after completing the response.
     const pending = event.type === "response.completed"
-        ? yield* ToolStream.finishAll(state.id, state.tools)
-        : { tools: state.tools, events: NO_EVENTS };
-    const events = [...pending.events];
+        ? yield* ToolStream.finishAll(current.id, current.tools)
+        : { tools: current.tools, events: NO_EVENTS };
+    const events = [...reconciled[1], ...pending.events];
     const hasFunctionCall = pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-        state.hasFunctionCall;
-    const lifecycle = Lifecycle.finish(state.lifecycle, events, {
+        current.hasFunctionCall;
+    const lifecycle = Lifecycle.finish(current.lifecycle, events, {
         reason: {
             normalized: mapFinishReason(event, hasFunctionCall),
             raw: event.response?.incomplete_details?.reason,
         },
-        usage: mapUsage(event.response?.usage, state.providerMetadataKey),
+        usage: mapUsage(event.response?.usage, current.providerMetadataKey),
         providerMetadata: event.response?.id || event.response?.service_tier
-            ? providerMetadata(state, {
+            ? providerMetadata(current, {
                 responseId: event.response.id,
                 serviceTier: event.response.service_tier,
             })
             : undefined,
     });
-    return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events];
+    return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events];
 });
 // Build the prettiest summary available from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -917,7 +925,10 @@ export const providerFailure = (id, event, fallback) => {
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
-export const step = (state, event) => {
+export const step = (state, input) => {
+    const event = input.item_id && outputItemID(state, input) !== input.item_id
+        ? { ...input, item_id: outputItemID(state, input) }
+        : input;
     if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
         if (!event.item_id)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
@@ -956,7 +967,9 @@ export const step = (state, event) => {
     if (event.type === "response.output_item.added") {
         if (event.item?.type === "message" && !event.item.id)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
-        return Effect.succeed(onOutputItemAdded(state, event));
+        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && event.item?.id
+            ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: event.item.id } }
+            : state, event));
     }
     if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
         return event.item_id
@@ -989,6 +1002,7 @@ export const initial = (request, extension = BASE) => ({
     hasFunctionCall: false,
     tools: ToolStream.empty(),
     lifecycle: Lifecycle.initial(),
+    outputItems: {},
     messageItems: new Set(),
     messagePhases: {},
     reasoningItems: {},

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

@@ -285,6 +285,7 @@ export interface ParserState {
 }
 interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
+    readonly toolCallID?: (id: string) => string;
 }
 export declare const fromRequest: (request: LLMRequest, options?: LoweringOptions | undefined) => Effect.Effect<{
     reasoning_effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;

package/dist/protocols/openai-chat.js

@@ -192,8 +192,8 @@ const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("OpenAI C
     required: () => "required",
     tool: (name) => ({ type: "function", function: { name } }),
 });
-const lowerToolCall = (part) => ({
-    id: part.id,
+const lowerToolCall = (part, options) => ({
+    id: options.toolCallID?.(part.id) ?? part.id,
     type: "function",
     function: {
         name: part.name,
@@ -257,7 +257,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
             continue;
         }
         if (part.type === "tool-call") {
-            toolCalls.push(lowerToolCall(part));
+            toolCalls.push(lowerToolCall(part, options));
             continue;
         }
     }
@@ -307,7 +307,7 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
         if (part.result.type !== "content") {
             messages.push({
                 role: "tool",
-                tool_call_id: part.id,
+                tool_call_id: options.toolCallID?.(part.id) ?? part.id,
                 content: ProviderShared.toolResultText(part),
                 cache_control: options.cacheControl?.(part.cache),
             });
@@ -317,7 +317,7 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
         const text = content.filter((item) => item.type === "text").map((item) => item.text);
         messages.push({
             role: "tool",
-            tool_call_id: part.id,
+            tool_call_id: options.toolCallID?.(part.id) ?? part.id,
             content: text.join("\n"),
             cache_control: options.cacheControl?.(part.cache),
         });
@@ -349,13 +349,35 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
             ]
             : [{ role: "system", content: ProviderShared.joinText(request.system) }];
     const messages = [...system];
+    const modelID = request.model.id.toLowerCase();
+    const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family));
+    const lowering = {
+        ...options,
+        toolCallID: (id) => {
+            if (mistral)
+                return id.replace(/[^a-zA-Z0-9]/g, "").slice(0, 9).padEnd(9, "0");
+            if (modelID.includes("claude"))
+                return id.replace(/[^a-zA-Z0-9_-]/g, "_");
+            if (request.model.provider === "openai" || request.model.provider === "azure" || modelID.startsWith("openai/"))
+                return id.slice(0, 40);
+            return id;
+        },
+    };
+    const requireAssistantAfterTool = request.model.compatibility?.requireAssistantAfterTool ?? mistral;
+    const bridgeTools = () => {
+        if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
+            messages.push({ role: "assistant", content: "Done." });
+    };
     const pendingImages = [];
     const flushImages = () => {
         if (pendingImages.length === 0)
             return;
+        bridgeTools();
         messages.push({ role: "user", content: pendingImages.splice(0) });
     };
     for (const message of request.messages) {
+        if (message.role === "user")
+            bridgeTools();
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Chat", message);
             if (pendingImages.length > 0) {
@@ -396,14 +418,16 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
                     : { role: "user", content: part.text });
             continue;
         }
+        if (message.role === "assistant" && message.content.every((part) => part.type === "text" && part.text.trim() === ""))
+            continue;
         if (message.role === "tool") {
-            const lowered = yield* lowerToolMessages(message, options);
+            const lowered = yield* lowerToolMessages(message, lowering);
             messages.push(...lowered.messages);
             pendingImages.push(...lowered.images);
             continue;
         }
         flushImages();
-        messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, options)));
+        messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField, lowering)));
     }
     flushImages();
     return messages;
@@ -517,7 +541,7 @@ const detectZaiToolStream = (provider, baseURL, modelID) => {
 };
 const lowerOptions = (request, supportsStore) => {
     const options = OpenAIOptions.resolve(request);
-    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
+    const cacheKey = ProviderShared.promptCacheKey(request);
     return {
         ...(supportsStore && options.store !== undefined ? { store: options.store } : {}),
         // For providers that support `store`, ensure stateless `store:false` is sent

package/dist/protocols/openai-compatible-responses.js

@@ -13,5 +13,6 @@ export const route = Route.make({
     protocol: OpenResponses.protocol,
     endpoint: Endpoint.path(OpenResponses.PATH),
     transport: OpenResponses.httpTransport,
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";

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

@@ -286,6 +286,15 @@ export declare const protocol: Protocol<{
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
         readonly error?: {
             readonly type?: string | null | undefined;
             readonly code?: string | null | undefined;
@@ -313,6 +322,7 @@ export declare const protocol: Protocol<{
     readonly param?: string | null | undefined;
     readonly status_code?: unknown;
     readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
     readonly summary_index?: number | undefined;
 }, OpenResponses.ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{

package/dist/protocols/openai-responses.js

@@ -139,7 +139,7 @@ const HOSTED_TOOLS = {
 const step = (state, event) => {
     if (event.type === "response.reasoning_text.delta")
         return event.item_id
-            ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
+            ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id))
             : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
         return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS);
@@ -176,6 +176,6 @@ export const route = Route.make({
     endpoint,
     auth,
     transport,
-    defaults: { providerOptions: { store: false } },
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });
 export * as OpenAIResponses from "./openai-responses.js";

package/dist/protocols/shared.d.ts

@@ -11,7 +11,7 @@ export declare const JsonObject: Schema.$Record<Schema.String, Schema.Unknown>;
 export declare const optionalArray: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.$Array<S>>;
 export declare const optionalNull: <const S extends Schema.Top>(schema: S) => Schema.optional<Schema.NullOr<S>>;
 export declare const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
-export declare const clampPromptCacheKey: (key: string | undefined) => string | undefined;
+export declare const promptCacheKey: (request: LLMRequest) => string | undefined;
 /**
  * Streaming tool-call accumulator. Adapters that build a tool call across
  * multiple `tool-input-delta` chunks store the partial JSON input string here

package/dist/protocols/shared.js

@@ -16,12 +16,12 @@ export const optionalNull = (schema) => Schema.optional(Schema.NullOr(schema));
 export const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
 // OpenAI limits `prompt_cache_key` to 64 chars; DeepSeek and Zai inherit the same
 // limit via their OpenAI-compatible APIs. Clamp with unicode-aware slicing.
-export const clampPromptCacheKey = (key) => {
-    if (key === undefined)
+export const promptCacheKey = (request) => {
+    if (request.cache === "none" || request.promptCacheKey === undefined)
         return undefined;
-    const chars = Array.from(key);
+    const chars = Array.from(request.promptCacheKey);
     if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
-        return key;
+        return request.promptCacheKey;
     return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
 };
 /**

package/dist/protocols/utils/partial-json.js

@@ -43,8 +43,58 @@ export function parseJSON(jsonString, allowPartial = Allow.ALL) {
         return decodeJson(input);
     }
     catch { }
-    return _parseJSON(input, allowPartial);
+    const repaired = repairJSON(input);
+    if (repaired !== input) {
+        try {
+            return decodeJson(repaired);
+        }
+        catch { }
+    }
+    try {
+        return _parseJSON(input, allowPartial);
+    }
+    catch (error) {
+        if (repaired !== input)
+            return _parseJSON(repaired, allowPartial);
+        throw error;
+    }
 }
+const repairJSON = (input) => {
+    let repaired = "";
+    let quoted = false;
+    for (let index = 0; index < input.length; index++) {
+        const character = input[index];
+        if (!quoted) {
+            repaired += character;
+            if (character === '"')
+                quoted = true;
+            continue;
+        }
+        if (character === '"') {
+            repaired += character;
+            quoted = false;
+            continue;
+        }
+        if (character === "\\") {
+            const next = input[index + 1];
+            if (next === "u" && /^[0-9a-fA-F]{4}$/.test(input.slice(index + 2, index + 6))) {
+                repaired += input.slice(index, index + 6);
+                index += 5;
+                continue;
+            }
+            if (next !== undefined && '"\\/bfnrtu'.includes(next)) {
+                repaired += `\\${next}`;
+                index++;
+                continue;
+            }
+            repaired += "\\\\";
+            continue;
+        }
+        const code = character.charCodeAt(0);
+        repaired += code <= 0x1f ? `\\u${code.toString(16).padStart(4, "0")}` : character;
+    }
+    return repaired;
+};
 const _parseJSON = (jsonString, allow) => {
     const length = jsonString.length;
     let index = 0;
@@ -138,7 +188,12 @@ const _parseJSON = (jsonString, allow) => {
                 skipBlank();
                 index++;
                 try {
-                    object[key] = parseAny();
+                    Object.defineProperty(object, key, {
+                        value: parseAny(),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
                 }
                 catch (error) {
                     if (Allow.OBJ & allow)

package/dist/protocols/utils/tool-stream.d.ts

@@ -61,7 +61,7 @@ export declare const appendOrStart: <K extends StreamKey>(route: string, tools:
 export declare const appendExisting: <K extends StreamKey>(route: string, tools: State<K>, key: K, text: string, missingToolMessage: string) => AppendOutcome<K> | AIError;
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return either a call or a non-executable local input error.
+ * from state, and recover incomplete local arguments when needed.
  * Missing keys are a no-op because some providers emit stop events for
  * non-tool content blocks.
  */

package/dist/protocols/utils/tool-stream.js

@@ -19,34 +19,28 @@ const inputStart = (tool) => LLMEvent.toolInputStart({
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
 });
-const inputDelta = (tool, text) => {
-    const input = parsePartialInput(tool.input);
-    return LLMEvent.toolInputDelta({
-        id: tool.id,
-        name: tool.name,
-        text,
-        ...(Option.isSome(input) ? { input: input.value } : {}),
-    });
-};
+const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
+    id: tool.id,
+    name: tool.name,
+    text,
+    input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
+});
 const toolCall = (route, tool, inputOverride) => {
     const raw = inputOverride ?? tool.input;
-    return parseToolInput(route, tool.name, raw).pipe(Effect.map((input) => LLMEvent.toolCall({
+    return parseToolInput(route, tool.name, raw).pipe(Effect.catch((error) => tool.providerExecuted
+        ? Effect.fail(error)
+        : Effect.succeed(Option.getOrElse(Option.map(parsePartialInput(raw), (input) => input ?? {}), () => ({})))), Effect.map((input) => LLMEvent.toolCall({
         id: tool.id,
         name: tool.name,
         input,
         providerExecuted: tool.providerExecuted ? true : undefined,
         providerMetadata: tool.providerMetadata,
-    })), Effect.catch((error) => tool.providerExecuted
-        ? Effect.fail(error)
-        : Effect.succeed(LLMEvent.toolInputError({
-            id: tool.id,
-            name: tool.name,
-            raw,
-        }))));
+    })));
 };
-const finishEvents = (tool, event) => event.type === "tool-input-error"
-    ? [event]
-    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event];
+const finishEvents = (tool, event) => [
+    LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+    event,
+];
 /** Store the updated tool and produce the optional public delta event. */
 const appendTool = (tools, key, tool, text) => {
     const events = [];
@@ -105,7 +99,7 @@ export const appendExisting = (route, tools, key, text, missingToolMessage) => {
 };
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return either a call or a non-executable local input error.
+ * from state, and recover incomplete local arguments when needed.
  * Missing keys are a no-op because some providers emit stop events for
  * non-tool content blocks.
  */

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

@@ -143,6 +143,15 @@ export declare const protocol: Protocol<{
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
         readonly error?: {
             readonly type?: string | null | undefined;
             readonly code?: string | null | undefined;
@@ -170,6 +179,7 @@ export declare const protocol: Protocol<{
     readonly param?: string | null | undefined;
     readonly status_code?: unknown;
     readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
     readonly summary_index?: number | undefined;
 }, OpenResponses.ParserState>;
 export * as XAIResponses from "./xai-responses.js";

package/dist/providers/openrouter.js

@@ -8,7 +8,7 @@ import { ProviderID } from "../schema/index.js";
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js";
 import * as OpenAIChat from "../protocols/openai-chat.js";
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js";
-import { isRecord, ProviderShared } from "../protocols/shared.js";
+import { isRecord } from "../protocols/shared.js";
 export const profile = OpenAICompatibleProfiles.profiles.openrouter;
 export const id = ProviderID.make(profile.provider);
 const ADAPTER = "openrouter";
@@ -39,12 +39,10 @@ export const protocol = Protocol.make({
                     reasoning_details: reasoningDetails,
                 };
             });
-            const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
             return {
                 ...body,
                 messages,
                 ...bodyOptions(request.providerOptions),
-                ...(cacheKey ? { prompt_cache_key: cacheKey } : {}),
             };
         })),
     },

package/dist/providers/xai.js

@@ -21,7 +21,7 @@ const responsesRoute = Route.make({
         name: "xAI Responses",
         rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
     }),
-    defaults: { providerOptions: { store: false } },
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });
 const chatRoute = Route.make({
     id: "openai-compatible-chat",

package/dist/route/client.js

@@ -5,6 +5,7 @@ import { RequestExecutor } from "./executor.js";
 import { Framing } from "./framing.js";
 import { HttpTransport } from "./transport/index.js";
 import { applyCachePolicy } from "../cache-policy.js";
+import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
 import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputReason, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
@@ -159,7 +160,8 @@ export function make(input) {
     });
 }
 const compile = Effect.fn("LLM.compile")(function* (request, options) {
-    const resolved = applyCachePolicy(resolveRequestOptions(request));
+    const original = applyCachePolicy(resolveRequestOptions(request));
+    const resolved = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }));
     const route = resolved.model.route;
     const body = yield* route.body
         .from(resolved)

package/dist/schema/options.d.ts

@@ -74,6 +74,7 @@ declare const LanguageModelCompatibility_base: Schema.Class<LanguageModelCompati
     readonly reasoningField: Schema.optional<Schema.String>;
     readonly maxTokensField: Schema.optional<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>;
     readonly requireFinishReason: Schema.optional<Schema.Boolean>;
+    readonly requireAssistantAfterTool: Schema.optional<Schema.Boolean>;
     readonly supportsStore: Schema.optional<Schema.Boolean>;
     readonly supportsUsageInStreaming: Schema.optional<Schema.Boolean>;
     readonly supportsStrictMode: Schema.optional<Schema.Boolean>;

package/dist/schema/options.js

@@ -101,6 +101,7 @@ export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelC
     reasoningField: Schema.optional(Schema.String),
     maxTokensField: Schema.optional(LanguageModelMaxTokensFieldCompatibility),
     requireFinishReason: Schema.optional(Schema.Boolean),
+    requireAssistantAfterTool: Schema.optional(Schema.Boolean),
     supportsStore: Schema.optional(Schema.Boolean),
     supportsUsageInStreaming: Schema.optional(Schema.Boolean),
     supportsStrictMode: Schema.optional(Schema.Boolean),

package/dist/utils/sanitize.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeSurrogates: <T>(value: T) => T;

package/dist/utils/sanitize.js

@@ -0,0 +1,12 @@
+import { isRecord } from "./record.js";
+export const sanitizeSurrogates = (value) => {
+    if (typeof value === "string")
+        return value.toWellFormed();
+    if (Array.isArray(value))
+        return value.map(sanitizeSurrogates);
+    if (value instanceof Uint8Array || value instanceof Error)
+        return value;
+    if (isRecord(value))
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key.toWellFormed(), sanitizeSurrogates(entry)]));
+    return value;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-18155",
+  "version": "0.0.0-beta-18230",
   "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.111",
-    "@opencode-ai/http-recorder": "0.0.0-beta-18155",
+    "@opencode-ai/http-recorder": "0.0.0-beta-18230",
     "@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-18155",
+    "@opencode-ai/schema": "0.0.0-beta-18230",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"