@opencode-ai/ai 0.0.0-next-16111 → 0.0.0-next-16116

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

@@ -102,6 +102,13 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
                 readonly type: Schema.tag<"ephemeral">;
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"redacted_thinking">;
+            readonly data: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.tag<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"tool_use">;
             readonly id: Schema.String;
@@ -268,6 +275,13 @@ export declare const protocol: Protocol<{
                 readonly type: Schema.tag<"ephemeral">;
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"redacted_thinking">;
+            readonly data: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.tag<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"tool_use">;
             readonly id: Schema.String;
@@ -375,6 +389,7 @@ export declare const protocol: Protocol<{
         readonly type: string;
         readonly text?: string | undefined;
         readonly name?: string | undefined;
+        readonly data?: string | undefined;
         readonly content?: unknown;
         readonly id?: string | undefined;
         readonly input?: unknown;
@@ -483,6 +498,13 @@ export declare const route: Route<{
                 readonly type: Schema.tag<"ephemeral">;
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"redacted_thinking">;
+            readonly data: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.tag<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"tool_use">;
             readonly id: Schema.String;

package/dist/protocols/anthropic-messages.js

@@ -51,6 +51,14 @@ const AnthropicThinkingBlock = Schema.Struct({
     signature: Schema.optional(Schema.String),
     cache_control: Schema.optional(AnthropicCacheControl),
 });
+// Safety-filtered thinking arrives as an opaque encrypted `data` payload with
+// no visible text. It must round-trip verbatim so multi-turn thinking + tool
+// use conversations keep their reasoning continuity.
+const AnthropicRedactedThinkingBlock = Schema.Struct({
+    type: Schema.tag("redacted_thinking"),
+    data: Schema.String,
+    cache_control: Schema.optional(AnthropicCacheControl),
+});
 const AnthropicToolUseBlock = Schema.Struct({
     type: Schema.tag("tool_use"),
     id: Schema.String,
@@ -101,6 +109,7 @@ const AnthropicUserBlock = Schema.Union([
 const AnthropicAssistantBlock = Schema.Union([
     AnthropicTextBlock,
     AnthropicThinkingBlock,
+    AnthropicRedactedThinkingBlock,
     AnthropicToolUseBlock,
     AnthropicServerToolUseBlock,
     AnthropicServerToolResultBlock,
@@ -165,6 +174,9 @@ const AnthropicStreamBlock = Schema.Struct({
     text: Schema.optional(Schema.String),
     thinking: Schema.optional(Schema.String),
     signature: Schema.optional(Schema.String),
+    // redacted_thinking blocks arrive whole in content_block_start with the
+    // encrypted payload in `data`; there is no streaming delta sequence.
+    data: Schema.optional(Schema.String),
     input: Schema.optional(Schema.Unknown),
     // *_tool_result blocks arrive whole as content_block_start (no streaming
     // delta) with the structured payload in `content` and the originating
@@ -222,6 +234,12 @@ const signatureFromMetadata = (metadata) => {
         return undefined;
     return typeof anthropic.signature === "string" ? anthropic.signature : undefined;
 };
+const redactedDataFromMetadata = (metadata) => {
+    const anthropic = metadata?.anthropic;
+    if (!ProviderShared.isRecord(anthropic))
+        return undefined;
+    return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined;
+};
 const lowerTool = (breakpoints, tool, inputSchema) => ({
     name: tool.name,
     description: tool.description,
@@ -386,11 +404,16 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                     continue;
                 }
                 if (part.type === "reasoning") {
-                    content.push({
-                        type: "thinking",
-                        thinking: part.text,
-                        signature: part.encrypted ?? signatureFromMetadata(part.providerMetadata),
-                    });
+                    // Mirrors Vercel's @ai-sdk/anthropic: a signature marks visible
+                    // thinking; only signature-less parts carrying redactedData
+                    // round-trip as opaque redacted_thinking blocks.
+                    const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata);
+                    const redactedData = redactedDataFromMetadata(part.providerMetadata);
+                    if (signature === undefined && redactedData !== undefined) {
+                        content.push({ type: "redacted_thinking", data: redactedData });
+                        continue;
+                    }
+                    content.push({ type: "thinking", thinking: part.text, signature });
                     continue;
                 }
                 if (part.type === "tool-call") {
@@ -637,6 +660,19 @@ const onContentBlockStart = (state, event) => {
             events,
         ];
     }
+    // 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) {
+        const events = [];
+        return [
+            {
+                ...state,
+                lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${event.index ?? 0}`, anthropicMetadata({ redactedData: block.data })),
+            },
+            events,
+        ];
+    }
     const result = serverToolResultEvent(block);
     if (!result)
         return [state, NO_EVENTS];

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

@@ -63,12 +63,14 @@ declare const BedrockConverseBody: Schema.Struct<{
         readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly text: Schema.String;
         }>, Schema.Struct<{
-            readonly reasoningContent: Schema.Struct<{
-                readonly reasoningText: Schema.optional<Schema.Struct<{
+            readonly reasoningContent: Schema.Union<readonly [Schema.Struct<{
+                readonly reasoningText: Schema.Struct<{
                     readonly text: Schema.String;
                     readonly signature: Schema.optional<Schema.String>;
-                }>>;
-            }>;
+                }>;
+            }>, Schema.Struct<{
+                readonly redactedContent: Schema.String;
+            }>]>;
         }>, Schema.Struct<{
             readonly toolUse: Schema.Struct<{
                 readonly toolUseId: Schema.String;
@@ -194,12 +196,14 @@ export declare const protocol: Protocol<{
         readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly text: Schema.String;
         }>, Schema.Struct<{
-            readonly reasoningContent: Schema.Struct<{
-                readonly reasoningText: Schema.optional<Schema.Struct<{
+            readonly reasoningContent: Schema.Union<readonly [Schema.Struct<{
+                readonly reasoningText: Schema.Struct<{
                     readonly text: Schema.String;
                     readonly signature: Schema.optional<Schema.String>;
-                }>>;
-            }>;
+                }>;
+            }>, Schema.Struct<{
+                readonly redactedContent: Schema.String;
+            }>]>;
         }>, Schema.Struct<{
             readonly toolUse: Schema.Struct<{
                 readonly toolUseId: Schema.String;
@@ -289,6 +293,7 @@ export declare const protocol: Protocol<{
             readonly reasoningContent?: {
                 readonly text?: string | undefined;
                 readonly signature?: string | undefined;
+                readonly redactedContent?: string | undefined;
             } | undefined;
         } | undefined;
     } | undefined;
@@ -347,6 +352,7 @@ export declare const protocol: Protocol<{
             readonly reasoningContent?: {
                 readonly text?: string | undefined;
                 readonly signature?: string | undefined;
+                readonly redactedContent?: string | undefined;
             } | undefined;
         } | undefined;
     } | undefined;
@@ -429,12 +435,14 @@ export declare const route: Route<{
         readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
             readonly text: Schema.String;
         }>, Schema.Struct<{
-            readonly reasoningContent: Schema.Struct<{
-                readonly reasoningText: Schema.optional<Schema.Struct<{
+            readonly reasoningContent: Schema.Union<readonly [Schema.Struct<{
+                readonly reasoningText: Schema.Struct<{
                     readonly text: Schema.String;
                     readonly signature: Schema.optional<Schema.String>;
-                }>>;
-            }>;
+                }>;
+            }>, Schema.Struct<{
+                readonly redactedContent: Schema.String;
+            }>]>;
         }>, Schema.Struct<{
             readonly toolUse: Schema.Struct<{
                 readonly toolUseId: Schema.String;

package/dist/protocols/bedrock-converse.js

@@ -40,12 +40,15 @@ const BedrockToolResultBlock = Schema.Struct({
     }),
 });
 const BedrockReasoningBlock = Schema.Struct({
-    reasoningContent: Schema.Struct({
-        reasoningText: Schema.optional(Schema.Struct({
-            text: Schema.String,
-            signature: Schema.optional(Schema.String),
-        })),
-    }),
+    reasoningContent: Schema.Union([
+        Schema.Struct({
+            reasoningText: Schema.Struct({
+                text: Schema.String,
+                signature: Schema.optional(Schema.String),
+            }),
+        }),
+        Schema.Struct({ redactedContent: Schema.String }),
+    ]),
 });
 const BedrockUserBlock = Schema.Union([
     BedrockTextBlock,
@@ -124,6 +127,8 @@ const BedrockEvent = Schema.Struct({
             reasoningContent: Schema.optional(Schema.Struct({
                 text: Schema.optional(Schema.String),
                 signature: Schema.optional(Schema.String),
+                // Blob fields in Bedrock's JSON event stream are base64 strings.
+                redactedContent: Schema.optional(Schema.String),
             })),
         })),
     })),
@@ -178,6 +183,12 @@ const reasoningSignature = (part) => {
     return (part.encrypted ??
         (ProviderShared.isRecord(bedrock) && typeof bedrock.signature === "string" ? bedrock.signature : undefined));
 };
+const reasoningRedactedData = (part) => {
+    const bedrock = part.providerMetadata?.bedrock;
+    return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string"
+        ? bedrock.redactedData
+        : undefined;
+};
 const lowerToolCall = (part) => ({
     toolUse: {
         toolUseId: part.id,
@@ -259,11 +270,13 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
                 if (part.type === "reasoning") {
-                    content.push({
-                        reasoningContent: {
-                            reasoningText: { text: part.text, signature: reasoningSignature(part) },
-                        },
-                    });
+                    const signature = reasoningSignature(part);
+                    const redactedData = reasoningRedactedData(part);
+                    if (signature === undefined && redactedData !== undefined) {
+                        content.push({ reasoningContent: { redactedContent: redactedData } });
+                        continue;
+                    }
+                    content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } });
                     continue;
                 }
                 if (part.type === "tool-call") {
@@ -399,12 +412,15 @@ const step = (state, event) => Effect.gen(function* () {
         const index = event.contentBlockDelta.contentBlockIndex;
         const reasoning = event.contentBlockDelta.delta.reasoningContent;
         const events = [];
+        const lifecycle = reasoning.text
+            ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text)
+            : reasoning.redactedContent !== undefined
+                ? Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${index}`, bedrockMetadata({ redactedData: reasoning.redactedContent }))
+                : state.lifecycle;
         return [
             {
                 ...state,
-                lifecycle: reasoning.text
-                    ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text)
-                    : state.lifecycle,
+                lifecycle,
                 reasoningSignatures: reasoning.signature
                     ? { ...state.reasoningSignatures, [index]: reasoning.signature }
                     : state.reasoningSignatures,

package/dist/providers/amazon-bedrock.d.ts

@@ -76,12 +76,14 @@ export declare const routes: import("../route").Route<{
         readonly content: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
             readonly text: import("effect/Schema").String;
         }>, import("effect/Schema").Struct<{
-            readonly reasoningContent: import("effect/Schema").Struct<{
-                readonly reasoningText: import("effect/Schema").optional<import("effect/Schema").Struct<{
+            readonly reasoningContent: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly reasoningText: import("effect/Schema").Struct<{
                     readonly text: import("effect/Schema").String;
                     readonly signature: import("effect/Schema").optional<import("effect/Schema").String>;
-                }>>;
-            }>;
+                }>;
+            }>, import("effect/Schema").Struct<{
+                readonly redactedContent: import("effect/Schema").String;
+            }>]>;
         }>, import("effect/Schema").Struct<{
             readonly toolUse: import("effect/Schema").Struct<{
                 readonly toolUseId: import("effect/Schema").String;

package/dist/providers/anthropic-compatible.d.ts

@@ -105,6 +105,13 @@ export declare const routes: import("../route").Route<{
                 readonly type: import("effect/Schema").tag<"ephemeral">;
                 readonly ttl: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").tag<"redacted_thinking">;
+            readonly data: import("effect/Schema").String;
+            readonly cache_control: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").tag<"ephemeral">;
+                readonly ttl: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").tag<"tool_use">;
             readonly id: import("effect/Schema").String;

package/dist/providers/anthropic.d.ts

@@ -91,6 +91,13 @@ export declare const routes: import("../route").Route<{
                 readonly type: import("effect/Schema").tag<"ephemeral">;
                 readonly ttl: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").tag<"redacted_thinking">;
+            readonly data: import("effect/Schema").String;
+            readonly cache_control: import("effect/Schema").optional<import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").tag<"ephemeral">;
+                readonly ttl: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").tag<"tool_use">;
             readonly id: import("effect/Schema").String;

package/dist/providers/google-vertex-messages.d.ts

@@ -114,6 +114,13 @@ export declare const routes: Route<{
                 readonly type: Schema.tag<"ephemeral">;
                 readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
             }>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.tag<"redacted_thinking">;
+            readonly data: Schema.String;
+            readonly cache_control: Schema.optional<Schema.Struct<{
+                readonly type: Schema.tag<"ephemeral">;
+                readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+            }>>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"tool_use">;
             readonly id: Schema.String;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-16111",
+  "version": "0.0.0-next-16116",
   "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-16111",
+    "@opencode-ai/http-recorder": "0.0.0-next-16116",
     "@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-16111",
+    "@opencode-ai/schema": "0.0.0-next-16116",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"