@opencode-ai/ai 0.0.0-dev-18659 → 0.0.0-dev-18661

package/dist/protocols/open-responses.js

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
@@ -624,6 +624,14 @@ const onOutputTextDone = (state, event, id) => {
     const events = [];
     return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events];
 };
+const decodeMessagePart = Schema.decodeUnknownOption(Schema.Union([OpenResponsesOutputText, Schema.Struct({ type: Schema.tag("refusal"), refusal: Schema.String })]));
+const decodeSummaryPart = Schema.decodeUnknownOption(OpenResponsesReasoningSummaryText);
+const decodeReasoningPart = Schema.decodeUnknownOption(Schema.Struct({ type: Schema.tag("reasoning_text"), text: Schema.String }));
+const joinReasoningText = (parts) => {
+    if (!parts.some((part) => part !== undefined && part.length > 0))
+        return undefined;
+    return parts.filter((part) => part !== undefined).join("\n\n");
+};
 export const outputItemID = (state, event) => event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id);
 const startReasoningSummaryPart = (state, itemID, index) => {
     const item = state.reasoningItems[itemID];
@@ -821,19 +829,30 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
     events.push(...result.events);
     return [{ ...state, lifecycle, tools: result.tools }, events];
 });
-const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (state, event) {
-    const item = event.item;
+const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (state, item) {
     if (!item)
         return [state, NO_EVENTS];
     if (item.type === "message" && item.id !== undefined) {
+        const message = state.message?.id === item.id ? state.message : undefined;
         const itemPhase = messagePhase(item.phase);
-        const phase = itemPhase === undefined && state.message?.id === item.id ? state.message.phase : itemPhase;
+        const phase = itemPhase === undefined ? message?.phase : itemPhase;
+        const parts = Array.isArray(item.content) ? item.content : [];
+        const content = [];
+        for (const part of parts) {
+            const decoded = Option.getOrUndefined(decodeMessagePart(part));
+            if (!decoded)
+                continue;
+            content.push(decoded.type === "output_text" ? decoded.text : decoded.refusal);
+        }
+        const text = content.length > 0 ? content.join("") : undefined;
+        const metadata = providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) });
         const events = [];
+        const lifecycle = message && text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle;
         return [
             {
                 ...state,
-                lifecycle: Lifecycle.textEnd(state.lifecycle, events, item.id, providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })),
-                message: state.message?.id === item.id ? undefined : state.message,
+                lifecycle: Lifecycle.textEnd(lifecycle, events, item.id, metadata, text),
+                message: message ? undefined : state.message,
             },
             events,
         ];
@@ -883,15 +902,36 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         ];
     }
     if (isReasoningItem(item)) {
-        const events = [];
+        if (state.reasoningItems[item.id]?.open === false)
+            return [state, NO_EVENTS];
         const metadata = reasoningMetadata(state, item);
+        const summaryParts = Array.isArray(item.summary) ? item.summary : [];
+        const summary = [];
+        for (const part of summaryParts) {
+            const decoded = Option.getOrUndefined(decodeSummaryPart(part));
+            // Keep missing entries so the array still matches the provider's summary indexes.
+            summary.push(decoded?.text);
+        }
+        const reasoningParts = Array.isArray(item.content) ? item.content : [];
+        const content = [];
+        for (const part of reasoningParts) {
+            const decoded = Option.getOrUndefined(decodeReasoningPart(part));
+            if (decoded)
+                content.push(decoded.text);
+        }
+        const itemText = joinReasoningText(summary) ?? joinReasoningText(content);
+        const events = [];
         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 fragments = Object.entries(reasoningItem.summaryParts);
+            let lifecycle = state.lifecycle;
+            for (const [index, status] of fragments) {
+                if (status === "concluded")
+                    continue;
+                // Do not repeat earlier summaries that were already emitted as separate fragments.
+                const finalText = fragments.length === 1 ? itemText : summary[Number(index)];
+                lifecycle = Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${index}`, metadata, finalText || undefined);
+            }
             return [
                 {
                     ...state,
@@ -911,7 +951,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         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 }));
+            events.push(LLMEvent.reasoningEnd({
+                id: item.id,
+                providerMetadata: metadata,
+                text: itemText,
+            }));
             return [
                 {
                     ...state,
@@ -937,22 +981,25 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     return [state, NO_EVENTS];
 });
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
-    const reconciled = event.type === "response.completed"
-        ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
+    let current = state;
+    const events = [];
+    if (event.type === "response.completed") {
+        for (const item of event.response?.output ?? []) {
             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]?.open)))
-                return Effect.succeed([current, events]);
-            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
-        })
-        : [state, NO_EVENTS];
-    const current = reconciled[0];
+            if (id === undefined)
+                continue;
+            if (item.type !== "function_call" || !current.tools[id])
+                continue;
+            const [next, emitted] = yield* onOutputItemDone(current, item);
+            current = next;
+            events.push(...emitted);
+        }
+    }
     // Some compatible providers omit output_item.done even after completing the response.
     const pending = event.type === "response.completed"
         ? yield* ToolStream.finishAll(current.id, current.tools)
         : { tools: current.tools, events: NO_EVENTS };
-    const events = [...reconciled[1], ...pending.events];
+    events.push(...pending.events);
     const hasFunctionCall = pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
         current.hasFunctionCall;
     const lifecycle = Lifecycle.finish(current.lifecycle, events, {
@@ -1061,7 +1108,7 @@ export const step = (state, input) => {
     if (event.type === "response.output_item.done") {
         if (event.item?.type === "message" && event.item.id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
-        return onOutputItemDone(state, event);
+        return onOutputItemDone(state, event.item);
     }
     if (event.type === "response.completed" || event.type === "response.incomplete")
         return onResponseFinish(state, event);

package/dist/protocols/openai-chat.js

@@ -846,15 +846,15 @@ const step = (state, event) => Effect.gen(function* () {
             lifecycle = Lifecycle.stepStart(lifecycle, events);
         events.push(...result.events);
     }
-    const contentFiltered = finishReason?.normalized === "content-filter";
+    const incompleteTools = finishReason?.normalized === "content-filter" || finishReason?.normalized === "length";
     if (finishReason !== undefined &&
-        !contentFiltered &&
+        !incompleteTools &&
         state.finishReason === undefined &&
         Object.keys(pendingTools).length)
         return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta is missing id or name", ProviderShared.encodeJson(event));
-    // A content filter terminates the response without confirming pending tool calls.
+    // Filtering or truncation terminates the response without confirming pending tool calls.
     const finished = finishReason !== undefined &&
-        !contentFiltered &&
+        !incompleteTools &&
         state.finishReason === undefined &&
         Object.keys(tools).length > 0
         ? yield* ToolStream.finishAll(ADAPTER, tools)

package/package.json

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