llm-stream-assemble 1.4.0 → 1.5.0

package/dist/adapters/cohere.js

@@ -0,0 +1,592 @@
+// 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
+    })
+  ];
+}
+
+export { cohereAdapter };
+//# sourceMappingURL=cohere.js.map
+//# sourceMappingURL=cohere.js.map