@opencode-ai/ai 0.0.0-next-16175 → 0.0.0-next-16179

package/dist/protocols/anthropic-messages.d.ts

@@ -431,6 +431,7 @@ export declare const protocol: Protocol<{
     } | undefined;
 }, {
     tools: Partial<Record<number, ToolStream.PendingTool>>;
+    reasoningSignatures: {};
     lifecycle: Lifecycle.State;
 }>;
 export declare const route: Route<{

package/dist/protocols/anthropic-messages.js

@@ -632,6 +632,9 @@ const onContentBlockStart = (state, event) => {
                 tools: ToolStream.start(state.tools, event.index, {
                     id: block.id ?? String(event.index),
                     name: block.name ?? "",
+                    input: block.input !== undefined && (!ProviderShared.isRecord(block.input) || Object.keys(block.input).length > 0)
+                        ? ProviderShared.encodeJson(block.input)
+                        : undefined,
                     providerExecuted: block.type === "server_tool_use",
                 }),
             },
@@ -645,19 +648,29 @@ const onContentBlockStart = (state, event) => {
             ],
         ];
     }
-    if (block.type === "text" && block.text) {
+    if (block.type === "text" && block.text !== undefined) {
         const events = [];
+        const id = `text-${event.index ?? 0}`;
+        const lifecycle = Lifecycle.textStart(state.lifecycle, events, id);
         return [
-            { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, `text-${event.index ?? 0}`, block.text) },
+            { ...state, lifecycle: block.text ? Lifecycle.textDelta(lifecycle, events, id, block.text) : lifecycle },
             events,
         ];
     }
-    if (block.type === "thinking" && block.thinking) {
+    if (block.type === "thinking" && block.thinking !== undefined) {
         const events = [];
+        const id = `reasoning-${event.index ?? 0}`;
+        const providerMetadata = block.signature === undefined ? undefined : anthropicMetadata({ signature: block.signature });
+        const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, providerMetadata);
         return [
             {
                 ...state,
-                lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${event.index ?? 0}`, block.thinking),
+                lifecycle: block.thinking
+                    ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, providerMetadata)
+                    : lifecycle,
+                reasoningSignatures: event.index === undefined || block.signature === undefined
+                    ? state.reasoningSignatures
+                    : { ...state.reasoningSignatures, [event.index]: block.signature },
             },
             events,
         ];
@@ -665,7 +678,7 @@ const onContentBlockStart = (state, event) => {
     // Redacted thinking surfaces as an empty reasoning part carrying the opaque
     // payload as `redactedData` metadata (same model as Vercel's
     // @ai-sdk/anthropic). The existing content_block_stop closes the part.
-    if (block.type === "redacted_thinking" && block.data) {
+    if (block.type === "redacted_thinking" && block.data !== undefined) {
         const events = [];
         return [
             {
@@ -701,13 +714,13 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
         ];
     }
     if (delta?.type === "signature_delta" && delta.signature) {
-        const events = [];
+        const index = event.index ?? 0;
         return [
             {
                 ...state,
-                lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, `reasoning-${event.index ?? 0}`, anthropicMetadata({ signature: delta.signature })),
+                reasoningSignatures: { ...state.reasoningSignatures, [index]: delta.signature },
             },
-            events,
+            NO_EVENTS,
         ];
     }
     if (delta?.type === "input_json_delta" && event.index !== undefined) {
@@ -729,26 +742,45 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
     const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index);
     const events = [];
     const resultEvents = result.events ?? [];
+    const signature = state.reasoningSignatures[event.index];
     const lifecycle = resultEvents.length
         ? Lifecycle.stepStart(state.lifecycle, events)
-        : Lifecycle.reasoningEnd(Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`), events, `reasoning-${event.index}`);
+        : Lifecycle.reasoningEnd(Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`), events, `reasoning-${event.index}`, signature === undefined ? undefined : anthropicMetadata({ signature }));
     events.push(...resultEvents);
-    return [{ ...state, lifecycle, tools: result.tools }, events];
+    const reasoningSignatures = { ...state.reasoningSignatures };
+    delete reasoningSignatures[event.index];
+    return [{ ...state, lifecycle, tools: result.tools, reasoningSignatures }, events];
 });
 const onMessageDelta = (state, event) => {
     const usage = mergeUsage(state.usage, mapUsage(event.usage));
+    return [
+        {
+            ...state,
+            usage,
+            pendingFinish: {
+                reason: {
+                    normalized: mapFinishReason(event.delta?.stop_reason),
+                    raw: event.delta?.stop_reason ?? undefined,
+                },
+                providerMetadata: event.delta?.stop_sequence === null || event.delta?.stop_sequence === undefined
+                    ? undefined
+                    : anthropicMetadata({ stopSequence: event.delta.stop_sequence }),
+            },
+        },
+        NO_EVENTS,
+    ];
+};
+const onMessageStop = (state) => {
     const events = [];
     const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-        reason: {
-            normalized: mapFinishReason(event.delta?.stop_reason),
-            raw: event.delta?.stop_reason ?? undefined,
+        reason: state.pendingFinish?.reason ?? {
+            normalized: "unknown",
+            raw: undefined,
         },
-        usage,
-        providerMetadata: event.delta?.stop_sequence
-            ? anthropicMetadata({ stopSequence: event.delta.stop_sequence })
-            : undefined,
+        usage: state.usage,
+        providerMetadata: state.pendingFinish?.providerMetadata,
     });
-    return [{ ...state, lifecycle, usage }, events];
+    return [{ ...state, lifecycle }, events];
 };
 // Prefix `error.type` so overloads, rate limits, and quota errors are visible
 // even when the provider message is generic or empty.
@@ -775,6 +807,8 @@ const step = (state, event) => {
         return onContentBlockStop(state, event);
     if (event.type === "message_delta")
         return Effect.succeed(onMessageDelta(state, event));
+    if (event.type === "message_stop")
+        return Effect.succeed(onMessageStop(state));
     if (event.type === "error")
         return onError(event);
     return Effect.succeed([state, NO_EVENTS]);
@@ -795,7 +829,11 @@ export const protocol = Protocol.make({
     },
     stream: {
         event: Protocol.jsonEvent(AnthropicEvent),
-        initial: () => ({ tools: ToolStream.empty(), lifecycle: Lifecycle.initial() }),
+        initial: () => ({
+            tools: ToolStream.empty(),
+            reasoningSignatures: {},
+            lifecycle: Lifecycle.initial(),
+        }),
         step,
     },
 });

package/dist/protocols/utils/lifecycle.d.ts

@@ -6,6 +6,7 @@ export interface State {
 }
 export declare const initial: () => State;
 export declare const stepStart: (state: State, events: LLMEvent[]) => State;
+export declare const textStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
 export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string) => State;
 export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;

package/dist/protocols/utils/lifecycle.js

@@ -6,15 +6,18 @@ export const stepStart = (state, events) => {
     events.push(LLMEvent.stepStart({ index: 0 }));
     return { ...state, stepStarted: true };
 };
-export const textDelta = (state, events, id, text) => {
+export const textStart = (state, events, id, providerMetadata) => {
+    if (state.text.has(id))
+        return state;
     const stepped = stepStart(state, events);
-    if (stepped.text.has(id)) {
-        events.push(LLMEvent.textDelta({ id, text }));
-        return stepped;
-    }
-    events.push(LLMEvent.textStart({ id }), LLMEvent.textDelta({ id, text }));
+    events.push(LLMEvent.textStart({ id, providerMetadata }));
     return { ...stepped, text: new Set([...stepped.text, id]) };
 };
+export const textDelta = (state, events, id, text) => {
+    const started = textStart(state, events, id);
+    events.push(LLMEvent.textDelta({ id, text }));
+    return started;
+};
 export const reasoningStart = (state, events, id, providerMetadata) => {
     if (state.reasoning.has(id))
         return state;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16175",
+  "version": "0.0.0-next-16179",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-16175",
+    "@opencode-ai/http-recorder": "0.0.0-next-16179",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-16175",
+    "@opencode-ai/schema": "0.0.0-next-16179",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"