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

package/README.md

@@ -214,22 +214,40 @@ the requests sent by code under test:
 import { Effect } from "effect"
 import { TestLLM } from "@opencode-ai/ai/testing"
 
-const testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
 const programWithTestClient = Effect.gen(function* () {
+  const test = yield* TestLLM.Test
+  yield* test.push(TestLLM.text("Hello from the test model", "text-1"))
   const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
+  console.log(yield* test.requests())
   return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
+}).pipe(Effect.provide(TestLLM.testLayer()))
 ```
 
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
+`testLayer()` provides the same object under `LLMClient.Service` and `TestLLM.Test`. Production consumes the
+normal client; tests use the additional controls. Each layer build has fresh state.
+
+- `test.push(...)` queues one-shot responses in execution order. Each argument is one response.
+- `test.always(response)` installs a repeatable fallback. The layer's `fallback` option sets its initial value.
+- `test.serve(request => response)` installs a request-dependent fallback. `always` and `serve` replace each
+  other without changing queued replies; queued replies take precedence.
+- `test.requests()` returns an array snapshot. `transformRequest` changes only the recorded observation;
+  `serve` receives the original canonical request.
+- `test.wait(count)` waits for request arrivals, not output or completion, and supports concurrent waiters.
+- `test.gate()` returns a scoped gate with countable `started` notifications and a `release` Effect. Release
+  unblocks all requests captured by that gate; closing its scope also releases it. Effect-aware test runners
+  already provide Scope.
+
+Constructing `stream()` or `generate()` does not record a request, invoke a responder, or consume a script.
+Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
+future reply.
+
+Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
+it does not repair or truncate them.
+
+The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
+over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
+`testLayer`.
 
 ## Caching
 

package/dist/llm.d.ts

@@ -45,6 +45,7 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -70,6 +71,7 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

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

@@ -129,6 +129,7 @@ export type BedrockConverseBody = Schema.Schema.Type<typeof BedrockConverseBody>
 interface ParserState {
     readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<number>;
+    readonly finishedTools: ReadonlySet<number>;
     readonly pendingFinish: {
         readonly reason: FinishReasonDetails;
         readonly usage?: Usage;

package/dist/protocols/bedrock-converse.js

@@ -285,6 +285,13 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                         content.push({ reasoningContent: { redactedContent: redactedData } });
                         continue;
                     }
+                    if (signature === undefined || signature.trim().length === 0) {
+                        // Interrupted streams and model switches can leave unsigned reasoning.
+                        // Preserve readable history as text rather than replay invalid reasoningContent.
+                        if (part.text.trim().length > 0)
+                            content.push(...textWithCache(breakpoints, part.text, part.cache));
+                        continue;
+                    }
                     content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } });
                     continue;
                 }
@@ -293,7 +300,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
             }
-            messages.push({ role: "assistant", content });
+            if (content.length > 0)
+                messages.push({ role: "assistant", content });
             continue;
         }
         const content = [];
@@ -447,6 +455,8 @@ const step = (state, event) => Effect.gen(function* () {
     }
     if (event.contentBlockDelta?.delta?.toolUse) {
         const index = event.contentBlockDelta.contentBlockIndex;
+        if (state.finishedTools.has(index))
+            return [state, []];
         const result = ToolStream.appendExisting(ADAPTER, state.tools, index, event.contentBlockDelta.delta.toolUse.input, "Bedrock Converse tool delta is missing its tool call");
         if (ToolStream.isError(result))
             return yield* result;
@@ -473,6 +483,7 @@ const step = (state, event) => Effect.gen(function* () {
                     state.hasToolCalls,
                 lifecycle,
                 tools: result.tools,
+                finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
                 reasoningSignatures: Object.fromEntries(Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index))),
             },
             events,
@@ -552,6 +563,7 @@ export const protocol = Protocol.make({
         initial: (request) => ({
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
+            finishedTools: new Set(),
             pendingFinish: undefined,
             hasToolCalls: false,
             lifecycle: Lifecycle.initial(),

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

@@ -565,15 +565,19 @@ export interface ParserState {
     readonly name: string;
     readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<string>;
+    readonly completedTools: ReadonlySet<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 message: {
+        readonly id: string;
+        readonly phase: MessagePhase | null | undefined;
+    } | undefined;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
 }
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded";
 interface ReasoningStreamItem {
+    readonly open: boolean;
     readonly encryptedContent: string | null | undefined;
     readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>;
     readonly deltaIndexes: ReadonlySet<number>;
@@ -828,6 +832,7 @@ export declare const step: (state: ParserState, input: Event) => AIError | Effec
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -853,6 +858,7 @@ export declare const step: (state: ParserState, input: Event) => AIError | Effec
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;

package/dist/protocols/open-responses.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]]));
         })
@@ -979,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 } }
@@ -1014,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,6 +3,7 @@ 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, AIErrorReason, InvalidProviderOutputError, LLMEvent, ProviderInternalError, UnknownProviderError, Usage, } from "../schema/index.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: {
@@ -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()) {
@@ -891,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;
@@ -917,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(),
@@ -931,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";

package/dist/protocols/shared.d.ts

@@ -117,13 +117,13 @@ export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. Retry control events are ignored without interrupting the stream.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
  * Decoder failures become provider output errors so the public error channel
  * stays `AIError`.
  */
-export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>) => Stream.Stream<string, AIError>;
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>, includeDone?: boolean) => Stream.Stream<string, AIError>;
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */