@opencode-ai/ai 0.0.0-beta-18387 → 0.0.0-beta-18593

package/dist/protocols/open-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, ProviderInternalReason, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -607,16 +607,16 @@ const NO_EVENTS = [];
 const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incomplete", "response.failed"]);
 export const terminal = (event) => TERMINAL_TYPES.has(event.type);
 const onOutputTextDelta = (state, event, id) => {
-    if (!event.delta || !state.messageItems.has(id))
+    if (!event.delta || state.message?.id !== id)
         return [state, NO_EVENTS];
     const events = [];
-    const phase = state.messagePhases[id];
+    const phase = state.message.phase;
     const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) });
     const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata);
     return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events];
 };
 const onOutputTextDone = (state, event, id) => {
-    if (state.messageItems.has(id)) {
+    if (state.message?.id === id) {
         if (state.lifecycle.text.has(id) || event.text === undefined)
             return [state, NO_EVENTS];
         return onOutputTextDelta(state, { ...event, delta: event.text }, id);
@@ -625,19 +625,51 @@ const onOutputTextDone = (state, event, id) => {
     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 startReasoningSummaryPart = (state, itemID, index) => {
     const item = state.reasoningItems[itemID];
-    if (!event.delta || !item)
+    if (!item?.open || index === 0 || item.summaryParts[index] !== undefined)
         return [state, NO_EVENTS];
-    const index = event.summary_index ?? 0;
     const events = [];
+    const lifecycle = Object.entries(item.summaryParts)
+        .filter((entry) => entry[1] !== "concluded")
+        .reduce((lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${itemID}:${entry[0]}`, providerMetadata(state, { itemId: itemID })), state.lifecycle);
     return [
         {
             ...state,
-            lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `${itemID}:${index}`, event.delta),
+            lifecycle: Lifecycle.reasoningStart(lifecycle, events, `${itemID}:${index}`, providerMetadata(state, { itemId: itemID, reasoningEncryptedContent: item.encryptedContent ?? null })),
             reasoningItems: {
                 ...state.reasoningItems,
-                [itemID]: { ...item, deltaIndexes: new Set([...item.deltaIndexes, index]) },
+                [itemID]: {
+                    ...item,
+                    summaryParts: {
+                        ...Object.fromEntries(Object.entries(item.summaryParts).map((entry) => entry[1] === "concluded" ? entry : [entry[0], "concluded"])),
+                        [index]: "active",
+                    },
+                },
+            },
+        },
+        events,
+    ];
+};
+export const onReasoningDelta = (state, event, itemID) => {
+    const item = state.reasoningItems[itemID];
+    if (!event.delta || !item?.open)
+        return [state, NO_EVENTS];
+    const index = event.summary_index ?? 0;
+    if (item.summaryParts[index] === "concluded")
+        return [state, NO_EVENTS];
+    const [started, emitted] = startReasoningSummaryPart(state, itemID, index);
+    const current = started.reasoningItems[itemID];
+    if (!current)
+        return [started, emitted];
+    const events = [...emitted];
+    return [
+        {
+            ...started,
+            lifecycle: Lifecycle.reasoningDelta(started.lifecycle, events, `${itemID}:${index}`, event.delta),
+            reasoningItems: {
+                ...started.reasoningItems,
+                [itemID]: { ...current, deltaIndexes: new Set([...current.deltaIndexes, index]) },
             },
         },
         events,
@@ -648,7 +680,7 @@ export const onReasoningDelta = (state, event, itemID) => {
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state, event, itemID) => {
     const item = state.reasoningItems[itemID];
-    if (!item || typeof event.text !== "string")
+    if (!item?.open || typeof event.text !== "string")
         return [state, NO_EVENTS];
     const index = event.summary_index ?? 0;
     if (item.deltaIndexes.has(index))
@@ -656,32 +688,44 @@ export const onReasoningDone = (state, event, itemID) => {
     return onReasoningDelta(state, { ...event, delta: event.text }, itemID);
 };
 const reasoningMetadata = (state, item) => providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null });
-// Responses APIs stream reasoning items in a stable order:
+// Responses APIs normally stream reasoning items in this order:
 //   `output_item.added` (reasoning) →
 //     `reasoning_summary_part.added` (index=0) →
 //     `reasoning_summary_text.delta` →
 //     `reasoning_summary_part.done` (index=0) →
 //     (repeat for index>0) →
 //   `output_item.done` (reasoning).
-// The handlers below rely on this ordering: `onOutputItemAdded` seeds the
-// per-item entry, `onReasoningSummaryPartAdded` for `summary_index === 0`
-// short-circuits when the entry already exists, and higher-index handlers
-// fold against the same entry. Behaviour for out-of-order events is
-// best-effort, not guaranteed.
+// `onOutputItemAdded` seeds the per-item entry, while each later part start is
+// also an implicit boundary for the previous part. This keeps the common event
+// lifecycle ordered when a compatible provider omits or delays a part-done event.
 const onOutputItemAdded = (state, event) => {
     const item = event.item;
     if (item?.type === "message" && item.id !== undefined) {
+        const itemID = item.id;
         const phase = messagePhase(item.phase);
+        // A new message closes earlier messages, including ones that never streamed.
+        const events = [];
+        const lifecycle = [...state.lifecycle.text]
+            .filter((id) => id !== itemID)
+            .reduce((lifecycle, id) => {
+            const openPhase = state.message?.id === id ? state.message.phase : undefined;
+            return Lifecycle.textEnd(lifecycle, events, id, providerMetadata(state, { itemId: id, ...(openPhase === undefined ? {} : { phase: openPhase }) }));
+        }, state.lifecycle);
         return [
             {
                 ...state,
-                messageItems: new Set([...state.messageItems, item.id]),
-                messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
+                lifecycle,
+                message: {
+                    id: itemID,
+                    phase: phase === undefined && state.message?.id === itemID ? state.message.phase : phase,
+                },
             },
-            NO_EVENTS,
+            events,
         ];
     }
     if (item && isReasoningItem(item)) {
+        if (state.reasoningItems[item.id] !== undefined)
+            return [state, NO_EVENTS];
         const events = [];
         return [
             {
@@ -690,6 +734,7 @@ const onOutputItemAdded = (state, event) => {
                 reasoningItems: {
                     ...state.reasoningItems,
                     [item.id]: {
+                        open: true,
                         encryptedContent: item.encrypted_content,
                         summaryParts: { 0: "active" },
                         deltaIndexes: new Set(),
@@ -702,6 +747,8 @@ const onOutputItemAdded = (state, event) => {
     if (item?.type !== "function_call" || !item.call_id)
         return [state, NO_EVENTS];
     const id = item.id ?? item.call_id;
+    if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
+        return [state, NO_EVENTS];
     const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined;
     const events = [];
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
@@ -722,38 +769,15 @@ const onOutputItemAdded = (state, event) => {
 const onReasoningSummaryPartAdded = (state, event) => {
     if (event.item_id === undefined || event.summary_index === undefined)
         return [state, NO_EVENTS];
-    const item = state.reasoningItems[event.item_id];
-    if (!item)
-        return [state, NO_EVENTS];
-    if (event.summary_index === 0)
-        return [state, NO_EVENTS];
-    const events = [];
-    const closed = Object.entries(item.summaryParts)
-        .filter((entry) => entry[1] === "can-conclude")
-        .reduce((lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${event.item_id}:${entry[0]}`, providerMetadata(state, { itemId: event.item_id })), state.lifecycle);
-    return [
-        {
-            ...state,
-            lifecycle: Lifecycle.reasoningStart(closed, events, `${event.item_id}:${event.summary_index}`, providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null })),
-            reasoningItems: {
-                ...state.reasoningItems,
-                [event.item_id]: {
-                    ...item,
-                    summaryParts: {
-                        ...Object.fromEntries(Object.entries(item.summaryParts).map((entry) => entry[1] === "can-conclude" ? [entry[0], "concluded"] : entry)),
-                        [event.summary_index]: "active",
-                    },
-                },
-            },
-        },
-        events,
-    ];
+    return startReasoningSummaryPart(state, event.item_id, event.summary_index);
 };
 const onReasoningSummaryPartDone = (state, event) => {
     if (event.item_id === undefined || event.summary_index === undefined)
         return [state, NO_EVENTS];
     const item = state.reasoningItems[event.item_id];
-    if (!item)
+    if (!item?.open)
+        return [state, NO_EVENTS];
+    if (item.summaryParts[event.summary_index] !== "active")
         return [state, NO_EVENTS];
     return [
         {
@@ -803,17 +827,13 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         return [state, NO_EVENTS];
     if (item.type === "message" && item.id !== undefined) {
         const itemPhase = messagePhase(item.phase);
-        const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase;
+        const phase = itemPhase === undefined && state.message?.id === item.id ? state.message.phase : itemPhase;
         const events = [];
-        const messageItems = new Set(state.messageItems);
-        messageItems.delete(item.id);
-        const { [item.id]: _phase, ...messagePhases } = state.messagePhases;
         return [
             {
                 ...state,
                 lifecycle: Lifecycle.textEnd(state.lifecycle, events, item.id, providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })),
-                messageItems,
-                messagePhases,
+                message: state.message?.id === item.id ? undefined : state.message,
             },
             events,
         ];
@@ -821,19 +841,33 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     if (item.type === "function_call") {
         if (!item.call_id || !item.name)
             return [state, NO_EVENTS];
-        const id = item.id ?? item.call_id;
-        const tools = state.tools[id]
+        const callID = item.call_id;
+        if (state.completedTools.has(callID))
+            return [state, NO_EVENTS];
+        const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined;
+        const fallback = item.id ?? callID;
+        // Match the pending tool by call id so item events that disagree on
+        // whether `item.id` is present still resolve the same call.
+        const registered = state.tools[fallback] !== undefined
+            ? fallback
+            : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID);
+        const id = registered ?? fallback;
+        const tools = registered !== undefined
             ? state.tools
             : ToolStream.start(state.tools, id, {
-                id: item.call_id,
+                id: callID,
                 name: item.name,
-                providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
+                providerMetadata: metadata,
             });
         const result = item.arguments === undefined
             ? yield* ToolStream.finish(state.id, tools, id)
             : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments);
         const events = [];
-        const resultEvents = result.events ?? [];
+        const finished = result.events ?? [];
+        // A done-only call never streamed a start event, so open its lifecycle here.
+        const resultEvents = registered !== undefined || finished.length === 0
+            ? finished
+            : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished];
         const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle;
         events.push(...resultEvents);
         return [
@@ -843,6 +877,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
                 hasFunctionCall: resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
                     state.hasFunctionCall,
                 tools: result.tools,
+                completedTools: new Set([...state.completedTools, callID]),
             },
             events,
         ];
@@ -852,17 +887,47 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         const metadata = reasoningMetadata(state, item);
         const reasoningItem = state.reasoningItems[item.id];
         if (reasoningItem) {
+            if (!reasoningItem.open)
+                return [state, NO_EVENTS];
             const lifecycle = Object.entries(reasoningItem.summaryParts)
                 .filter((entry) => entry[1] === "active" || entry[1] === "can-conclude")
                 .reduce((lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, metadata), state.lifecycle);
-            const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems;
-            return [{ ...state, lifecycle, reasoningItems }, events];
+            return [
+                {
+                    ...state,
+                    lifecycle,
+                    reasoningItems: {
+                        ...state.reasoningItems,
+                        [item.id]: {
+                            ...reasoningItem,
+                            open: false,
+                            encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+                        },
+                    },
+                },
+                events,
+            ];
         }
         if (!state.lifecycle.reasoning.has(item.id)) {
             const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
             events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }));
             events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata }));
-            return [{ ...state, lifecycle }, events];
+            return [
+                {
+                    ...state,
+                    lifecycle,
+                    reasoningItems: {
+                        ...state.reasoningItems,
+                        [item.id]: {
+                            open: false,
+                            encryptedContent: item.encrypted_content,
+                            summaryParts: { 0: "concluded" },
+                            deltaIndexes: new Set(),
+                        },
+                    },
+                },
+                events,
+            ];
         }
         return [
             { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
@@ -877,7 +942,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
             const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined);
             if (id === undefined ||
                 ((item.type !== "function_call" || !current.tools[id]) &&
-                    (item.type !== "reasoning" || !current.reasoningItems[id])))
+                    (item.type !== "reasoning" || !current.reasoningItems[id]?.open)))
                 return Effect.succeed([current, events]);
             return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
         })
@@ -918,11 +983,8 @@ const providerErrorMessage = (event, nested) => {
         return `${code}: ${message}`;
     return message || code;
 };
-export const providerFailure = (id, event, fallback) => {
+export const providerFailure = (event, fallback, body = ProviderShared.encodeJson(event)) => {
     const nested = event.error ?? event.response?.error ?? undefined;
-    const code = event.code || nested?.code || undefined;
-    // Keep the full raw payload on the error even when the message is a summary.
-    const body = JSON.stringify(nested ?? event) ?? "";
     const summary = providerErrorMessage(event, nested);
     const message = summary ?? (body === "{}" ? fallback : body);
     const status = typeof event.status === "number"
@@ -935,16 +997,10 @@ export const providerFailure = (id, event, fallback) => {
         event.response === undefined &&
         summary === undefined &&
         status === undefined
-        ? new ProviderInternalReason({ message })
-        : classifyProviderFailure({ message, code, status, rawBody: body });
-    return new AIError({
-        module: id,
-        method: "stream",
-        body,
-        reason,
-    });
+        ? new ProviderInternalError({ message, body })
+        : classifyProviderFailure({ message, status, rawBody: body });
+    return new AIError({ reason });
 };
-const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
 export const step = (state, input) => {
     // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
     const event = input.item_id !== undefined && outputItemID(state, input) !== input.item_id
@@ -988,6 +1044,11 @@ export const step = (state, input) => {
     if (event.type === "response.output_item.added") {
         if (event.item?.type === "message" && event.item.id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
+        if (event.item &&
+            isReasoningItem(event.item) &&
+            state.reasoningItems[event.item.id] === undefined &&
+            state.lifecycle.reasoning.size > 0)
+            return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`);
         const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined);
         return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && id !== undefined
             ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
@@ -1005,9 +1066,9 @@ export const step = (state, input) => {
     if (event.type === "response.completed" || event.type === "response.incomplete")
         return onResponseFinish(state, event);
     if (event.type === "response.failed")
-        return providerError(state, event, `${state.name} response failed`);
+        return providerFailure(event, `${state.name} response failed`);
     if (event.type === "error")
-        return decodeKnownErrorEvent(event).pipe(Effect.mapError(() => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`)), Effect.flatMap(() => providerError(state, event, `${state.name} stream error`)));
+        return decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`, ProviderShared.encodeJson(event), cause)), Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)));
     return Effect.succeed([state, NO_EVENTS]);
 };
 // =============================================================================
@@ -1023,10 +1084,10 @@ export const initial = (request, extension = BASE) => ({
     providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
     hasFunctionCall: false,
     tools: ToolStream.empty(),
+    completedTools: new Set(),
     lifecycle: Lifecycle.initial(),
     outputItems: {},
-    messageItems: new Set(),
-    messagePhases: {},
+    message: undefined,
     reasoningItems: {},
 });
 export const protocol = Protocol.make({

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

@@ -1,5 +1,6 @@
 import { Effect, Schema } from "effect";
 import { Route } from "../route/client.js";
+import { Framing } from "../route/framing.js";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, Usage, type FinishReasonDetails, type CacheHint, type LLMRequest } from "../schema/index.js";
@@ -587,7 +588,7 @@ export declare const protocol: Protocol<{
     readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
-}, string, {
+}, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {
         readonly [x: string]: unknown;
@@ -655,6 +656,7 @@ export declare const protocol: Protocol<{
         readonly native_finish_reason?: string | null | undefined;
     }[] | null | undefined;
 }, ParserState>;
+export declare const framing: Framing.Definition<string>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly model: string;
     readonly messages: readonly ({

package/dist/protocols/openai-chat.js

@@ -3,9 +3,10 @@ import { Tool } from "@opencode-ai/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
+import { Framing } from "../route/framing.js";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, InvalidProviderOutputReason, LLMEvent, ProviderInternalReason, UnknownProviderReason, Usage, } from "../schema/index.js";
+import { AIError, AIErrorReason, InvalidProviderOutputError, LLMEvent, ProviderInternalError, UnknownProviderError, 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";
@@ -176,6 +177,8 @@ export const OpenAIChatEvent = Schema.StructWithRest(Schema.Struct({
     usage: optionalNull(OpenAIChatUsage),
     error: optionalNull(OpenAIChatError),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const DONE = "[DONE]";
+const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)]);
 const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
     type: "function",
     function: {
@@ -613,18 +616,22 @@ 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 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)" }));
+            return yield* new AIError({
+                reason: new UnknownProviderError({
+                    message: "Provider reported an error (finish_reason: error)",
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         case "network_error":
-            return yield* finishReasonError(event, new ProviderInternalReason({ message: "Provider reported a network error (finish_reason: network_error)" }));
+            return yield* new AIError({
+                reason: new ProviderInternalError({
+                    message: "Provider reported a network error (finish_reason: network_error)",
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         case "stop":
         case "end":
             return "stop";
@@ -738,12 +745,8 @@ const step = (state, event) => Effect.gen(function* () {
     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,
             }),
@@ -796,14 +799,13 @@ const step = (state, event) => Effect.gen(function* () {
         (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0))
         lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata);
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0");
-    if (delta?.content) {
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
+    // Reasoning is one response-wide channel: it stays open alongside text and
+    // refusal output so late reasoning deltas and details join the same block,
+    // and `finishEvents` closes it once with the complete metadata.
+    if (delta?.content)
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content);
-    }
-    if (delta?.refusal) {
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
+    if (delta?.refusal)
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal);
-    }
     // Compatible providers may omit indexes. Prefer durable identity, then use
     // batch position for parallel deltas or the latest call for sparse chunks.
     for (const [position, tool] of toolDeltas.entries()) {
@@ -831,7 +833,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* ProviderShared.eventError(ADAPTER, result.reason.message, ProviderShared.encodeJson(event));
+            return yield* new AIError({
+                reason: AIErrorReason.make({
+                    ...result.reason,
+                    message: result.message,
+                    cause: result.reason.cause,
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         tools = result.tools;
         if (result.events.length)
             lifecycle = Lifecycle.stepStart(lifecycle, events);
@@ -867,11 +876,9 @@ const step = (state, event) => Effect.gen(function* () {
 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",
+            reason: new InvalidProviderOutputError({
                 message: "OpenAI Chat stream ended without finish_reason",
+                classification: "incomplete-stream",
                 route: ADAPTER,
             }),
         });
@@ -886,7 +893,9 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state) {
             normalized: state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
         }
         : { normalized: hasToolCalls ? "tool-calls" : "stop" };
-    const metadata = reasoningMetadata(state.providerMetadataKey, state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
+    // Snapshot details at publish time so the emitted event never observes later
+    // mutation of the accumulated `reasoningDetails` array.
+    const metadata = reasoningMetadata(state.providerMetadataKey, state.reasoningField, state.reasoningDetailsObserved ? [...state.reasoningDetails] : undefined);
     const started = state.reasoningDetailsObserved && !state.reasoningEmitted
         ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, state.reasoningField))
         : state.lifecycle;
@@ -912,7 +921,7 @@ export const protocol = Protocol.make({
         from: fromRequest,
     },
     stream: {
-        event: Protocol.jsonEvent(OpenAIChatEvent),
+        event: OpenAIChatStreamEvent,
         initial: (request) => ({
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
@@ -926,11 +935,13 @@ export const protocol = Protocol.make({
             nextToolIndex: 0,
             requireFinishReason: request.model.compatibility?.requireFinishReason ?? true,
         }),
-        step,
+        step: (state, event) => (event === DONE ? Effect.succeed([state, []]) : step(state, event)),
+        terminal: (event) => event === DONE,
         onHalt: finishEvents,
     },
 });
-export const httpTransport = HttpTransport.sseJson.with();
+export const framing = Framing.sseWithDone;
+export const httpTransport = HttpTransport.sseJson.with().with({ framing });
 export const route = Route.make({
     id: ADAPTER,
     provider: "openai",

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

@@ -1,6 +1,5 @@
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import * as OpenAIChat from "./openai-chat.js";
 const ADAPTER = "openai-compatible-chat";
 /**
@@ -15,6 +14,6 @@ export const route = Route.make({
     providerMetadataKey: "openai",
     protocol: OpenAIChat.protocol,
     endpoint: Endpoint.path("/chat/completions"),
-    framing: Framing.sse,
+    framing: OpenAIChat.framing,
 });
 export * as OpenAICompatibleChat from "./openai-compatible-chat.js";