@anvia/core 1.1.1 → 1.2.0

package/dist/chunk-UTAB3XQI.js

@@ -0,0 +1,667 @@
+import {
+  CompletionProviderOutputError
+} from "./chunk-XQV3XNVT.js";
+import {
+  Usage
+} from "./chunk-IDNL6IH4.js";
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+
+// src/completion/stream-accumulator.ts
+var CompletionStreamAccumulator = class {
+  orderedParts = [];
+  textParts = /* @__PURE__ */ new Map();
+  reasoningByKey = /* @__PURE__ */ new Map();
+  reasoningKeyById = /* @__PURE__ */ new Map();
+  toolCalls = /* @__PURE__ */ new Map();
+  sources = /* @__PURE__ */ new Map();
+  providerToolCalls = /* @__PURE__ */ new Map();
+  finalResponse;
+  messageId;
+  nextTextKey = 0;
+  nextReasoningKey = 0;
+  accept(event) {
+    if (event.type === "text_delta") {
+      if (typeof event.delta !== "string") {
+        throw new CompletionProviderOutputError({ kind: "invalid-stream-event" });
+      }
+      this.appendText(event.delta);
+      return { type: "text_delta", delta: event.delta };
+    }
+    if (event.type === "reasoning_delta") {
+      if (typeof event.delta !== "string" || event.id !== void 0 && !isNonblankString(event.id) || event.signature !== void 0 && !isNonblankString(event.signature) || event.contentType !== void 0 && !isReasoningContentType(event.contentType)) {
+        throw new CompletionProviderOutputError({ kind: "invalid-stream-event" });
+      }
+      const reasoning = this.reasoningStateForEvent(event);
+      this.appendReasoning(reasoning, event);
+      return reasoningDeltaEvent(event);
+    }
+    if (event.type === "tool_call_delta") {
+      if (!isNonblankString(event.id)) {
+        throw new CompletionProviderOutputError({ kind: "invalid-tool-call" });
+      }
+      const toolCall = this.toolCallStateForId(event.id);
+      if (toolCall.fullCallSeen) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-tool-call",
+          toolCallId: toolCall.id
+        });
+      }
+      if (event.callId !== void 0) {
+        if (!isNonblankString(event.callId)) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.id
+          });
+        }
+        if (toolCall.callId !== void 0 && toolCall.callId !== event.callId) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.id
+          });
+        }
+        toolCall.callId = event.callId;
+      }
+      if (event.name !== void 0) {
+        if (!isNonblankString(event.name)) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.id
+          });
+        }
+        if (toolCall.name.length > 0 && toolCall.name !== event.name) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.id
+          });
+        }
+        toolCall.name = event.name;
+      }
+      if (event.signature !== void 0) {
+        if (!isNonblankString(event.signature) || toolCall.signature !== void 0 && toolCall.signature !== event.signature) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.id
+          });
+        }
+        toolCall.signature = event.signature;
+      }
+      if (event.argumentsMode !== void 0 && event.argumentsMode !== "append" && event.argumentsMode !== "replace") {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-stream-event",
+          toolCallId: toolCall.id
+        });
+      }
+      if (event.argumentsMode !== void 0 && event.argumentsDelta === void 0) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-stream-event",
+          toolCallId: toolCall.id
+        });
+      }
+      if (event.argumentsDelta !== void 0) {
+        if (typeof event.argumentsDelta !== "string") {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-arguments",
+            toolCallId: toolCall.id
+          });
+        }
+        if (event.argumentsMode === "replace") {
+          if (toolCall.argumentsText.length > 0 && toolCall.argumentsText !== event.argumentsDelta && (toolCall.argumentsSnapshotSeen || !event.argumentsDelta.startsWith(toolCall.argumentsText))) {
+            throw new CompletionProviderOutputError({
+              kind: "invalid-tool-call",
+              toolCallId: toolCall.id
+            });
+          }
+          toolCall.argumentsText = event.argumentsDelta;
+          toolCall.argumentsSnapshotSeen = true;
+        } else {
+          if (toolCall.argumentsSnapshotSeen) {
+            throw new CompletionProviderOutputError({
+              kind: "invalid-tool-call",
+              toolCallId: toolCall.id
+            });
+          }
+          toolCall.argumentsText += event.argumentsDelta;
+        }
+      }
+      return void 0;
+    }
+    if (event.type === "tool_call") {
+      this.upsertToolCall(event.toolCall);
+      return { type: "tool_call", toolCall: event.toolCall };
+    }
+    if (event.type === "source") {
+      this.sources.set(sourceKey(event.source), event.source);
+      return { type: "source", source: event.source };
+    }
+    if (event.type === "provider_tool_call") {
+      this.providerToolCalls.set(event.toolCall.id, event.toolCall);
+      return { type: "provider_tool_call", toolCall: event.toolCall };
+    }
+    if (event.type === "message_id") {
+      if (!isNonblankString(event.id)) {
+        throw new CompletionProviderOutputError({ kind: "invalid-stream-event" });
+      }
+      this.messageId = event.id;
+      return void 0;
+    }
+    if (event.type === "final") {
+      this.finalResponse = event.response;
+      return void 0;
+    }
+    return void 0;
+  }
+  response() {
+    this.assertAccumulatedFinishReason();
+    let accumulatedResponse;
+    try {
+      accumulatedResponse = this.buildAccumulatedResponse();
+    } catch (error) {
+      if (error instanceof CompletionProviderOutputError && this.finalResponse !== void 0) {
+        throw providerOutputErrorWithUsage(error, this.finalResponse.usage);
+      }
+      throw error;
+    }
+    if (this.finalResponse !== void 0) {
+      if (accumulatedResponse.choice.length === 0) {
+        return this.withAccumulatedArtifacts(this.finalResponse, accumulatedResponse);
+      }
+      return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
+    }
+    return accumulatedResponse;
+  }
+  assertAccumulatedFinishReason() {
+    if (this.finalResponse === void 0) {
+      if (this.toolCalls.size === 0) {
+        throw new CompletionProviderOutputError({ kind: "incomplete-stream" });
+      }
+      const toolCallId = this.toolCalls.size === 1 ? this.toolCalls.keys().next().value : void 0;
+      throw new CompletionProviderOutputError({
+        kind: "incomplete-tool-call",
+        toolCallId
+      });
+    }
+    if (this.toolCalls.size === 0) return;
+    const finishReason = this.finalResponse.finishReason;
+    if (finishReason === "length") {
+      throw new CompletionProviderOutputError({
+        kind: "truncated-tool-call",
+        finishReason,
+        usage: this.finalResponse.usage
+      });
+    }
+    if (finishReason === "content-filter") {
+      throw new CompletionProviderOutputError({
+        kind: "filtered-tool-call",
+        finishReason,
+        usage: this.finalResponse.usage
+      });
+    }
+    if (finishReason !== void 0 && finishReason !== "stop" && finishReason !== "tool-calls") {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        usage: this.finalResponse.usage
+      });
+    }
+  }
+  buildAccumulatedResponse() {
+    const choice = [];
+    for (const part of this.orderedParts) {
+      if (part.type === "text") {
+        const text = this.textParts.get(part.key) ?? "";
+        if (text.length > 0) {
+          choice.push({ type: "text", text });
+        }
+        continue;
+      }
+      if (part.type === "reasoning") {
+        const reasoning = this.reasoningByKey.get(part.key);
+        if (reasoning !== void 0) {
+          choice.push(reasoningContent(reasoning));
+        }
+        continue;
+      }
+      const toolCall = this.toolCalls.get(part.key);
+      if (toolCall !== void 0) {
+        choice.push(toolCallContent(toolCall));
+      }
+    }
+    const response = {
+      choice,
+      usage: Usage.empty(),
+      rawResponse: void 0
+    };
+    if (this.messageId !== void 0) {
+      response.messageId = this.messageId;
+    }
+    const sources = [...this.sources.values()];
+    if (sources.length > 0) {
+      response.sources = sources;
+    }
+    const providerToolCalls = [...this.providerToolCalls.values()];
+    if (providerToolCalls.length > 0) {
+      response.providerToolCalls = providerToolCalls;
+    }
+    return response;
+  }
+  upsertToolCall(toolCall) {
+    if (!isNonblankString(toolCall.toolCallId) || !isNonblankString(toolCall.toolName) || toolCall.callId !== void 0 && !isNonblankString(toolCall.callId) || toolCall.signature !== void 0 && !isNonblankString(toolCall.signature)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        toolCallId: isNonblankString(toolCall.toolCallId) ? toolCall.toolCallId : void 0
+      });
+    }
+    if (!isJsonValue(toolCall.input)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-arguments",
+        toolCallId: toolCall.toolCallId
+      });
+    }
+    const existing = this.toolCalls.get(toolCall.toolCallId);
+    if (existing !== void 0) {
+      if (existing.fullCallSeen) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-tool-call",
+          toolCallId: toolCall.toolCallId
+        });
+      }
+      if (existing.name.length > 0 && existing.name !== toolCall.toolName || existing.callId !== void 0 && existing.callId !== toolCall.callId || existing.signature !== void 0 && toolCall.signature !== void 0 && existing.signature !== toolCall.signature) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-tool-call",
+          toolCallId: toolCall.toolCallId
+        });
+      }
+      if (existing.argumentsText.length > 0) {
+        const accumulatedInput = parseToolArguments(existing.id, existing.argumentsText);
+        if (!jsonValuesEqual(accumulatedInput, toolCall.input)) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: toolCall.toolCallId
+          });
+        }
+      }
+    }
+    if (!this.toolCalls.has(toolCall.toolCallId)) {
+      this.orderedParts.push({ type: "tool_call", key: toolCall.toolCallId });
+    }
+    const partial = {
+      id: toolCall.toolCallId,
+      name: toolCall.toolName,
+      argumentsText: JSON.stringify(toolCall.input),
+      argumentsSnapshotSeen: true,
+      fullCallSeen: true
+    };
+    if (toolCall.callId !== void 0) {
+      partial.callId = toolCall.callId;
+    }
+    const signature = toolCall.signature ?? existing?.signature;
+    if (signature !== void 0) {
+      partial.signature = signature;
+    }
+    this.toolCalls.set(toolCall.toolCallId, partial);
+  }
+  mergeFinalResponse(accumulatedResponse, finalResponse) {
+    if (finalResponse.choice.length === 0) {
+      const mergedResponse = {
+        ...accumulatedResponse,
+        usage: finalResponse.usage,
+        rawResponse: finalResponse.rawResponse
+      };
+      if (finalResponse.finishReason !== void 0) {
+        mergedResponse.finishReason = finalResponse.finishReason;
+      }
+      if (finalResponse.providerFinishReason !== void 0) {
+        mergedResponse.providerFinishReason = finalResponse.providerFinishReason;
+      }
+      if (finalResponse.messageId !== void 0) {
+        mergedResponse.messageId = finalResponse.messageId;
+      }
+      return this.withAccumulatedArtifacts(mergedResponse, accumulatedResponse);
+    }
+    const accumulatedNonTool = accumulatedResponse.choice.filter(
+      (content) => content.type !== "tool-call"
+    );
+    const finalNonTool = finalResponse.choice.filter((content) => content.type !== "tool-call");
+    if (accumulatedNonTool.length > 0 && !nonToolPartsEqual(accumulatedNonTool, finalNonTool)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-stream-event",
+        usage: finalResponse.usage
+      });
+    }
+    const accumulatedById = /* @__PURE__ */ new Map();
+    const accumulatedByCallId = /* @__PURE__ */ new Map();
+    for (const content of accumulatedResponse.choice) {
+      if (content.type !== "tool-call") continue;
+      accumulatedById.set(content.toolCallId, content);
+      if (content.callId !== void 0) accumulatedByCallId.set(content.callId, content);
+    }
+    const matchedAccumulatedToolCalls = /* @__PURE__ */ new Set();
+    const choice = finalResponse.choice.map((content) => {
+      if (content.type !== "tool-call") return content;
+      const accumulated = accumulatedById.get(content.toolCallId);
+      if (accumulated === void 0) {
+        const changedIdentity = content.callId === void 0 ? void 0 : accumulatedByCallId.get(content.callId);
+        if (changedIdentity !== void 0) {
+          throw new CompletionProviderOutputError({
+            kind: "invalid-tool-call",
+            toolCallId: changedIdentity.toolCallId,
+            usage: finalResponse.usage
+          });
+        }
+        return content;
+      }
+      matchedAccumulatedToolCalls.add(accumulated);
+      return mergeFinalToolCall(accumulated, content, finalResponse.usage);
+    });
+    for (const accumulated of accumulatedById.values()) {
+      if (!matchedAccumulatedToolCalls.has(accumulated)) {
+        throw new CompletionProviderOutputError({
+          kind: "invalid-tool-call",
+          toolCallId: accumulated.toolCallId,
+          usage: finalResponse.usage
+        });
+      }
+    }
+    return this.withAccumulatedArtifacts({ ...finalResponse, choice }, accumulatedResponse);
+  }
+  appendText(delta) {
+    const lastPart = this.orderedParts.at(-1);
+    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
+    if (lastPart?.type !== "text") {
+      this.orderedParts.push({ type: "text", key });
+    }
+    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
+  }
+  reasoningStateForEvent(event) {
+    if (event.id !== void 0) {
+      const existingKey = this.reasoningKeyById.get(event.id);
+      if (existingKey !== void 0) {
+        const existing = this.reasoningByKey.get(existingKey);
+        if (existing !== void 0) {
+          return existing;
+        }
+      }
+      const key2 = this.createReasoningKey();
+      const reasoning2 = { id: event.id, text: "" };
+      this.reasoningKeyById.set(event.id, key2);
+      this.reasoningByKey.set(key2, reasoning2);
+      this.orderedParts.push({ type: "reasoning", key: key2 });
+      return reasoning2;
+    }
+    const lastPart = this.orderedParts.at(-1);
+    if (lastPart?.type === "reasoning") {
+      const lastReasoning = this.reasoningByKey.get(lastPart.key);
+      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
+        return lastReasoning;
+      }
+    }
+    const key = this.createReasoningKey();
+    const reasoning = { text: "" };
+    this.reasoningByKey.set(key, reasoning);
+    this.orderedParts.push({ type: "reasoning", key });
+    return reasoning;
+  }
+  toolCallStateForId(id) {
+    const existing = this.toolCalls.get(id);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const toolCall = {
+      id,
+      name: "",
+      argumentsText: "",
+      argumentsSnapshotSeen: false,
+      fullCallSeen: false
+    };
+    this.toolCalls.set(id, toolCall);
+    this.orderedParts.push({ type: "tool_call", key: id });
+    return toolCall;
+  }
+  withMessageIdFallback(response, accumulatedResponse) {
+    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
+      return response;
+    }
+    return { ...response, messageId: accumulatedResponse.messageId };
+  }
+  withAccumulatedArtifacts(response, accumulatedResponse) {
+    const withMessageId = this.withMessageIdFallback(response, accumulatedResponse);
+    const sources = mergeSources(accumulatedResponse.sources, response.sources);
+    const providerToolCalls = mergeProviderToolCalls(
+      accumulatedResponse.providerToolCalls,
+      response.providerToolCalls
+    );
+    let accumulated = { ...withMessageId };
+    if (sources.length > 0) accumulated = { ...accumulated, sources };
+    if (providerToolCalls.length > 0) {
+      accumulated = { ...accumulated, providerToolCalls };
+    }
+    return accumulated;
+  }
+  createTextKey() {
+    this.nextTextKey += 1;
+    return `text_${this.nextTextKey.toString()}`;
+  }
+  createReasoningKey() {
+    this.nextReasoningKey += 1;
+    return `reasoning_${this.nextReasoningKey.toString()}`;
+  }
+  appendReasoning(reasoning, event) {
+    const contentType = event.contentType ?? "text";
+    if (contentType === "text" || contentType === "summary") {
+      reasoning.text += event.delta;
+    }
+    if (event.contentType === void 0 && event.signature === void 0) {
+      return;
+    }
+    reasoning.details ??= [];
+    const last = reasoning.details.at(-1);
+    if (contentType === "text") {
+      if (last?.type === "text") {
+        let detail = {
+          ...last,
+          text: `${last.text}${event.delta}`
+        };
+        if (event.signature !== void 0) detail = { ...detail, signature: event.signature };
+        reasoning.details[reasoning.details.length - 1] = detail;
+      } else {
+        reasoning.details.push(
+          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
+        );
+      }
+      return;
+    }
+    if (contentType === "summary") {
+      if (last?.type === "summary") {
+        reasoning.details[reasoning.details.length - 1] = {
+          ...last,
+          text: `${last.text}${event.delta}`
+        };
+      } else {
+        reasoning.details.push({ type: "summary", text: event.delta });
+      }
+      return;
+    }
+    if (contentType === "encrypted") {
+      reasoning.details.push({ type: "encrypted", data: event.delta });
+      return;
+    }
+    reasoning.details.push({ type: "redacted", data: event.delta });
+  }
+};
+function sourceKey(source) {
+  return `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
+}
+function mergeSources(accumulated, final) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const source of [...accumulated ?? [], ...final ?? []]) {
+    sources.set(sourceKey(source), source);
+  }
+  return [...sources.values()];
+}
+function mergeProviderToolCalls(accumulated, final) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  for (const toolCall of [...accumulated ?? [], ...final ?? []]) {
+    toolCalls.set(toolCall.id, toolCall);
+  }
+  return [...toolCalls.values()];
+}
+function reasoningContent(reasoning) {
+  const content = reasoning.details === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, details: reasoning.details };
+  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
+}
+function toolCallContent(toolCall) {
+  const argumentsValue = parseToolArguments(toolCall.id, toolCall.argumentsText);
+  let content = {
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    input: argumentsValue
+  };
+  if (toolCall.callId !== void 0) content = { ...content, callId: toolCall.callId };
+  if (toolCall.signature !== void 0) content = { ...content, signature: toolCall.signature };
+  return content;
+}
+function mergeFinalToolCall(accumulated, finalToolCall, usage) {
+  if (finalToolCall.toolCallId !== accumulated.toolCallId || finalToolCall.toolName !== accumulated.toolName || accumulated.callId !== void 0 && finalToolCall.callId !== accumulated.callId || accumulated.signature !== void 0 && finalToolCall.signature !== void 0 && finalToolCall.signature !== accumulated.signature) {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-call",
+      toolCallId: accumulated.toolCallId,
+      usage
+    });
+  }
+  if (!isJsonValue(finalToolCall.input)) {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-arguments",
+      toolCallId: accumulated.toolCallId,
+      usage
+    });
+  }
+  if (!jsonValuesEqual(accumulated.input, finalToolCall.input)) {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-call",
+      toolCallId: accumulated.toolCallId,
+      usage
+    });
+  }
+  let merged = {
+    type: "tool-call",
+    toolCallId: finalToolCall.toolCallId,
+    toolName: finalToolCall.toolName,
+    input: accumulated.input
+  };
+  const callId = finalToolCall.callId ?? accumulated.callId;
+  if (callId !== void 0) merged = { ...merged, callId };
+  const signature = finalToolCall.signature ?? accumulated.signature;
+  if (signature !== void 0) merged = { ...merged, signature };
+  return merged;
+}
+function reasoningDeltaEvent(event) {
+  const mapped = { type: "reasoning_delta", delta: event.delta };
+  if (event.id !== void 0) mapped.id = event.id;
+  if (event.contentType !== void 0) mapped.contentType = event.contentType;
+  if (event.signature !== void 0) mapped.signature = event.signature;
+  return mapped;
+}
+function parseToolArguments(toolCallId, text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new CompletionProviderOutputError({
+      kind: "malformed-tool-arguments",
+      toolCallId
+    });
+  }
+  if (!isJsonValue(value)) {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-arguments",
+      toolCallId
+    });
+  }
+  return value;
+}
+function jsonValuesEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  if (isJsonArray(left) || isJsonArray(right)) {
+    if (!isJsonArray(left) || !isJsonArray(right) || left.length !== right.length) {
+      return false;
+    }
+    return left.every((value, index) => {
+      const rightValue = right[index];
+      return rightValue !== void 0 && jsonValuesEqual(value, rightValue);
+    });
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (const key of leftKeys) {
+    if (!Object.hasOwn(right, key)) {
+      return false;
+    }
+    const leftValue = left[key];
+    const rightValue = right[key];
+    if (leftValue === void 0 || rightValue === void 0 || !jsonValuesEqual(leftValue, rightValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+function nonToolPartsEqual(accumulated, final) {
+  if (accumulated.length !== final.length) return false;
+  if (!isJsonValue(accumulated) || !isJsonValue(final)) return false;
+  const unmatched = [...final];
+  for (const part of accumulated) {
+    const index = unmatched.findIndex((candidate) => jsonValuesEqual(part, candidate));
+    if (index < 0) return false;
+    unmatched.splice(index, 1);
+  }
+  return true;
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function providerOutputErrorWithUsage(error, usage) {
+  const shared = { usage };
+  if (error.toolCallId !== void 0) shared.toolCallId = error.toolCallId;
+  if (error.kind === "truncated-tool-call") {
+    return new CompletionProviderOutputError({
+      ...shared,
+      kind: error.kind,
+      finishReason: "length"
+    });
+  }
+  if (error.kind === "filtered-tool-call") {
+    return new CompletionProviderOutputError({
+      ...shared,
+      kind: error.kind,
+      finishReason: "content-filter"
+    });
+  }
+  if (error.finishReason === "length" || error.finishReason === "content-filter") {
+    throw error;
+  }
+  return new CompletionProviderOutputError({
+    ...shared,
+    kind: error.kind,
+    finishReason: error.finishReason
+  });
+}
+function isNonblankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isReasoningContentType(value) {
+  return value === "text" || value === "summary" || value === "encrypted" || value === "redacted";
+}
+
+export {
+  CompletionStreamAccumulator
+};
+//# sourceMappingURL=chunk-UTAB3XQI.js.map