llm-stream-assemble 1.3.6 → 1.4.1

package/README.md

@@ -1,19 +1,19 @@
 # llm-stream-assemble
 
-![core](https://img.shields.io/badge/core-1.3.6-blue)
+![core](https://img.shields.io/badge/core-1.4.1-blue)
 ![node](https://img.shields.io/badge/node-%3E%3D18-339933)
 ![runtime deps](https://img.shields.io/badge/runtime_deps-0-brightgreen)
-![tests](https://img.shields.io/badge/tests-1019%2B_passing-brightgreen)
+![tests](https://img.shields.io/badge/tests-1183_passing-brightgreen)
 [![ci](https://github.com/01laky/llm-stream-assemble/actions/workflows/ci.yml/badge.svg)](https://github.com/01laky/llm-stream-assemble/actions/workflows/ci.yml)
-![status](https://img.shields.io/badge/status-stable_1.3.6-brightgreen)
+![status](https://img.shields.io/badge/status-stable_1.4.1-brightgreen)
 
 **One typed event model for every LLM stream** — text, tool calls, reasoning, JSON, usage, refusals, errors, and non-streaming responses.
 
-> A zero-dependency TypeScript layer for assembling **OpenAI**, **Anthropic**, **Google Gemini**, and **OpenAI-compatible** LLM streams into unified events — so you can stop hand-rolling provider parsers and keep one clean, typed event model across chat UIs, agents, proxies, and backends.
+> A zero-dependency TypeScript layer between raw LLM provider bytes and your app: six built-in adapters, thirteen host presets, and a single StreamEvent model for text, tools, reasoning, JSON, and lifecycle — from Ollama to Azure to Bedrock to Cloudflare Workers AI.
 
 Turn provider SSE fragments into typed events — **not another `+=` loop**.
 
-**Status:** Stable `1.3.6`. Five built-in adapters, thirteen OpenAI-compatible host presets (including **Azure OpenAI** and **Cloudflare Workers AI**), transforms, replay helpers, and examples are production-ready. Pin semver ranges as usual and review [CHANGELOG.md](./CHANGELOG.md) before major upgrades.
+**Status:** Stable `1.4.1`. Six built-in adapters, thirteen OpenAI-compatible host presets (including **Azure OpenAI** and **Cloudflare Workers AI**), transforms, replay helpers, and examples are production-ready. Pin semver ranges as usual and review [CHANGELOG.md](./CHANGELOG.md) before major upgrades.
 
 ---
 
@@ -138,13 +138,14 @@ Diagram sources: [`docs/img/`](./docs/img/) (Mermaid `.mmd` + committed SVG). Re
 
 ## Providers at a glance
 
-| Adapter                                 | Provider / API                                                                                                                                     | Import                                      |
-| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
-| `openaiChatAdapter()`                   | OpenAI Chat Completions                                                                                                                            | `llm-stream-assemble`                       |
-| `openaiCompatibleAdapter({ provider })` | Groq, DeepSeek, Mistral, Ollama, LM Studio, Together, Fireworks, OpenRouter, Perplexity, xAI, **Azure OpenAI**, **Cloudflare Workers AI**, generic | `llm-stream-assemble`                       |
-| `anthropicAdapter()`                    | Anthropic Messages                                                                                                                                 | `llm-stream-assemble`                       |
-| `openaiResponsesAdapter()`              | OpenAI Responses API                                                                                                                               | `llm-stream-assemble`                       |
-| `geminiAdapter()`                       | Google AI Gemini                                                                                                                                   | `llm-stream-assemble` or `/adapters/gemini` |
+| Adapter                                 | Provider / API                                                                                                                                     | Import                                       |
+| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| `openaiChatAdapter()`                   | OpenAI Chat Completions                                                                                                                            | `llm-stream-assemble`                        |
+| `openaiCompatibleAdapter({ provider })` | Groq, DeepSeek, Mistral, Ollama, LM Studio, Together, Fireworks, OpenRouter, Perplexity, xAI, **Azure OpenAI**, **Cloudflare Workers AI**, generic | `llm-stream-assemble`                        |
+| `anthropicAdapter()`                    | Anthropic Messages                                                                                                                                 | `llm-stream-assemble`                        |
+| `openaiResponsesAdapter()`              | OpenAI Responses API                                                                                                                               | `llm-stream-assemble`                        |
+| `geminiAdapter()`                       | Google AI Gemini                                                                                                                                   | `llm-stream-assemble` or `/adapters/gemini`  |
+| `bedrockAdapter()`                      | AWS Bedrock Converse / ConverseStream                                                                                                              | `llm-stream-assemble` or `/adapters/bedrock` |
 
 Full feature flags and quirks: [compatibility matrix](./docs/compatibility.md).
 
@@ -200,6 +201,7 @@ Pick an adapter in ~30 seconds:
 - **OpenAI Responses API** → `openaiResponsesAdapter()`
 - **Anthropic Messages** → `anthropicAdapter()`
 - **Google Gemini** → `geminiAdapter()`
+- **AWS Bedrock ConverseStream** → `bedrockAdapter()` (decoded JSON per event — see [Bedrock Usage](#bedrock-usage))
 - **Groq, Ollama, Azure, Cloudflare, OpenRouter, …** → `openaiCompatibleAdapter({ provider })`
 - **Non-streaming JSON body** → `assembleResponse(body, adapter)`
 - **React chat UI / full agent framework** → not this package — see [comparison](./docs/comparison.md)
@@ -271,6 +273,10 @@ for await (const event of assembleStream(response.body!, adapter)) {
 
 → [`examples/node-fetch/gemini.ts`](./examples/node-fetch/gemini.ts) · Usage: [Gemini](#gemini-usage)
 
+### AWS Bedrock
+
+→ [`examples/node-fetch/bedrock.ts`](./examples/node-fetch/bedrock.ts) · Usage: [Bedrock](#bedrock-usage) · Decode helper: [`examples/bedrock/README.md`](./examples/bedrock/README.md)
+
 ### Streaming JSON (structured output)
 
 ```ts
@@ -311,7 +317,7 @@ Wire unified events into **Hono**, **Express**, **Cloudflare Workers**, **LiteLL
 
 ### Core Usage
 
-The core pipeline works with any adapter that emits `RawChunk[]`, including the built-in OpenAI Chat, OpenAI-compatible, Anthropic Messages, OpenAI Responses, and Google Gemini adapters:
+The core pipeline works with any adapter that emits `RawChunk[]`, including the built-in OpenAI Chat, OpenAI-compatible, Anthropic Messages, OpenAI Responses, Google Gemini, and AWS Bedrock adapters:
 
 ```ts
 import { assembleFromPayloads, type StreamAdapter } from "llm-stream-assemble";
@@ -551,6 +557,54 @@ Subpath import: `import { geminiAdapter } from "llm-stream-assemble/adapters/gem
 
 Vertex AI and the Interactions API are out of scope for this adapter; see [compatibility matrix](./docs/compatibility.md).
 
+### Bedrock Usage
+
+`bedrockAdapter()` parses **decoded** AWS Bedrock **ConverseStream** JSON events — one ConverseStream envelope object per `parseChunk` call. Create one adapter instance per request/stream.
+
+Bedrock streaming responses are often `application/vnd.amazon.eventstream` (binary). **Decode EventStream bytes in your app, AWS SDK, or the example helper** before assembly — this library does not sign requests or parse binary framing.
+
+```
+Bedrock Runtime → EventStream bytes → [SDK or decode helper] → JSON strings
+  → bedrockAdapter().parseChunk / assembleFromPayloads / assembleStream → StreamEvent[]
+```
+
+**Recommended path:** use `@aws-sdk/client-bedrock-runtime` `ConverseStreamCommand`, iterate the async stream, `JSON.stringify` each event object, and feed lines to `assembleFromPayloads`. See [`examples/bedrock/README.md`](./examples/bedrock/README.md) and [`examples/node-fetch/bedrock.ts`](./examples/node-fetch/bedrock.ts).
+
+```ts
+import { assembleFromPayloads, bedrockAdapter } from "llm-stream-assemble";
+
+async function* decodedConverseEvents(sdkStream: AsyncIterable<Record<string, unknown>>) {
+	for await (const event of sdkStream) {
+		yield JSON.stringify(event);
+	}
+}
+
+for await (const event of assembleFromPayloads(
+	decodedConverseEvents(converseStream),
+	bedrockAdapter({ modelFamily: "auto" }),
+)) {
+	if (event.type === "text.delta") process.stdout.write(event.text);
+	if (event.type === "tool_call.done") console.log(event.name, event.args);
+}
+```
+
+**`modelFamily`** hints which ConverseStream dialect to prefer when envelopes overlap:
+
+| Value           | When to use                                                       |
+| --------------- | ----------------------------------------------------------------- |
+| `"auto"`        | Default — structural detection from payload shape                 |
+| `"anthropic"`   | Claude on Bedrock — reasoning deltas, Anthropic-style tool blocks |
+| `"nova"`        | Amazon Nova models                                                |
+| `"openai-like"` | Llama and other OpenAI-shaped delta fields                        |
+
+Use `bedrockAdapter({ jsonMode: true })` when structured JSON text blocks should map to `json.*` instead of `text.*`. Guardrail interventions map to `finish` with `content_filter`; trace details remain in `metadata.raw`.
+
+**Environment variables** for live smoke and examples: `AWS_REGION`, `BEDROCK_MODEL_ID`, plus standard AWS credential chain (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_PROFILE`, SSO). IAM and SigV4 signing stay outside this library.
+
+Subpath import: `import { bedrockAdapter } from "llm-stream-assemble/adapters/bedrock"`.
+
+Worker proxy recipe: [`examples/integrations/bedrock-worker-proxy.ts`](./examples/integrations/bedrock-worker-proxy.ts). EventStream decode helper (examples only): [`examples/bedrock/decode-event-stream.ts`](./examples/bedrock/decode-event-stream.ts).
+
 ---
 
 ## Transforms & replay
@@ -623,6 +677,7 @@ for await (const event of assembleFromFile(
 | [`examples/node-fetch/xai.ts`](./examples/node-fetch/xai.ts)                                     | xAI Grok streaming                               |
 | [`examples/node-fetch/anthropic.ts`](./examples/node-fetch/anthropic.ts)                         | Anthropic Messages                               |
 | [`examples/node-fetch/gemini.ts`](./examples/node-fetch/gemini.ts)                               | Google Gemini SSE                                |
+| [`examples/node-fetch/bedrock.ts`](./examples/node-fetch/bedrock.ts)                             | AWS Bedrock ConverseStream (decoded JSON)        |
 | [`examples/node-fetch/replay-fixture.ts`](./examples/node-fetch/replay-fixture.ts)               | Local fixture replay                             |
 | [`examples/proxy-safety/`](./examples/proxy-safety/)                                             | Proxy + browser client patterns                  |
 

package/dist/adapters/anthropic.cjs

@@ -1,5 +1,36 @@
 'use strict';
 
+// src/core/utils/object.ts
+function stripUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+}
+
+// src/adapters/errors.ts
+function libraryError(message) {
+  return new Error(`llm-stream-assemble: ${message}`);
+}
+function adapterScopedError(scope, message) {
+  return new Error(`llm-stream-assemble: ${scope}: ${message}`);
+}
+function providerErrorChunks(error, recoverable = false) {
+  return [
+    { kind: "provider-error", error, recoverable },
+    { kind: "finish", reason: "error" }
+  ];
+}
+function providerErrorChunksFromMessage(message, recoverable = false) {
+  return providerErrorChunks(libraryError(message), recoverable);
+}
+function providerErrorChunksFromPayload(errorPayload, scope, recoverable, fallbackMessage) {
+  const message = asString(errorPayload.message) ?? fallbackMessage;
+  const error = adapterScopedError(scope, message);
+  Object.defineProperty(error, "raw", {
+    value: errorPayload,
+    enumerable: false
+  });
+  return providerErrorChunks(error, recoverable);
+}
+
 // src/adapters/utils.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11,9 +42,7 @@ function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function optionalRawChunk(input) {
-  return Object.fromEntries(
-    Object.entries(input).filter(([, value]) => value !== void 0)
-  );
+  return stripUndefined(input);
 }
 function prefixedAdapterError(feature, message) {
   return adapterScopedError(feature, message);
@@ -37,21 +66,125 @@ function parseAdapterJSON(raw, feature) {
   }
 }
 
-// src/adapters/errors.ts
-function libraryError(message) {
-  return new Error(`llm-stream-assemble: ${message}`);
+// src/adapters/shared/anthropic-blocks.ts
+function anthropicResponseBlockChunks(block, index, context) {
+  return anthropicBlockStartChunks(block, index, { ...context, mode: "response" });
 }
-function adapterScopedError(scope, message) {
-  return new Error(`llm-stream-assemble: ${scope}: ${message}`);
+function anthropicBlockStartChunks(block, index, context) {
+  const mode = context.mode ?? "stream-start";
+  const blockType = asString(block.type) ?? "unknown";
+  switch (blockType) {
+    case "text": {
+      const text = asString(block.text);
+      if (!text) return [];
+      if (context.jsonMode) return [{ kind: "json-delta", delta: text }];
+      return [{ kind: "text-delta", text }];
+    }
+    case "thinking": {
+      const text = asString(block.thinking);
+      return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
+    }
+    case "redacted_thinking":
+      return [];
+    case "tool_use":
+      return anthropicToolUseBlockChunks(block, index, mode);
+    case "json": {
+      const text = asString(block.text) ?? asString(block.partial_json);
+      return text ? [{ kind: "json-delta", delta: text }] : [];
+    }
+    case "refusal": {
+      const text = asString(block.refusal) ?? asString(block.text);
+      return text ? [{ kind: "refusal-delta", text }] : [];
+    }
+    default:
+      return [];
+  }
 }
-function providerErrorChunks(error, recoverable = false) {
-  return [
-    { kind: "provider-error", error, recoverable },
-    { kind: "finish", reason: "error" }
-  ];
+function anthropicToolUseBlockChunks(block, index, mode) {
+  const id = asString(block.id);
+  const name = asString(block.name) ?? "unknown";
+  const chunks = [optionalRawChunk({ kind: "tool-start", id, name, index })];
+  const input = block.input;
+  if (input !== void 0 && !(isRecord(input) && Object.keys(input).length === 0)) {
+    chunks.push(
+      optionalRawChunk({ kind: "tool-args-delta", id, delta: JSON.stringify(input), index })
+    );
+  }
+  if (mode === "response") {
+    chunks.push(optionalRawChunk({ kind: "tool-done", id, index }));
+  }
+  return chunks;
 }
-function providerErrorChunksFromMessage(message, recoverable = false) {
-  return providerErrorChunks(libraryError(message), recoverable);
+
+// src/adapters/shared/parse-payload.ts
+function parseAdapterObjectPayload(raw, scope, options = {}) {
+  const { trim = true, allowDone = true } = options;
+  const input = trim ? raw.trim() : raw;
+  if (input.length === 0 || allowDone && input === "[DONE]") return null;
+  const payload = parseAdapterJSON(input, scope);
+  if (!isRecord(payload)) {
+    throw adapterScopedError(scope, "expected a JSON object");
+  }
+  return payload;
+}
+
+// src/adapters/shared/stop-reasons.ts
+function mapAnthropicLikeStopReason(value) {
+  switch (value) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "tool_use":
+      return "tool_calls";
+    case "max_tokens":
+      return "length";
+    case "content_filtered":
+    case "guardrail_intervened":
+    case "refusal":
+      return "content_filter";
+    default:
+      return "stop";
+  }
+}
+
+// src/adapters/shared/usage.ts
+var DEFAULT_ALIASES = {
+  input: ["inputTokens", "input_tokens", "promptTokens", "promptTokenCount", "inputTokenCount"],
+  output: [
+    "outputTokens",
+    "output_tokens",
+    "completionTokens",
+    "candidatesTokenCount",
+    "outputTokenCount"
+  ],
+  reasoning: ["reasoningTokens", "reasoning_tokens", "thoughtsTokenCount"],
+  total: ["totalTokens", "totalTokenCount", "total_tokens"]
+};
+function firstNumber(value, fields) {
+  if (!fields) return void 0;
+  for (const field of fields) {
+    const number = asNumber(value[field]);
+    if (number !== void 0) return number;
+  }
+  return void 0;
+}
+function buildUsageChunk(value, aliases = DEFAULT_ALIASES, options) {
+  if (!isRecord(value)) return void 0;
+  const inputTokens = firstNumber(value, aliases.input);
+  const outputTokens = firstNumber(value, aliases.output);
+  const reasoningTokens = firstNumber(value, aliases.reasoning);
+  const totalTokens = firstNumber(value, aliases.total);
+  if (inputTokens === void 0 && outputTokens === void 0 && reasoningTokens === void 0 && totalTokens === void 0) {
+    return void 0;
+  }
+  const raw = value;
+  return optionalRawChunk({
+    kind: "usage",
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    raw
+  });
 }
 
 // src/adapters/anthropic.ts
@@ -71,10 +204,8 @@ var AnthropicStreamParser = class {
   blocks = /* @__PURE__ */ new Map();
   sawFinish = false;
   parseChunk(raw) {
-    const payload = parseAdapterJSON(raw, "anthropicAdapter.parseChunk");
-    if (!isRecord(payload)) {
-      throw libraryError("anthropicAdapter.parseChunk expected a JSON object");
-    }
+    const payload = parseAdapterObjectPayload(raw, "anthropicAdapter.parseChunk");
+    if (!payload) return [];
     const type = asString(payload.type);
     switch (type) {
       case "ping":
@@ -92,7 +223,7 @@ var AnthropicStreamParser = class {
       case "message_stop":
         return this.messageStop();
       case "error":
-        return providerErrorChunks2(payload.error);
+        return providerErrorFromPayload(payload.error);
       default:
         throw libraryError(`anthropicAdapter.parseChunk unknown event type: ${String(type)}`);
     }
@@ -107,7 +238,7 @@ var AnthropicStreamParser = class {
     if (id || model) {
       chunks.push(optionalRawChunk({ kind: "metadata", responseId: id, model, raw: message }));
     }
-    const usage = usageChunk(message.usage);
+    const usage = buildUsageChunk(message.usage);
     if (usage) chunks.push(usage);
     return chunks;
   }
@@ -118,42 +249,16 @@ var AnthropicStreamParser = class {
     const blockType = asString(block.type) ?? "unknown";
     const state = { type: blockType };
     this.blocks.set(index, state);
-    switch (blockType) {
-      case "text": {
-        const text = asString(block.text);
-        return text ? [{ kind: "text-delta", text }] : [];
-      }
-      case "thinking": {
-        const text = asString(block.thinking);
-        return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
-      }
-      case "redacted_thinking":
-        return [];
-      case "tool_use": {
-        const id = asString(block.id);
-        const name = asString(block.name) ?? "unknown";
-        if (id) state.id = id;
-        state.name = name;
-        const chunks = [optionalRawChunk({ kind: "tool-start", id, name, index })];
-        const input = block.input;
-        if (input !== void 0 && !(isRecord(input) && Object.keys(input).length === 0)) {
-          chunks.push(
-            optionalRawChunk({ kind: "tool-args-delta", id, delta: JSON.stringify(input), index })
-          );
-        }
-        return chunks;
-      }
-      case "json": {
-        const text = asString(block.text) ?? asString(block.partial_json);
-        return text ? [{ kind: "json-delta", delta: text }] : [];
-      }
-      case "refusal": {
-        const text = asString(block.refusal) ?? asString(block.text);
-        return text ? [{ kind: "refusal-delta", text }] : [];
-      }
-      default:
-        return [];
+    if (blockType === "tool_use") {
+      const id = asString(block.id);
+      const name = asString(block.name) ?? "unknown";
+      if (id) state.id = id;
+      state.name = name;
     }
+    return anthropicBlockStartChunks(block, index, {
+      jsonMode: this.options.jsonMode,
+      mode: "stream-start"
+    });
   }
   contentBlockDelta(payload) {
     const index = asNumber(payload.index) ?? 0;
@@ -165,8 +270,9 @@ var AnthropicStreamParser = class {
       case "text_delta": {
         const text = asString(delta.text);
         if (!text) return [];
-        if (this.options.jsonMode || state?.type === "json")
+        if (this.options.jsonMode || state?.type === "json") {
           return [{ kind: "json-delta", delta: text }];
+        }
         if (state?.type === "refusal") return [{ kind: "refusal-delta", text }];
         return [{ kind: "text-delta", text }];
       }
@@ -198,7 +304,7 @@ var AnthropicStreamParser = class {
   }
   messageDelta(payload) {
     const chunks = [];
-    const usage = usageChunk(payload.usage);
+    const usage = buildUsageChunk(payload.usage);
     if (usage) chunks.push(usage);
     const delta = isRecord(payload.delta) ? payload.delta : void 0;
     const stopReason = delta ? asString(delta.stop_reason) : void 0;
@@ -220,91 +326,41 @@ function parseResponse(body, options) {
     throw libraryError("anthropicAdapter.parseResponse expected an Anthropic message object");
   }
   if (asString(body.type) === "error" || isRecord(body.error)) {
-    return providerErrorChunks2(body.error);
+    return providerErrorFromPayload(body.error);
   }
   const chunks = [];
   const id = asString(body.id);
   const model = asString(body.model);
   if (id) chunks.push({ kind: "message-start", id });
-  if (id || model)
+  if (id || model) {
     chunks.push(optionalRawChunk({ kind: "metadata", responseId: id, model, raw: body }));
-  const inputUsage = usageChunk(body.usage);
+  }
+  const inputUsage = buildUsageChunk(body.usage);
   if (inputUsage) chunks.push(inputUsage);
   const content = Array.isArray(body.content) ? body.content : [];
   for (let index = 0; index < content.length; index += 1) {
     const block = content[index];
     if (!isRecord(block)) continue;
-    chunks.push(...responseBlockChunks(block, index, options));
+    chunks.push(...anthropicResponseBlockChunks(block, index, { jsonMode: options.jsonMode }));
   }
   const reason = finishReason(asString(body.stop_reason));
   if (reason) chunks.push({ kind: "finish", reason });
   return chunks;
 }
-function responseBlockChunks(block, index, options) {
-  const type = asString(block.type);
-  switch (type) {
-    case "text": {
-      const text = asString(block.text);
-      if (!text) return [];
-      return options.jsonMode ? [{ kind: "json-delta", delta: text }] : [{ kind: "text-delta", text }];
-    }
-    case "thinking": {
-      const text = asString(block.thinking);
-      return text ? [{ kind: "reasoning-delta", text, variant: "detail" }] : [];
-    }
-    case "tool_use": {
-      const id = asString(block.id);
-      const name = asString(block.name) ?? "unknown";
-      const chunks = [optionalRawChunk({ kind: "tool-start", id, name, index })];
-      if (block.input !== void 0) {
-        chunks.push(
-          optionalRawChunk({
-            kind: "tool-args-delta",
-            id,
-            delta: JSON.stringify(block.input),
-            index
-          })
-        );
-      }
-      chunks.push(optionalRawChunk({ kind: "tool-done", id, index }));
-      return chunks;
-    }
-    case "refusal": {
-      const text = asString(block.refusal) ?? asString(block.text);
-      return text ? [{ kind: "refusal-delta", text }] : [];
-    }
-    default:
-      return [];
-  }
-}
 function finishReason(value) {
-  switch (value) {
-    case "end_turn":
-    case "stop_sequence":
-      return "stop";
-    case "max_tokens":
-      return "length";
-    case "tool_use":
-      return "tool_calls";
-    case "refusal":
-      return "content_filter";
-    case void 0:
-    case null:
-      return void 0;
-    default:
-      return "stop";
-  }
-}
-function usageChunk(value) {
-  if (!isRecord(value)) return void 0;
-  const inputTokens = asNumber(value.input_tokens);
-  const outputTokens = asNumber(value.output_tokens);
-  if (inputTokens === void 0 && outputTokens === void 0) return void 0;
-  return optionalRawChunk({ kind: "usage", inputTokens, outputTokens, raw: value });
+  if (value === void 0 || value === null) return void 0;
+  return mapAnthropicLikeStopReason(value);
 }
-function providerErrorChunks2(value) {
-  const message = isRecord(value) ? asString(value.message) : void 0;
-  return providerErrorChunksFromMessage(message ?? "Anthropic provider error", false);
+function providerErrorFromPayload(value) {
+  if (isRecord(value)) {
+    return providerErrorChunksFromPayload(
+      value,
+      "anthropicAdapter.parseChunk",
+      false,
+      "Anthropic provider error"
+    );
+  }
+  return providerErrorChunksFromMessage("Anthropic provider error", false);
 }
 
 exports.anthropicAdapter = anthropicAdapter;