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

package/dist/protocols/bedrock-converse.js

@@ -565,7 +565,7 @@ export const protocol = Protocol.make({
             reasoningSignatures: {},
         }),
         step,
-        onHalt,
+        onHalt: (state) => Effect.succeed(onHalt(state)),
     },
 });
 export const route = Route.make({

package/dist/protocols/gemini.js

@@ -574,7 +574,7 @@ export const protocol = Protocol.make({
             lifecycle: Lifecycle.initial(),
         }),
         step,
-        onHalt: finish,
+        onHalt: (state) => Effect.succeed(finish(state)),
     },
 });
 export const route = Route.make({

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

@@ -384,6 +384,7 @@ export declare const decodeKnownErrorEvent: (event: Event) => Effect.Effect<{
 export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
     readonly delta: Schema.optional<Schema.String>;
+    readonly arguments: Schema.optional<Schema.String>;
     readonly text: Schema.optional<Schema.String>;
     readonly item_id: Schema.optional<Schema.String>;
     readonly summary_index: Schema.optional<Schema.Number>;
@@ -1009,6 +1010,7 @@ 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;

package/dist/protocols/open-responses.js

@@ -204,6 +204,7 @@ export const decodeKnownErrorEvent = (event) => decodeWebSocketErrorEvent({
 export const Event = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     delta: Schema.optional(Schema.String),
+    arguments: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
     item_id: Schema.optional(Schema.String),
     summary_index: Schema.optional(Schema.Number),
@@ -756,9 +757,23 @@ const onReasoningSummaryPartDone = (state, event) => {
     ];
 };
 const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
-    if (!event.item_id || !event.delta || !state.tools[event.item_id])
+    if (!event.item_id)
+        return [state, NO_EVENTS];
+    const tool = state.tools[event.item_id];
+    if (!tool)
+        return [state, NO_EVENTS];
+    const final = event.type === "response.function_call_arguments.done" ? event.arguments : undefined;
+    if (event.type === "response.function_call_arguments.done" && final === undefined)
+        return [state, NO_EVENTS];
+    if (final !== undefined && !final.startsWith(tool.input))
+        return [
+            { ...state, tools: ToolStream.start(state.tools, event.item_id, { ...tool, input: final }) },
+            NO_EVENTS,
+        ];
+    const delta = final === undefined ? event.delta : final.slice(tool.input.length);
+    if (!delta)
         return [state, NO_EVENTS];
-    const result = ToolStream.appendExisting(state.id, state.tools, event.item_id, event.delta, `${state.name} tool argument delta is missing its tool call`);
+    const result = ToolStream.appendExisting(state.id, state.tools, event.item_id, delta, `${state.name} tool argument delta is missing its tool call`);
     if (ToolStream.isError(result))
         return yield* result;
     const events = [];
@@ -943,7 +958,7 @@ export const step = (state, event) => {
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
         return Effect.succeed(onOutputItemAdded(state, event));
     }
-    if (event.type === "response.function_call_arguments.delta")
+    if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
         return event.item_id
             ? onFunctionCallArgumentsDelta(state, event)
             : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);

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

@@ -204,7 +204,7 @@ declare const OpenAIChatBody: Schema.Struct<{
     stop: Schema.optional<Schema.$Array<Schema.String>>;
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
-export declare const OpenAIChatEvent: Schema.Struct<{
+export declare const OpenAIChatEvent: Schema.StructWithRest<Schema.Struct<{
     readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -257,11 +257,11 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.Struct<{
+    readonly error: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly code: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
         readonly message: Schema.String;
-    }>>>;
-}>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>;
 interface PendingToolDelta {
     readonly id?: string;
@@ -281,6 +281,7 @@ export interface ParserState {
     readonly reasoningEmitted: boolean;
     readonly latestToolIndex?: number;
     readonly nextToolIndex: number;
+    readonly requireFinishReason: boolean;
 }
 interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
@@ -585,7 +586,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/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: {
@@ -577,19 +577,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 +699,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 +720,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 +741,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 +793,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 +820,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 +846,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 +856,7 @@ const finishEvents = (state) => {
     events.push(...toolCallEvents);
     Lifecycle.finish(lifecycle, events, { reason, usage: state.usage });
     return events;
-};
+});
 // =============================================================================
 // Protocol And OpenAI Route
 // =============================================================================
@@ -853,6 +884,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-responses.d.ts

@@ -309,6 +309,7 @@ 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;

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

@@ -166,6 +166,7 @@ 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;

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/route/client.js

@@ -123,7 +123,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;
                 })));
             },

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/package.json

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