@opencode/ai 2.0.18 → 2.0.20

package/README.md

@@ -129,8 +129,9 @@ VercelAIGateway.configure().experimental.evaluation("typesafe-ai/jev")
 
 OpenRouter reads `OPENROUTER_API_KEY`. Vercel reads `AI_GATEWAY_API_KEY`, then `VERCEL_OIDC_TOKEN`.
 The common API uses `boolean`; System One routes lower it to native `noul`.
-Choice and score confidence plus score legends remain available in provider metadata, and the
-provider's rounded probabilities are returned unchanged.
+Choice and score answers include `confidence` when the provider returns it, such as
+`response.answers.department.confidence`. Score legends remain available in provider metadata, and
+the provider's rounded probabilities are returned unchanged.
 
 ## Alibaba Cloud Model Studio
 
@@ -752,7 +753,10 @@ const events = Video.stream({ model: Runway.configure({ apiKey }).video("gen4.5"
 
 Status polls, result fetches, cancels, and asset downloads all run through the same request executor with the route's
 auth. `Generation.await` and `Generation.events` fail with a
-`Timeout` reason when `poll.timeout` (default 10 minutes) elapses. Failed,
+`Timeout` reason when `poll.timeout` (default 10 minutes) elapses. Status polls and result fetches retry transient
+failures (rate limits, provider 5xx, network errors) with backoff that honors `retry-after`, always within
+`poll.timeout`; submits and cancels never retry. Interrupting a wait (or aborting its `signal`) does not cancel the
+provider job, which keeps running and billing: call `cancel()` to stop it. Failed,
 cancelled, and expired generations fail typed with the provider's terminal document on `reason.body`; moderation
 outcomes (Veo `raiMediaFilteredReasons`, xAI `respect_moderation`, Runway `SAFETY.*` codes) surface as `notices` when
 a video is still returned and as a `ContentPolicy` reason when nothing is.
@@ -773,7 +777,9 @@ Provider notes:
 The promise client exposes the same surface: `ai.video.start(...)` resolves to a handle with `await`, `events`,
 `result`, `refresh`, `cancel`, and `token`; `ai.video.generate`, `ai.video.resume(model, token)`, and
 `ai.video.stream` mirror the Effect API. The handle's `status` and `progress` are a snapshot from when it was
-created; `refresh()` resolves to a new handle.
+created; `refresh()` resolves to a new handle. Every promise method and stream accepts `{ signal }`: like `fetch`,
+aborting rejects the Promise or throws from the `for await` loop with `signal.reason` (an `AbortError` `DOMException`
+unless `abort(reason)` passed one), while `break` stops a stream without throwing.
 
 ```ts
 import { ai } from "@opencode/ai/promise"
@@ -871,11 +877,12 @@ for await (const event of ai.speech.stream({ model, text: "Hello from OpenCode."
 ## Transcription
 
 Transcription (speech-to-text) is the one modality whose providers use every route kind: OpenAI and Gemini stream,
-Deepgram answers inline, and AssemblyAI is queued. `Transcription.generate` and `Transcription.stream` work on all of
-them; `Transcription.start` / `resume` return a `Generation` on queued routes and fail with `UnsupportedOperation`
-elsewhere. Models come from `.transcription(...)` selectors on the `OpenAI`, `Google`, `Deepgram`, and `AssemblyAI`
-facades. Common fields (`language`, `prompt`, `timestamps: "none" | "segment" | "word"`, `diarize`, `speakers`) lower
-natively or fail with a typed `AIError` before any network call; a route may return more than asked.
+Deepgram and ElevenLabs answer inline, and AssemblyAI is queued. `Transcription.generate` and `Transcription.stream`
+work on all of them; `Transcription.start` / `resume` return a `Generation` on queued routes and fail with
+`UnsupportedOperation` elsewhere. Models come from `.transcription(...)` selectors on the `OpenAI`, `Google`,
+`Deepgram`, `ElevenLabs`, and `AssemblyAI` facades. Common fields (`language`, `prompt`,
+`timestamps: "none" | "segment" | "word"`, `diarize`, `speakers`) lower natively or fail with a typed `AIError` before
+any network call; a route may return more than asked.
 
 ```ts
 import { Console, Effect, Stream } from "effect"
@@ -887,7 +894,7 @@ const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })
 const program = Effect.gen(function* () {
   const audio = yield* Media.file("./call.mp3")
 
-  // Speaker-labelled segments; labels are provider-native strings ("A", "0", "spk:0").
+  // Speaker-labelled segments; labels are provider-native strings ("A", "0", "spk:0", "speaker_0").
   const response = yield* Transcription.generate({
     model: Deepgram.configure({ apiKey }).transcription("nova-3"),
     audio,
@@ -897,7 +904,7 @@ const program = Effect.gen(function* () {
   response.text // "Hello from OpenCode."
   response.segments // [{ text, startSeconds, endSeconds, speaker: "0" }]
   response.words // [{ text, startSeconds, endSeconds, speaker, confidence }]
-  response.language // the provider's own value, lowercased ("en", "english", "en_us")
+  response.language // the provider's own value, lowercased ("en", "eng", "english", "en_us")
 
   // Text deltas as the model transcribes, then one finish carrying the whole transcript.
   yield* Transcription.stream({ model: openai.transcription("gpt-4o-mini-transcribe"), audio }).pipe(
@@ -921,7 +928,12 @@ Provider notes:
 - **OpenAI** takes inline audio only; `diarize` needs `gpt-4o-transcribe-diarize`, timestamps need `whisper-1`, and `whisper-1` does not stream.
 - **Gemini** needs a transcribe model (`gemini-3.5-transcribe`); `prompt` and `speakers` fail typed.
 - **Deepgram** detects the language unless `language` is set; vocabulary goes in `providerOptions.keyterm`.
-- **AssemblyAI** uploads inline audio before submitting and is the only route that accepts `speakers`.
+- **ElevenLabs** (`scribe_v2`) uploads inline audio as the multipart `file` and sends a URL as `source_url`. Words
+  always carry timestamps, and segments are speaker turns, so `diarize`, `timestamps: "segment"`, or `speakers` turns
+  on diarization. `speakers` is an upper bound (`num_speakers`); `prompt` fails typed (vocabulary goes in
+  `providerOptions.keyterms`), as do webhook delivery and per-channel output (`use_multi_channel` without
+  `multichannel_output_style: "combined"`).
+- **AssemblyAI** uploads inline audio before submitting and treats `speakers` as the exact speaker count.
 
 The promise client mirrors the Effect API:
 

package/dist/cache-policy.js

@@ -36,8 +36,15 @@ const resolve = (policy) => {
 // prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
 // whole policy pass for these — emitting hints would be harmless but pointless.
 const RESPECTS_INLINE_HINTS = new Set([
+    "alibaba-messages",
     "anthropic-messages",
+    "anthropic-compatible-messages",
+    "cloudflare-ai-gateway-messages",
     "google-vertex-messages",
+    "meta-messages",
+    "minimax-messages",
+    "moonshot-messages",
+    "zai-coding-messages",
     "bedrock-converse",
     "openrouter",
 ]);

package/dist/experimental/evaluation.d.ts

@@ -54,12 +54,14 @@ export declare const ChoiceAnswer: Schema.Struct<{
     readonly type: Schema.Literal<"choice">;
     readonly choice: Schema.String;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>;
 export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswer>;
 export declare const ScoreAnswer: Schema.Struct<{
     readonly type: Schema.Literal<"score">;
     readonly score: Schema.Number;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>;
 export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswer>;
 export declare const BooleanAnswer: Schema.Struct<{
@@ -71,10 +73,12 @@ export declare const EvaluationAnswer: Schema.toTaggedUnion<"type", readonly [Sc
     readonly type: Schema.Literal<"choice">;
     readonly choice: Schema.String;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"score">;
     readonly score: Schema.Number;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"boolean">;
     readonly probability: Schema.Number;
@@ -87,6 +91,7 @@ export type AnswerFor<Question extends EvaluationQuestion> = Question extends {
     readonly type: "choice";
     readonly choice: Extract<keyof Criteria, string>;
     readonly probabilities?: Readonly<Record<Extract<keyof Criteria, string>, number>>;
+    readonly confidence?: number;
 } : Question extends {
     readonly type: "score";
 } ? ScoreAnswer : BooleanAnswer;
@@ -206,10 +211,12 @@ declare const EvaluationResponse_base: Schema.Class<EvaluationResponse, Schema.S
         readonly type: Schema.Literal<"choice">;
         readonly choice: Schema.String;
         readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+        readonly confidence: Schema.optional<Schema.Number>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"score">;
         readonly score: Schema.Number;
         readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+        readonly confidence: Schema.optional<Schema.Number>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"boolean">;
         readonly probability: Schema.Number;

package/dist/experimental/evaluation.js

@@ -33,11 +33,13 @@ export const ChoiceAnswer = Schema.Struct({
     type: Schema.Literal("choice"),
     choice: Schema.String,
     probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+    confidence: Schema.optional(Probability),
 });
 export const ScoreAnswer = Schema.Struct({
     type: Schema.Literal("score"),
     score: Schema.Number,
     probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+    confidence: Schema.optional(Probability),
 });
 export const BooleanAnswer = Schema.Struct({
     type: Schema.Literal("boolean"),

package/dist/experimental/system-one.js

@@ -80,34 +80,37 @@ export const model = (cfg) => EvaluationModel.make({
             const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
             const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
-            const confidence = {};
             const legend = {};
             const answers = Object.fromEntries(Object.entries(data.answers).map(([id, answer]) => {
                 if (answer.type === "noul")
                     return [id, { type: "boolean", probability: answer.noul }];
                 if (answer.type === "choice") {
-                    if (answer.confidence !== undefined)
-                        confidence[id] = answer.confidence;
                     return [
                         id,
                         {
                             type: "choice",
                             choice: answer.choice,
                             probabilities: answer.probabilities,
+                            ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
                         },
                     ];
                 }
-                if (answer.confidence !== undefined)
-                    confidence[id] = answer.confidence;
                 if (answer.legend !== undefined)
                     legend[id] = answer.legend;
-                return [id, { type: "score", score: answer.score, probabilities: answer.probabilities }];
+                return [
+                    id,
+                    {
+                        type: "score",
+                        score: answer.score,
+                        probabilities: answer.probabilities,
+                        ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
+                    },
+                ];
             }));
             const meta = {
                 ...(data.id === undefined ? {} : { responseId: data.id }),
                 ...(data.provider === undefined ? {} : { provider: data.provider }),
                 ...data.provider_metadata?.[cfg.providerMetadataKey],
-                ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
                 ...(Object.keys(legend).length === 0 ? {} : { legend }),
             };
             return new EvaluationResponse({

package/dist/generation.d.ts

@@ -72,8 +72,8 @@ export declare class Generation<Response> {
      */
     events(options?: AwaitOptions): Stream.Stream<Event, AIError>;
     private event;
-    private timeoutError;
     private poll;
     private schedule;
 }
+/** `events` followed by the expanded result, with the result fetch bounded by the same `poll.timeout` deadline. */
 export declare const resultEvents: <Response, A>(generation: Generation<Response>, expand: (response: Response) => ReadonlyArray<A>, options?: AwaitOptions) => Stream.Stream<Observation | A, AIError>;

package/dist/generation.js

@@ -56,7 +56,7 @@ export class Generation {
         const settled = this.terminal ? Effect.succeed(this) : this.poll(options?.poll);
         return settled.pipe(
         // Non-completed terminal states also go through `result` so the route can surface its provider failure body.
-        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => this.timeoutError(timeout) }));
+        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => timeoutError(this.id, timeout) }));
     }
     cancel() {
         return this.route.cancel ?? Effect.void;
@@ -73,14 +73,7 @@ export class Generation {
         const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
         return Stream.unwrap(Clock.currentTimeMillis.pipe(Effect.map((start) => {
             const deadline = start + Duration.toMillis(timeout);
-            // Fail before polling once the deadline has passed: a fast status request could otherwise win the zero-budget
-            // race and schedule another zero-delay poll.
-            const refresh = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => now >= deadline
-                ? this.timeoutError(timeout)
-                : this.refresh().pipe(Effect.timeoutOrElse({
-                    duration: Duration.millis(deadline - now),
-                    orElse: () => this.timeoutError(timeout),
-                }))));
+            const refresh = within(this.refresh(), this.id, timeout, deadline);
             const schedule = this.schedule(options?.poll).pipe(Schedule.modifyDelay((meta) => Effect.succeed(Duration.min(meta.duration, Duration.millis(Math.max(0, deadline - meta.now))))));
             return Stream.fromEffectSchedule(refresh, schedule).pipe(Stream.takeUntil((generation) => generation.terminal), Stream.map((generation) => generation.event()));
         })));
@@ -92,14 +85,6 @@ export class Generation {
             return { type: "generation-queued", id: this.id, position: this.position };
         return { type: "generation-progress", id: this.id, progress: this.progress };
     }
-    timeoutError(timeout) {
-        return new AIError({
-            reason: new TimeoutError({
-                message: `Generation ${this.id} did not finish within ${Duration.format(timeout)}`,
-                timeoutMs: Duration.toMillis(timeout),
-            }),
-        });
-    }
     poll(poll) {
         return this.refresh().pipe(Effect.repeat({ schedule: this.schedule(poll), until: (generation) => generation.terminal }));
     }
@@ -107,4 +92,24 @@ export class Generation {
         return Schedule.spaced(poll?.interval ?? DEFAULT_POLL_INTERVAL);
     }
 }
-export const resultEvents = (generation, expand, options) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(Effect.map(generation.result(), expand))));
+/** `events` followed by the expanded result, with the result fetch bounded by the same `poll.timeout` deadline. */
+export const resultEvents = (generation, expand, options) => {
+    const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
+    return Stream.unwrap(Clock.currentTimeMillis.pipe(Effect.map((start) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(within(generation.result(), generation.id, timeout, start + Duration.toMillis(timeout)).pipe(Effect.map(expand))))))));
+};
+/**
+ * Run `effect` within the time left until `deadline`. Fails before starting once the deadline has passed: a fast
+ * request could otherwise win the zero-budget race and schedule another zero-delay poll.
+ */
+const within = (effect, id, timeout, deadline) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => now >= deadline
+    ? Effect.fail(timeoutError(id, timeout))
+    : effect.pipe(Effect.timeoutOrElse({
+        duration: Duration.millis(deadline - now),
+        orElse: () => Effect.fail(timeoutError(id, timeout)),
+    }))));
+const timeoutError = (id, timeout) => new AIError({
+    reason: new TimeoutError({
+        message: `Generation ${id} did not finish within ${Duration.format(timeout)}`,
+        timeoutMs: Duration.toMillis(timeout),
+    }),
+});

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js";
 export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, LLMClientService, } from "./route/client.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";

package/dist/index.js

@@ -4,7 +4,7 @@ export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export { Image } from "./image.js";

package/dist/llm.d.ts

@@ -184,8 +184,8 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "tool-error";
-        readonly name: string;
         readonly message: string;
+        readonly name: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {

package/dist/promise.d.ts

@@ -30,7 +30,7 @@ export type GenerationHandle<Response> = Snapshot & {
     /** Serializable JSON; pass it back to `resume` from another process. */
     readonly token: unknown;
     readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
-    /** Status observations until the first terminal one, polling like `await`; abort ends iteration without throwing. */
+    /** Status observations until the first terminal one, polling like `await`; abort throws `signal.reason`. */
     readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>;
     /** The result without polling; fails when the generation has not completed. */
     readonly result: (options?: RunOptions) => Promise<Response>;
@@ -211,8 +211,8 @@ export declare const make: (options?: Options) => {
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -698,8 +698,8 @@ export declare const ai: {
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {

package/dist/promise.js

@@ -10,21 +10,22 @@ import { Speech } from "./speech.js";
 import { Transcription, } from "./transcription.js";
 import { fileMediaType } from "./utils/media-type.js";
 import { Video } from "./video.js";
+// Fails with `signal.reason` so aborted calls reject and aborted streams throw like `fetch`: an `AbortError` by default.
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
         if (signal.aborted) {
-            resume(Effect.void);
+            resume(Effect.fail(signal.reason));
             return;
         }
-        const onAbort = () => resume(Effect.void);
+        const onAbort = () => resume(Effect.fail(signal.reason));
         signal.addEventListener("abort", onAbort, { once: true });
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
     const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
     /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
-    const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
+    const run = (effect, options) => runtime.runPromise(Effect.raceFirst(effect, abortEffect(options?.signal)));
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
     const handle = (generation) => ({
         ...generation.snapshot,

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

@@ -90,12 +90,17 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -208,6 +213,7 @@ export declare const protocol: Protocol<{
                 } | null | undefined;
                 readonly id?: string | null | undefined;
                 readonly index?: number | null | undefined;
+                readonly extra_content?: unknown;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;

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

@@ -77,8 +77,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -114,8 +114,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -190,21 +190,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -236,6 +225,17 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;

package/dist/protocols/anthropic-messages.js

@@ -13,6 +13,7 @@ import { JsonObject, knownString, optionalArray, optionalNull, ProviderShared }
 import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate, resolveEffortUpdates } from "../effort-updates.js";
 import * as Cache from "./utils/cache.js";
+import { claudeVersion, supportsThinkingBlockBinding, THINKING_BINDING_BETA } from "./utils/claude-model.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "anthropic-messages";
@@ -850,20 +851,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
     }
     return messages;
 });
-// Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-const claudeVersion = (id) => {
-    const match = /(?:^|[./])claude-(?<family>[a-z]+)-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/.exec(id.toLowerCase())?.groups;
-    if (!match)
-        return undefined;
-    return { family: match.family, major: Number(match.major), minor: Number(match.minor ?? 0) };
-};
-const supportsThinkingBlockBinding = (model) => {
-    const override = model.compatibility?.supportsThinkingBlockBinding;
-    if (override !== undefined)
-        return override;
-    const version = claudeVersion(model.id);
-    return version !== undefined && (version.major > 5 || (version.major === 5 && version.minor >= 1));
-};
 const supportsEffortUpdates = (model) => {
     const override = model.compatibility?.supportsEffortUpdates;
     if (override !== undefined)
@@ -1437,7 +1424,7 @@ function requiredBetaHeaders(body) {
         betas.push("mid-conversation-output-config-2026-07-01");
     const thinking = body.thinking;
     if (thinking && thinking.type !== "disabled" && thinking.block_binding)
-        betas.push("thinking-binding-controls-2026-08-01");
+        betas.push(THINKING_BINDING_BETA);
     return betas;
 }
 export const route = Route.make({

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

@@ -141,7 +141,7 @@ interface ParserState {
     readonly hasToolCalls: boolean;
     readonly lifecycle: Lifecycle.State;
     readonly reasoningSignatures: Readonly<Record<number, string>>;
-    readonly reasoningRedactedContent: Readonly<Record<number, ReadonlyArray<Uint8Array>>>;
+    readonly reasoningRedactedContent: Readonly<Record<number, Uint8Array[]>>;
 }
 /**
  * The Bedrock Converse protocol — request body construction, body schema, and

package/dist/protocols/bedrock-converse.js

@@ -9,6 +9,7 @@ import { JsonObject, optionalArray, ProviderShared } from "./shared.js";
 import { BedrockAuth } from "./utils/bedrock-auth.js";
 import { BedrockCache } from "./utils/bedrock-cache.js";
 import { BedrockMedia } from "./utils/bedrock-media.js";
+import { supportsThinkingBlockBinding, THINKING_BINDING_BETA } from "./utils/claude-model.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
 import { ToolStream } from "./utils/tool-stream.js";
@@ -351,18 +352,33 @@ const Options = Schema.Struct({
 const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options));
 // Claude on Bedrock requires the thinking budget below `maxTokens`, with a minimum of 1,024.
 const MIN_THINKING_BUDGET = 1_024;
+const isThinkingDisabled = Schema.is(Schema.Struct({
+    additionalModelRequestFields: Schema.Struct({ thinking: Schema.Struct({ type: Schema.Literal("disabled") }) }),
+}));
+// Claude 5.1+ binds each thinking signature to the prefix above it. Ask Bedrock to drop the affected blocks instead of
+// failing when that prefix changes. `http.body` overlays this field by field, so callers can still override it.
+const applyThinkingBindingDefault = (request, thinking) => {
+    if (isThinkingDisabled(request.http?.body))
+        return thinking;
+    if (!supportsThinkingBlockBinding(request.model))
+        return thinking;
+    return {
+        ...(thinking ?? { type: "adaptive" }),
+        block_binding: { prefix_mismatch_behavior: "drop_block" },
+    };
+};
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request) {
     const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined;
     const flattened = ProviderShared.flattenToolRequest(request);
     const generation = request.generation;
     const options = yield* decodeOptions(request.providerOptions ?? {});
     const maxTokens = isNova2(request.model) && isHighReasoningEffort(request.http?.body) ? undefined : generation?.maxTokens;
-    const thinking = options.thinking === undefined
+    const thinking = applyThinkingBindingDefault(request, options.thinking === undefined
         ? undefined
         : {
             type: "enabled",
             budget_tokens: ProviderShared.fitThinkingBudget(options.thinking.budgetTokens, maxTokens, MIN_THINKING_BUDGET),
-        };
+        });
     // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
     // tools → system → messages order to favour the highest-impact prefixes.
     const breakpoints = BedrockCache.breakpoints(request.model.id);
@@ -407,6 +423,8 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
             : {
                 ...(generation?.topK === undefined ? {} : { top_k: generation.topK }),
                 ...(thinking === undefined ? {} : { thinking }),
+                // Converse takes Anthropic betas in the body, and Bedrock rejects `block_binding` without this one.
+                ...(thinking?.block_binding === undefined ? {} : { anthropic_beta: [THINKING_BINDING_BETA] }),
             },
     };
 });
@@ -478,25 +496,29 @@ const step = (state, event) => Effect.gen(function* () {
         const index = event.contentBlockDelta.contentBlockIndex;
         const reasoning = event.contentBlockDelta.delta.reasoningContent;
         const events = [];
-        const redactedChunks = yield* (() => {
+        const redactedChunk = yield* (() => {
             if (reasoning.redactedContent === undefined)
                 return Effect.succeed(undefined);
-            return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(Effect.map((chunk) => [...(state.reasoningRedactedContent[index] ?? []), chunk]), Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
+            return Effect.fromResult(Encoding.decodeBase64(reasoning.redactedContent)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Bedrock Converse reasoningContent.redactedContent contains invalid base64 data", undefined, cause)));
         })();
-        const redactedData = redactedChunks === undefined ? reasoning.data : encodeRedactedContent(redactedChunks);
+        const redactedChunks = state.reasoningRedactedContent[index] ?? [];
+        if (redactedChunk !== undefined)
+            redactedChunks.push(redactedChunk);
         const metadata = (() => {
             if (reasoning.signature)
                 return providerMetadata(state.providerMetadataKey, { signature: reasoning.signature });
-            if (redactedData !== undefined)
-                return providerMetadata(state.providerMetadataKey, { redactedData });
+            if (redactedChunk === undefined && reasoning.data !== undefined)
+                return providerMetadata(state.providerMetadataKey, { redactedData: reasoning.data });
         })();
         const lifecycle = (() => {
-            if (reasoning.text === undefined && metadata === undefined)
-                return state.lifecycle;
-            return Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata);
+            if (reasoning.text !== undefined || metadata !== undefined)
+                return Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata);
+            if (redactedChunk !== undefined)
+                return Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${index}`);
+            return state.lifecycle;
         })();
         const reasoningRedactedContent = (() => {
-            if (redactedChunks !== undefined)
+            if (redactedChunk !== undefined)
                 return { ...state.reasoningRedactedContent, [index]: redactedChunks };
             if (reasoning.data === undefined)
                 return state.reasoningRedactedContent;
@@ -609,7 +631,11 @@ const onHalt = (state) => {
         return state.finishReason.normalized;
     })();
     const events = [];
-    Lifecycle.finish(state.lifecycle, events, {
+    const lifecycle = Object.entries(state.reasoningRedactedContent).reduce((current, [index, chunks]) => {
+        const signature = state.reasoningSignatures[Number(index)];
+        return Lifecycle.reasoningEnd(current, events, `reasoning-${index}`, providerMetadata(state.providerMetadataKey, signature ? { signature } : { redactedData: encodeRedactedContent(chunks) }));
+    }, state.lifecycle);
+    Lifecycle.finish(lifecycle, events, {
         reason: {
             ...state.finishReason,
             normalized,