@opencode-ai/ai 0.0.0-beta-18148 → 0.0.0-beta-18219

package/dist/protocols/openai-chat.js

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, InvalidProviderOutputReason, LLMEvent, ProviderInternalReason, UnknownProviderReason, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
@@ -167,15 +167,15 @@ const OpenAIChatChoice = Schema.StructWithRest(Schema.Struct({
     // Moonshot streams usage on `choice.usage` instead of top-level `usage`.
     usage: optionalNull(OpenAIChatUsage),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const OpenAIChatError = Schema.Struct({
+const OpenAIChatError = Schema.StructWithRest(Schema.Struct({
     code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
     message: Schema.String,
-});
-export const OpenAIChatEvent = Schema.Struct({
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+export const OpenAIChatEvent = Schema.StructWithRest(Schema.Struct({
     choices: optionalNull(Schema.Array(OpenAIChatChoice)),
     usage: optionalNull(OpenAIChatUsage),
     error: optionalNull(OpenAIChatError),
-});
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
     type: "function",
     function: {
@@ -349,13 +349,22 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
             ]
             : [{ role: "system", content: ProviderShared.joinText(request.system) }];
     const messages = [...system];
+    const requireAssistantAfterTool = request.model.compatibility?.requireAssistantAfterTool ??
+        ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => request.model.id.toLowerCase().includes(family));
+    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,6 +405,8 @@ 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);
             messages.push(...lowered.messages);
@@ -517,7 +528,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
@@ -577,19 +588,32 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
 // Streaming parsers are small state machines: every event returns a new state
 // plus the common `LLMEvent`s produced by that event. Tool calls are accumulated
 // because OpenAI streams JSON arguments across multiple deltas.
-const mapFinishReason = (reason) => {
-    if (reason === "stop")
-        return "stop";
-    if (reason === "length")
-        return "length";
-    if (reason === "content_filter")
-        return "content-filter";
-    if (reason === "function_call" || reason === "tool_calls")
-        return "tool-calls";
-    if (reason === "error")
-        return "error";
-    return "unknown";
-};
+const finishReasonError = (event, reason) => new AIError({
+    module: ADAPTER,
+    method: "stream",
+    body: ProviderShared.encodeJson(event),
+    reason,
+});
+const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event, reason) {
+    switch (reason) {
+        case "error":
+            return yield* finishReasonError(event, new UnknownProviderReason({ message: "Provider reported an error (finish_reason: error)" }));
+        case "network_error":
+            return yield* finishReasonError(event, new ProviderInternalReason({ message: "Provider reported a network error (finish_reason: network_error)" }));
+        case "stop":
+        case "end":
+            return "stop";
+        case "length":
+            return "length";
+        case "content_filter":
+            return "content-filter";
+        case "function_call":
+        case "tool_calls":
+            return "tool-calls";
+        default:
+            return "unknown";
+    }
+});
 // OpenAI Chat reports `prompt_tokens` (inclusive total) with a
 // cached-read and cache-write subsets, and `completion_tokens` (inclusive
 // total) with a `reasoning_tokens` subset. We pass the inclusive totals
@@ -686,16 +710,20 @@ const reasoningMetadata = (field, details) => ({
     },
 });
 const step = (state, event) => Effect.gen(function* () {
-    if (event.error)
+    if (event.error) {
+        const body = ProviderShared.encodeJson(event);
         return yield* new AIError({
             module: ADAPTER,
             method: "stream",
+            body,
             reason: classifyProviderFailure({
                 message: event.error.message,
                 code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
                 status: typeof event.error.code === "number" ? event.error.code : undefined,
+                rawBody: body,
             }),
         });
+    }
     const events = [];
     const choice = event.choices?.[0];
     // Moonshot (and a few other OpenAI-compatible providers) attach usage to
@@ -703,8 +731,11 @@ const step = (state, event) => Effect.gen(function* () {
     const choiceUsage = choice?.usage;
     const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage;
     const rawFinishReason = choice?.finish_reason;
-    const finishReason = rawFinishReason !== undefined && rawFinishReason !== null
-        ? { normalized: mapFinishReason(rawFinishReason), raw: choice?.native_finish_reason ?? rawFinishReason }
+    const finishReason = rawFinishReason
+        ? {
+            normalized: yield* mapFinishReason(event, rawFinishReason),
+            raw: choice?.native_finish_reason ?? rawFinishReason,
+        }
         : state.finishReason;
     const delta = choice?.delta;
     const toolDeltas = delta?.tool_calls ?? [];
@@ -721,7 +752,7 @@ const step = (state, event) => Effect.gen(function* () {
         toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments));
     if (state.finishReason !== undefined) {
         if (hasLateContent)
-            return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason");
+            return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat received content after the finish reason", ProviderShared.encodeJson(event));
         return [{ ...state, usage }, events];
     }
     const reasoningField = state.reasoningField ?? reasoning?.field;
@@ -773,14 +804,14 @@ const step = (state, event) => Effect.gen(function* () {
         }
         const result = ToolStream.appendOrStart(ADAPTER, tools, index, { id: id || undefined, name: name || undefined, text }, "OpenAI Chat tool call delta is missing id or name");
         if (ToolStream.isError(result))
-            return yield* result;
+            return yield* ProviderShared.eventError(ADAPTER, result.reason.message, ProviderShared.encodeJson(event));
         tools = result.tools;
         if (result.events.length)
             lifecycle = Lifecycle.stepStart(lifecycle, events);
         events.push(...result.events);
     }
     if (finishReason !== undefined && state.finishReason === undefined && Object.keys(pendingTools).length > 0)
-        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name");
+        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name", ProviderShared.encodeJson(event));
     // Finalize accumulated tool inputs eagerly when finish_reason arrives so
     // valid calls and malformed local calls settle independently.
     const finished = finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
@@ -800,14 +831,25 @@ const step = (state, event) => Effect.gen(function* () {
             reasoningEmitted,
             latestToolIndex,
             nextToolIndex,
+            requireFinishReason: state.requireFinishReason,
         },
         events,
     ];
 });
-const finishEvents = (state) => {
+const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state) {
+    if (state.finishReason === undefined && state.requireFinishReason)
+        return yield* new AIError({
+            module: ADAPTER,
+            method: "stream",
+            reason: new InvalidProviderOutputReason({
+                classification: "incomplete-stream",
+                message: "OpenAI Chat stream ended without finish_reason",
+                route: ADAPTER,
+            }),
+        });
     const events = [];
     const toolCallEvents = state.finishReason === undefined && Object.keys(state.tools).length > 0
-        ? Effect.runSync(ToolStream.finishAll(ADAPTER, state.tools)).events
+        ? (yield* ToolStream.finishAll(ADAPTER, state.tools)).events
         : state.toolCallEvents;
     const hasToolCalls = toolCallEvents.length > 0;
     const reason = state.finishReason
@@ -815,7 +857,7 @@ const finishEvents = (state) => {
             ...state.finishReason,
             normalized: state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
         }
-        : { normalized: hasToolCalls ? "tool-calls" : "unknown" };
+        : { normalized: hasToolCalls ? "tool-calls" : "stop" };
     const metadata = reasoningMetadata(state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
     const started = state.reasoningDetailsObserved && !state.reasoningEmitted
         ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
@@ -825,7 +867,7 @@ const finishEvents = (state) => {
     events.push(...toolCallEvents);
     Lifecycle.finish(lifecycle, events, { reason, usage: state.usage });
     return events;
-};
+});
 // =============================================================================
 // Protocol And OpenAI Route
 // =============================================================================
@@ -853,6 +895,7 @@ export const protocol = Protocol.make({
             reasoningDetailsObserved: false,
             reasoningEmitted: false,
             nextToolIndex: 0,
+            requireFinishReason: request.model.compatibility?.requireFinishReason ?? true,
         }),
         step,
         onHalt: finishEvents,

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;
@@ -309,9 +318,11 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly arguments?: string | undefined;
     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;
@@ -166,9 +175,11 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly arguments?: string | undefined;
     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.d.ts

@@ -283,7 +283,9 @@ export declare const protocol: Protocol<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, string, {
+    readonly [x: string]: unknown;
     readonly error?: {
+        readonly [x: string]: unknown;
         readonly message: string;
         readonly code?: string | number | null | undefined;
     } | null | undefined;

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) => {
@@ -123,7 +124,17 @@ function makeFromTransport(input) {
                 const route = `${request.model.provider}/${request.model.route.id}`;
                 return Stream.unwrap(routeInput.transport.execute(prepared, request, runtime, options).pipe(Effect.map((execution) => {
                     const events = execution.frames.pipe(Stream.mapEffect(decodeEvent(route)), protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream);
-                    const stream = events.pipe(Stream.mapAccumEffect(() => protocol.stream.initial(request), protocol.stream.step, protocol.stream.onHalt ? { onHalt: protocol.stream.onHalt } : undefined), Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route));
+                    const stream = Stream.suspend(() => {
+                        let state = protocol.stream.initial(request);
+                        const parsed = events.pipe(Stream.mapEffect((event) => protocol.stream.step(state, event).pipe(Effect.map(([next, output]) => {
+                            state = next;
+                            return output;
+                        }))), Stream.flatMap(Stream.fromIterable));
+                        const onHalt = protocol.stream.onHalt;
+                        return onHalt
+                            ? parsed.pipe(Stream.concat(Stream.suspend(() => Stream.unwrap(onHalt(state).pipe(Effect.map(Stream.fromIterable))))))
+                            : parsed;
+                    }).pipe(Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route));
                     return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream;
                 })));
             },
@@ -149,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/route/protocol.d.ts

@@ -56,8 +56,8 @@ export interface ProtocolStream<Frame, Event, State> {
     readonly step: (state: State, event: Event) => Effect.Effect<readonly [State, ReadonlyArray<LLMEvent>], AIError>;
     /** Optional request-completion signal for transports that do not end naturally. */
     readonly terminal?: (event: Event) => boolean;
-    /** Optional flush emitted when the framed stream ends. */
-    readonly onHalt?: (state: State) => ReadonlyArray<LLMEvent>;
+    /** Optional effectful flush emitted when the framed stream ends. */
+    readonly onHalt?: (state: State) => Effect.Effect<ReadonlyArray<LLMEvent>, AIError>;
 }
 /**
  * Construct a `Protocol` from its body and stream pieces:

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-18148",
+  "version": "0.0.0-beta-18219",
   "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-18148",
+    "@opencode-ai/http-recorder": "0.0.0-beta-18219",
     "@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-18148",
+    "@opencode-ai/schema": "0.0.0-beta-18219",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"