llm-stream-assemble 1.4.1 → 1.5.0

package/README.md

@@ -1,19 +1,19 @@
 # llm-stream-assemble
 
-![core](https://img.shields.io/badge/core-1.4.1-blue)
+![core](https://img.shields.io/badge/core-1.5.0-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-1183_passing-brightgreen)
+![tests](https://img.shields.io/badge/tests-1316_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.4.1-brightgreen)
+![status](https://img.shields.io/badge/status-stable_1.5.0-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 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.
+> A zero-dependency TypeScript layer between raw LLM provider bytes and your app: seven 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 Cohere to Cloudflare Workers AI.
 
 Turn provider SSE fragments into typed events — **not another `+=` loop**.
 
-**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.
+**Status:** Stable `1.5.0`. Seven 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.
 
 ---
 
@@ -146,6 +146,7 @@ Diagram sources: [`docs/img/`](./docs/img/) (Mermaid `.mmd` + committed SVG). Re
 | `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` |
+| `cohereAdapter()`                       | Cohere Chat v2 (`api.cohere.com/v2/chat`)                                                                                                          | `llm-stream-assemble` or `/adapters/cohere`  |
 
 Full feature flags and quirks: [compatibility matrix](./docs/compatibility.md).
 
@@ -202,6 +203,7 @@ Pick an adapter in ~30 seconds:
 - **Anthropic Messages** → `anthropicAdapter()`
 - **Google Gemini** → `geminiAdapter()`
 - **AWS Bedrock ConverseStream** → `bedrockAdapter()` (decoded JSON per event — see [Bedrock Usage](#bedrock-usage))
+- **Cohere Chat v2 SSE** → `cohereAdapter()` (not OpenAI-compatible — see [Cohere Usage](#cohere-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)
@@ -277,6 +279,10 @@ for await (const event of assembleStream(response.body!, adapter)) {
 
 → [`examples/node-fetch/bedrock.ts`](./examples/node-fetch/bedrock.ts) · Usage: [Bedrock](#bedrock-usage) · Decode helper: [`examples/bedrock/README.md`](./examples/bedrock/README.md)
 
+### Cohere Chat v2
+
+→ [`examples/node-fetch/cohere.ts`](./examples/node-fetch/cohere.ts) · Usage: [Cohere](#cohere-usage)
+
 ### Streaming JSON (structured output)
 
 ```ts
@@ -317,7 +323,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, Google Gemini, and AWS Bedrock 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, AWS Bedrock, and Cohere adapters:
 
 ```ts
 import { assembleFromPayloads, type StreamAdapter } from "llm-stream-assemble";
@@ -605,6 +611,41 @@ Subpath import: `import { bedrockAdapter } from "llm-stream-assemble/adapters/be
 
 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).
 
+### Cohere Usage
+
+`cohereAdapter()` parses Cohere Chat **v2** SSE events from `https://api.cohere.com/v2/chat` and non-streaming v2 response bodies. Create one adapter instance per request/stream. Cohere is **not** OpenAI-compatible — use `cohereAdapter()`, not `openaiCompatibleAdapter()`.
+
+Core `parseSSE()` frames the HTTP body; `assembleStream` yields one JSON payload string per `data:` line to `cohereAdapter().parseChunk`.
+
+```ts
+import { assembleStream, cohereAdapter } from "llm-stream-assemble";
+
+const response = await fetch("https://api.cohere.com/v2/chat", {
+	method: "POST",
+	headers: {
+		Authorization: `Bearer ${process.env.COHERE_API_KEY}`,
+		"Content-Type": "application/json",
+	},
+	body: JSON.stringify({
+		model: "command-r-plus-08-2024",
+		messages: [{ role: "user", content: "Hello" }],
+		stream: true,
+	}),
+});
+
+for await (const event of assembleStream(response.body!, cohereAdapter())) {
+	if (event.type === "text.delta") process.stdout.write(event.text);
+	if (event.type === "reasoning.delta") process.stdout.write(event.text);
+	if (event.type === "tool_call.done") console.log(event.name, event.args);
+}
+```
+
+Use `cohereAdapter({ jsonMode: true })` when structured JSON output should map to `json.*` instead of `text.*`. **`tool-plan-delta`** events map to `reasoning.*` with `variant: "detail"`. **`citation-start`** payloads are preserved in `metadata.raw` — there are no dedicated `citation.*` unified events in 1.x. Legacy Cohere v1 endpoints are out of scope.
+
+Subpath import: `import { cohereAdapter } from "llm-stream-assemble/adapters/cohere"`.
+
+Live smoke: `pnpm smoke:cohere` — see [`docs/live-smoke.md`](./docs/live-smoke.md) for `COHERE_API_KEY`, `COHERE_MODEL`, and `COHERE_SMOKE_TOOLS`.
+
 ---
 
 ## Transforms & replay

package/dist/adapters/cohere.cjs

@@ -0,0 +1,594 @@
+'use strict';
+
+// src/core/utils/object.ts
+function stripUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+}
+
+// src/adapters/utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalRawChunk(input) {
+  return stripUndefined(input);
+}
+function prefixedAdapterError(feature, message) {
+  return adapterScopedError(feature, message);
+}
+function createStreamAdapter(config) {
+  return {
+    parseChunk(raw) {
+      return config.parser.parseChunk(raw);
+    },
+    parseResponse(body) {
+      return config.parseResponse(body, config.options);
+    }
+  };
+}
+function parseAdapterJSON(raw, feature) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw prefixedAdapterError(feature, message);
+  }
+}
+
+// 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 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/shared/incremental-json.ts
+function incrementalJsonStringDelta(state, nextInput) {
+  const prev = state.lastArgsJson;
+  if (nextInput === prev) return void 0;
+  const delta = prev.length > 0 && nextInput.startsWith(prev) ? nextInput.slice(prev.length) : nextInput;
+  state.lastArgsJson = nextInput;
+  return delta.length > 0 ? delta : void 0;
+}
+
+// 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/text-delta.ts
+function textOrJsonDelta(text, options) {
+  if (text.length === 0) return void 0;
+  if (options.jsonMode) return { kind: "json-delta", delta: text };
+  if (options.choiceIndex !== void 0) {
+    return { kind: "text-delta", text, choiceIndex: options.choiceIndex };
+  }
+  return { kind: "text-delta", text };
+}
+
+// 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/cohere.ts
+var COHERE_USAGE_ALIASES = {
+  input: ["input_tokens", "inputTokens"],
+  output: ["output_tokens", "outputTokens"],
+  total: ["total_tokens", "totalTokens"]
+};
+function cohereAdapter(options = {}) {
+  const parser = new CohereStreamParser(options);
+  return createStreamAdapter({
+    parser,
+    parseResponse,
+    options
+  });
+}
+var CohereStreamParser = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  messageStarted = false;
+  metadataEmitted = false;
+  toolsByKey = /* @__PURE__ */ new Map();
+  indexToKey = /* @__PURE__ */ new Map();
+  parseChunk(raw) {
+    const payload = parseAdapterObjectPayload(raw, "cohereAdapter.parseChunk");
+    if (!payload) return [];
+    if (asString(payload.type) === "error" || isRecord(payload.error)) {
+      const errorBody = isRecord(payload.error) ? payload.error : payload;
+      return providerErrorChunksFromPayload(
+        errorBody,
+        "cohereAdapter.parseChunk",
+        false,
+        "Cohere provider error"
+      );
+    }
+    const eventType = asString(payload.type);
+    if (!eventType) return optionalMetadataRaw(payload);
+    switch (eventType) {
+      case "message-start":
+        return this.messageStartChunks(payload);
+      case "content-start":
+      case "content-end":
+        return [];
+      case "content-delta":
+        return this.contentDeltaChunks(payload);
+      case "tool-plan-delta":
+        return this.toolPlanDeltaChunks(payload);
+      case "tool-call-start":
+        return this.toolCallStartChunks(payload);
+      case "tool-call-delta":
+        return this.toolCallDeltaChunks(payload);
+      case "tool-call-end":
+        return this.toolCallEndChunks(payload);
+      case "citation-start":
+        return this.citationStartChunks(payload);
+      case "citation-end":
+        return [];
+      case "message-end":
+        return this.messageEndChunks(payload);
+      default:
+        return optionalMetadataRaw(payload);
+    }
+  }
+  messageStartChunks(payload) {
+    if (this.messageStarted) return [];
+    this.messageStarted = true;
+    const chunks = [{ kind: "message-start" }];
+    const messageId = asString(payload.id);
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const message = delta && isRecord(delta.message) ? delta.message : void 0;
+    const role = message ? asString(message.role) : void 0;
+    if (messageId || role) {
+      this.metadataEmitted = true;
+      chunks.push(
+        optionalRawChunk({
+          kind: "metadata",
+          responseId: messageId,
+          raw: { id: messageId, role }
+        })
+      );
+    }
+    return chunks;
+  }
+  contentDeltaChunks(payload) {
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const message = delta && isRecord(delta.message) ? delta.message : void 0;
+    const content = message && isRecord(message.content) ? message.content : void 0;
+    const text = content ? asString(content.text) : void 0;
+    if (text === void 0 || text.length === 0) return [];
+    const textChunk = textOrJsonDelta(text, {
+      jsonMode: this.options.jsonMode,
+      choiceIndex: asNumber(payload.index) ?? 0
+    });
+    return textChunk ? [textChunk] : [];
+  }
+  toolPlanDeltaChunks(payload) {
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const message = delta && isRecord(delta.message) ? delta.message : void 0;
+    const toolPlan = message ? asString(message.tool_plan) : asString(delta?.tool_plan);
+    if (toolPlan === void 0 || toolPlan.length === 0) return [];
+    return [{ kind: "reasoning-delta", text: toolPlan, variant: "detail" }];
+  }
+  toolCallStartChunks(payload) {
+    const baseIndex = asNumber(payload.index) ?? 0;
+    const toolCalls = toolCallsFromDelta(payload.delta);
+    if (toolCalls.length === 0) return [];
+    const chunks = [];
+    for (let i = 0; i < toolCalls.length; i += 1) {
+      const toolCall = toolCalls[i];
+      const index = asNumber(toolCall.index) ?? baseIndex + i;
+      const id = asString(toolCall.id) ?? `cohere:tool:${index}`;
+      const fn = isRecord(toolCall.function) ? toolCall.function : void 0;
+      const name = fn ? asString(fn.name) ?? "unknown" : "unknown";
+      const key = reconcileToolKey(this.toolsByKey, this.indexToKey, index, id);
+      const existing = this.toolsByKey.get(key);
+      if (existing?.open && existing.id === id) continue;
+      const state = {
+        id,
+        name,
+        index,
+        open: true,
+        lastArgsJson: asString(fn?.arguments) ?? ""
+      };
+      this.toolsByKey.set(key, state);
+      this.indexToKey.set(index, key);
+      if (id !== key) this.toolsByKey.set(id, state);
+      chunks.push(
+        optionalRawChunk({
+          kind: "tool-start",
+          id,
+          name,
+          index,
+          choiceIndex: 0
+        })
+      );
+    }
+    return chunks;
+  }
+  toolCallDeltaChunks(payload) {
+    const index = asNumber(payload.index) ?? 0;
+    const toolCalls = toolCallsFromDelta(payload.delta);
+    if (toolCalls.length === 0) return [];
+    const chunks = [];
+    for (const toolCall of toolCalls) {
+      const lateId = asString(toolCall.id);
+      const key = this.resolveToolKey(index, lateId);
+      let state = key ? this.toolsByKey.get(key) : void 0;
+      if (!state) {
+        const fn2 = isRecord(toolCall.function) ? toolCall.function : void 0;
+        const name = fn2 ? asString(fn2.name) ?? "unknown" : "unknown";
+        const id = lateId ?? `cohere:tool:${index}`;
+        state = { id, name, index, open: true, lastArgsJson: "" };
+        this.toolsByKey.set(id, state);
+        this.indexToKey.set(index, id);
+        chunks.push(
+          optionalRawChunk({
+            kind: "tool-start",
+            id,
+            name,
+            index,
+            choiceIndex: 0
+          })
+        );
+      } else if (lateId && state.id !== lateId) {
+        this.reconcileLateId(state, lateId, index);
+      }
+      const fn = isRecord(toolCall.function) ? toolCall.function : void 0;
+      const argsText = fn ? asString(fn.arguments) : void 0;
+      if (argsText !== void 0 && argsText.length > 0 && state) {
+        const delta = incrementalJsonStringDelta(state, argsText);
+        if (delta) {
+          chunks.push(
+            optionalRawChunk({
+              kind: "tool-args-delta",
+              id: state.id,
+              delta,
+              index: state.index,
+              choiceIndex: 0
+            })
+          );
+        }
+      }
+    }
+    return chunks;
+  }
+  toolCallEndChunks(payload) {
+    const index = asNumber(payload.index) ?? 0;
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const message = delta && isRecord(delta.message) ? delta.message : void 0;
+    const toolCalls = message ? toolCallsFromRecord(message.tool_calls) : [];
+    const lateId = toolCalls[0] ? asString(toolCalls[0].id) : void 0;
+    const key = this.resolveToolKey(index, lateId);
+    const state = key ? this.toolsByKey.get(key) : void 0;
+    if (!state?.open) return [];
+    if (lateId && state.id !== lateId) {
+      this.reconcileLateId(state, lateId, index);
+    }
+    state.open = false;
+    return [
+      optionalRawChunk({
+        kind: "tool-done",
+        id: state.id,
+        index: state.index,
+        choiceIndex: 0
+      })
+    ];
+  }
+  citationStartChunks(payload) {
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const message = delta && isRecord(delta.message) ? delta.message : void 0;
+    const citations = message?.citations;
+    return [
+      optionalRawChunk({
+        kind: "metadata",
+        raw: { citation: citations, index: payload.index }
+      })
+    ];
+  }
+  messageEndChunks(payload) {
+    const delta = isRecord(payload.delta) ? payload.delta : void 0;
+    const chunks = [];
+    const usageSource = delta && isRecord(delta.usage) ? usageFromCohereUsage(delta.usage) : delta && isRecord(delta.billed_units) ? delta.billed_units : void 0;
+    const usage = buildUsageChunk(usageSource, COHERE_USAGE_ALIASES);
+    if (usage) chunks.push(usage);
+    const finishReason = delta ? asString(delta.finish_reason) : void 0;
+    if (finishReason) {
+      chunks.push(
+        optionalRawChunk({
+          kind: "metadata",
+          raw: { finish_reason: finishReason }
+        })
+      );
+      chunks.push({
+        kind: "finish",
+        reason: mapCohereFinishReason(finishReason),
+        choiceIndex: 0
+      });
+    }
+    return chunks;
+  }
+  resolveToolKey(index, id) {
+    if (id && this.toolsByKey.has(id)) return id;
+    const byIndex = this.indexToKey.get(index);
+    if (byIndex) return byIndex;
+    if (id) return id;
+    return this.indexToKey.get(index);
+  }
+  reconcileLateId(state, lateId, index) {
+    const oldKey = state.id;
+    state.id = lateId;
+    this.toolsByKey.delete(oldKey);
+    this.toolsByKey.set(lateId, state);
+    this.indexToKey.set(index, lateId);
+  }
+};
+function parseResponse(body, options) {
+  if (!isRecord(body)) {
+    throw libraryError("cohereAdapter.parseResponse expected a Cohere Chat v2 response object");
+  }
+  if (asString(body.type) === "error" || isRecord(body.error)) {
+    const errorBody = isRecord(body.error) ? body.error : body;
+    return providerErrorChunksFromPayload(
+      errorBody,
+      "cohereAdapter.parseResponse",
+      false,
+      "Cohere provider error"
+    );
+  }
+  const message = isRecord(body.message) ? body.message : void 0;
+  if (!message) {
+    const chunks2 = [];
+    const usage = buildUsageChunk(body.usage, COHERE_USAGE_ALIASES);
+    if (usage) chunks2.push(usage);
+    const finishReason2 = asString(body.finish_reason);
+    if (finishReason2) {
+      chunks2.push({
+        kind: "finish",
+        reason: mapCohereFinishReason(finishReason2),
+        choiceIndex: 0
+      });
+    } else {
+      chunks2.push({ kind: "finish", reason: "stop", choiceIndex: 0 });
+    }
+    return chunks2;
+  }
+  const parser = new CohereStreamParser(options);
+  const syntheticEvents = synthesizeCohereStreamEvents(body);
+  const chunks = [];
+  for (const event of syntheticEvents) {
+    chunks.push(...parser.parseChunk(JSON.stringify(event)));
+  }
+  const finishReason = asString(body.finish_reason);
+  if (finishReason && !chunks.some((chunk) => chunk.kind === "finish")) {
+    chunks.push({
+      kind: "finish",
+      reason: mapCohereFinishReason(finishReason),
+      choiceIndex: 0
+    });
+  } else if (!chunks.some((chunk) => chunk.kind === "finish")) {
+    chunks.push({ kind: "finish", reason: "stop", choiceIndex: 0 });
+  }
+  return chunks;
+}
+function synthesizeCohereStreamEvents(body) {
+  const events = [];
+  const message = isRecord(body.message) ? body.message : void 0;
+  if (!message) return events;
+  const messageId = asString(body.id);
+  events.push({
+    type: "message-start",
+    ...messageId ? { id: messageId } : {},
+    delta: { message: { role: asString(message.role) ?? "assistant" } }
+  });
+  const toolPlan = asString(message.tool_plan);
+  if (toolPlan) {
+    events.push({
+      type: "tool-plan-delta",
+      delta: { message: { tool_plan: toolPlan } }
+    });
+  }
+  const content = Array.isArray(message.content) ? message.content : [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    const text = asString(block.text);
+    if (text !== void 0 && text.length > 0) {
+      events.push({
+        type: "content-delta",
+        index: 0,
+        delta: { message: { content: { text } } }
+      });
+    }
+  }
+  const citations = message.citations;
+  if (Array.isArray(citations)) {
+    for (const citation of citations) {
+      events.push({
+        type: "citation-start",
+        index: 0,
+        delta: { message: { citations: citation } }
+      });
+    }
+  }
+  const toolCalls = toolCallsFromRecord(message.tool_calls);
+  let toolIndex = 0;
+  for (const toolCall of toolCalls) {
+    const id = asString(toolCall.id) ?? `cohere:tool:${toolIndex}`;
+    const fn = isRecord(toolCall.function) ? toolCall.function : void 0;
+    const name = fn ? asString(fn.name) ?? "unknown" : "unknown";
+    const args = fn ? asString(fn.arguments) : void 0;
+    events.push({
+      type: "tool-call-start",
+      index: toolIndex,
+      delta: {
+        message: {
+          tool_calls: {
+            id,
+            type: "function",
+            function: { name, arguments: args ?? "" }
+          }
+        }
+      }
+    });
+    if (args !== void 0 && args.length > 0) {
+      events.push({
+        type: "tool-call-delta",
+        index: toolIndex,
+        delta: {
+          message: {
+            tool_calls: {
+              id,
+              function: { arguments: args }
+            }
+          }
+        }
+      });
+    }
+    events.push({ type: "tool-call-end", index: toolIndex });
+    toolIndex += 1;
+  }
+  if (body.usage !== void 0 || body.finish_reason !== void 0) {
+    events.push({
+      type: "message-end",
+      delta: {
+        ...body.finish_reason !== void 0 ? { finish_reason: body.finish_reason } : {},
+        ...body.usage !== void 0 ? { usage: body.usage } : {}
+      }
+    });
+  }
+  return events;
+}
+function toolCallsFromDelta(delta) {
+  if (!isRecord(delta)) return [];
+  const message = isRecord(delta.message) ? delta.message : void 0;
+  return toolCallsFromRecord(message?.tool_calls);
+}
+function toolCallsFromRecord(value) {
+  if (value === void 0) return [];
+  if (Array.isArray(value)) {
+    return value.filter((item) => isRecord(item));
+  }
+  if (isRecord(value)) return [value];
+  return [];
+}
+function usageFromCohereUsage(usage) {
+  const billed = isRecord(usage.billed_units) ? usage.billed_units : void 0;
+  if (billed) return billed;
+  const tokens = isRecord(usage.tokens) ? usage.tokens : void 0;
+  if (tokens) return tokens;
+  return usage;
+}
+function reconcileToolKey(toolsByKey, indexToKey, index, id) {
+  const existingIndexKey = indexToKey.get(index);
+  if (existingIndexKey && toolsByKey.has(existingIndexKey)) {
+    const state = toolsByKey.get(existingIndexKey);
+    if (state && state.id.startsWith("cohere:tool:") && !id.startsWith("cohere:tool:")) {
+      toolsByKey.delete(existingIndexKey);
+      state.id = id;
+      toolsByKey.set(id, state);
+      indexToKey.set(index, id);
+      return id;
+    }
+    return existingIndexKey;
+  }
+  return id;
+}
+function mapCohereFinishReason(value) {
+  const normalized = value.toUpperCase();
+  switch (normalized) {
+    case "COMPLETE":
+    case "STOP_SEQUENCE":
+      return "stop";
+    case "MAX_TOKENS":
+      return "length";
+    case "TOOL_CALL":
+      return "tool_calls";
+    case "ERROR":
+    case "TIMEOUT":
+      return "error";
+    default:
+      if (normalized.includes("FILTER") || normalized.includes("SAFETY")) {
+        return "content_filter";
+      }
+      return "stop";
+  }
+}
+function optionalMetadataRaw(payload) {
+  if (Object.keys(payload).length === 0) return [];
+  return [
+    optionalRawChunk({
+      kind: "metadata",
+      raw: payload
+    })
+  ];
+}
+
+exports.cohereAdapter = cohereAdapter;
+//# sourceMappingURL=cohere.cjs.map
+//# sourceMappingURL=cohere.cjs.map