@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/chunk-7PHMK7W4.js

@@ -0,0 +1,1516 @@
+import {
+  assertJsonObject
+} from "./chunk-7JLAIN6E.js";
+import {
+  parseMessage,
+  parseMessages,
+  toProviderJsonSchema
+} from "./chunk-QGX73TSQ.js";
+import {
+  isJsonValue
+} from "./chunk-3XQGVDU5.js";
+import {
+  abortError,
+  completionProviderOutputErrorUsage,
+  resolveRetryOptions,
+  retryDelayMs,
+  retryOptionsForFailure,
+  throwIfAborted,
+  waitForRetry
+} from "./chunk-3RWESPUG.js";
+
+// src/completion/types.ts
+function reasoningDisplayText(reasoning) {
+  const details = "type" in reasoning ? reasoning.details : reasoning;
+  if (details === void 0) {
+    return "type" in reasoning ? reasoning.text : "";
+  }
+  return details.flatMap((item) => {
+    if (item.type === "text" || item.type === "summary") {
+      return [item.text];
+    }
+    return [];
+  }).join("");
+}
+function isProviderTool(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return candidate.kind === "provider" && typeof candidate.provider === "string" && candidate.provider.trim().length > 0 && typeof candidate.name === "string" && candidate.name.trim().length > 0 && (candidate.configuration === void 0 || typeof candidate.configuration === "object" && candidate.configuration !== null && !Array.isArray(candidate.configuration) && isJsonValue(candidate.configuration));
+}
+function calculateContextUsage(usage, model) {
+  if (model === void 0 || !Number.isFinite(usage.inputTokens) || usage.inputTokens <= 0 || !Number.isFinite(model.context.contextWindow) || model.context.contextWindow <= 0) {
+    return void 0;
+  }
+  const usedTokens = Math.max(0, usage.inputTokens);
+  const remainingTokens = Math.max(0, model.context.contextWindow - usedTokens);
+  const usedPercent = Math.min(100, usedTokens / model.context.contextWindow * 100);
+  return {
+    model,
+    usedTokens,
+    remainingTokens,
+    usedPercent,
+    remainingPercent: 100 - usedPercent
+  };
+}
+function withContextUsage(response, model) {
+  const contextUsage = calculateContextUsage(response.usage, model);
+  return contextUsage === void 0 ? response : { ...response, contextUsage };
+}
+function resolveModelContextLimits(modelId, catalog, override) {
+  return override ?? catalog[modelId];
+}
+var Usage = {
+  empty() {
+    return {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      cachedInputTokens: 0,
+      cacheCreationInputTokens: 0
+    };
+  },
+  add(left, right) {
+    const result = {
+      inputTokens: left.inputTokens + right.inputTokens,
+      outputTokens: left.outputTokens + right.outputTokens,
+      totalTokens: left.totalTokens + right.totalTokens,
+      cachedInputTokens: left.cachedInputTokens + right.cachedInputTokens,
+      cacheCreationInputTokens: left.cacheCreationInputTokens + right.cacheCreationInputTokens
+    };
+    const details = addUsageDetails(left, right);
+    if (details !== void 0) {
+      result.details = details;
+    }
+    return result;
+  },
+  isEmpty(usage) {
+    return isEmptyUsage(usage) && (usage.details === void 0 || Object.values(usage.details).every((value) => value === 0));
+  }
+};
+function addUsageDetails(left, right) {
+  if (isEmptyUsage(left) && left.details === void 0) {
+    return right.details === void 0 ? void 0 : { ...right.details };
+  }
+  if (isEmptyUsage(right) && right.details === void 0) {
+    return left.details === void 0 ? void 0 : { ...left.details };
+  }
+  if (left.details === void 0 || right.details === void 0) {
+    return void 0;
+  }
+  const details = { ...left.details };
+  for (const [key, value] of Object.entries(right.details)) {
+    details[key] = (details[key] ?? 0) + value;
+  }
+  return details;
+}
+function isEmptyUsage(usage) {
+  return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
+}
+function getAssistantGenerationMetadata(message) {
+  if (message.role !== "assistant" || !isJsonObjectValue(message.metadata)) {
+    return void 0;
+  }
+  const frameworkMetadata = message.metadata.anvia;
+  if (!isJsonObjectValue(frameworkMetadata)) {
+    return void 0;
+  }
+  const generation = frameworkMetadata.generation;
+  if (!isJsonObjectValue(generation) || typeof generation.provider !== "string" || typeof generation.modelId !== "string" || !isUsageValue(generation.usage)) {
+    return void 0;
+  }
+  let usage = { ...generation.usage };
+  if (generation.usage.details !== void 0) {
+    usage = { ...usage, details: { ...generation.usage.details } };
+  }
+  const metadata = {
+    provider: generation.provider,
+    modelId: generation.modelId,
+    usage
+  };
+  if (isCompletionFinishReason(generation.finishReason)) {
+    metadata.finishReason = generation.finishReason;
+  }
+  if (typeof generation.providerFinishReason === "string") {
+    metadata.providerFinishReason = generation.providerFinishReason;
+  }
+  if (isContextUsageValue(generation.contextUsage)) {
+    metadata.contextUsage = {
+      ...generation.contextUsage,
+      model: {
+        ...generation.contextUsage.model,
+        context: { ...generation.contextUsage.model.context }
+      }
+    };
+  }
+  if (isCompletionSourceArray(generation.sources)) {
+    metadata.sources = generation.sources.map((source) => ({ ...source }));
+  }
+  if (isProviderToolCallArray(generation.providerToolCalls)) {
+    metadata.providerToolCalls = generation.providerToolCalls.map((toolCall) => {
+      let copy = { ...toolCall };
+      if (toolCall.details !== void 0) {
+        copy = { ...copy, details: { ...toolCall.details } };
+      }
+      return copy;
+    });
+  }
+  return metadata;
+}
+function isJsonObjectValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContextUsageValue(value) {
+  if (!isJsonObjectValue(value) || !isJsonObjectValue(value.model)) {
+    return false;
+  }
+  const context = value.model.context;
+  if (typeof value.model.modelId === "string" && isJsonObjectValue(context) && isPositiveFiniteNumber(context.contextWindow) && isOptionalPositiveFiniteNumber(context.maxInputTokens) && isOptionalPositiveFiniteNumber(context.maxOutputTokens) && isNonnegativeFiniteNumber(value.usedTokens) && isNonnegativeFiniteNumber(value.remainingTokens) && isPercentage(value.usedPercent) && isPercentage(value.remainingPercent)) {
+    const contextWindow = context.contextWindow;
+    const remainingTokens = Math.max(0, contextWindow - value.usedTokens);
+    const usedPercent = Math.min(100, value.usedTokens / contextWindow * 100);
+    const remainingPercent = remainingTokens / contextWindow * 100;
+    return value.remainingTokens === remainingTokens && approximatelyEqual(value.usedPercent, usedPercent) && approximatelyEqual(value.remainingPercent, remainingPercent);
+  }
+  return false;
+}
+function approximatelyEqual(left, right) {
+  const scale = Math.max(1, Math.abs(left), Math.abs(right));
+  return Math.abs(left - right) <= Number.EPSILON * scale * 8;
+}
+function isPositiveFiniteNumber(value) {
+  return isNonnegativeFiniteNumber(value) && value > 0;
+}
+function isOptionalPositiveFiniteNumber(value) {
+  return value === void 0 || isPositiveFiniteNumber(value);
+}
+function isPercentage(value) {
+  return isNonnegativeFiniteNumber(value) && value <= 100;
+}
+function isUsageValue(value) {
+  if (!isJsonObjectValue(value)) {
+    return false;
+  }
+  return isNonnegativeFiniteNumber(value.inputTokens) && isNonnegativeFiniteNumber(value.outputTokens) && isNonnegativeFiniteNumber(value.totalTokens) && isNonnegativeFiniteNumber(value.cachedInputTokens) && isNonnegativeFiniteNumber(value.cacheCreationInputTokens) && isUsageDetailsValue(value.details);
+}
+function isNonnegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isUsageDetailsValue(value) {
+  if (value === void 0) {
+    return true;
+  }
+  if (!isJsonObjectValue(value)) {
+    return false;
+  }
+  let total;
+  let bucketSum = 0;
+  for (const [key, detail] of Object.entries(value)) {
+    if (detail === void 0 || !isNonnegativeFiniteNumber(detail)) {
+      return false;
+    }
+    if (key === "total") {
+      total = detail;
+    } else {
+      bucketSum += detail;
+    }
+  }
+  return total !== void 0 && total === bucketSum;
+}
+function isCompletionSourceArray(value) {
+  return Array.isArray(value) && value.every(
+    (source) => isJsonObjectValue(source) && source.type === "url" && typeof source.url === "string" && (source.title === void 0 || typeof source.title === "string") && (source.id === void 0 || typeof source.id === "string") && (source.startIndex === void 0 || typeof source.startIndex === "number") && (source.endIndex === void 0 || typeof source.endIndex === "number")
+  );
+}
+function isProviderToolCallArray(value) {
+  return Array.isArray(value) && value.every(
+    (toolCall) => isJsonObjectValue(toolCall) && typeof toolCall.id === "string" && typeof toolCall.name === "string" && (toolCall.status === void 0 || typeof toolCall.status === "string") && (toolCall.details === void 0 || isJsonObjectValue(toolCall.details))
+  );
+}
+function isCompletionFinishReason(value) {
+  return value === "stop" || value === "length" || value === "content-filter" || value === "tool-calls" || value === "other";
+}
+var CompletionCapabilityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CompletionCapabilityError";
+  }
+};
+function assertCompletionRequestSupported(model, request, options = {}) {
+  const modelLabel = `${model.provider}:${model.modelId}`;
+  const capabilities = model.capabilities;
+  if (options.streaming === true && !capabilities.streaming) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support streaming completions.`);
+  }
+  if (request.tools.length > 0 && !capabilities.tools) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support tool definitions.`);
+  }
+  if ((request.providerTools?.length ?? 0) > 0 && capabilities.providerTools !== true) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support provider-executed tools.`);
+  }
+  if (request.toolChoice !== void 0 && !capabilities.toolChoice) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support tool choice.`);
+  }
+  if (request.outputSchema !== void 0 && !capabilities.outputSchema) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support output schemas.`);
+  }
+  if (!capabilities.imageInput && requestHasImageInput(request)) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support image input.`);
+  }
+  if (!capabilities.documentInput && requestHasFileDocumentInput(request)) {
+    throw new CompletionCapabilityError(`${modelLabel} does not support document file input.`);
+  }
+}
+function textFromAssistantContent(content) {
+  return content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+}
+function requestHasImageInput(request) {
+  return request.chatHistory.some(
+    (message) => message.role === "system" || typeof message.content === "string" ? false : message.content.some((content) => content.type === "image")
+  );
+}
+function requestHasFileDocumentInput(request) {
+  return request.chatHistory.some(
+    (message) => message.role === "user" && typeof message.content !== "string" ? message.content.some((content) => content.type === "file" && content.data.type !== "text") : false
+  );
+}
+
+// src/completion/provider-output-error.ts
+var COMPLETION_PROVIDER_OUTPUT_ERROR_CODE = "ANVIA_COMPLETION_PROVIDER_OUTPUT";
+var PROVIDER_OUTPUT_ERROR_KINDS = /* @__PURE__ */ new Set([
+  "malformed-tool-arguments",
+  "invalid-tool-arguments",
+  "invalid-stream-event",
+  "invalid-response",
+  "incomplete-stream",
+  "incomplete-tool-call",
+  "invalid-tool-call",
+  "truncated-tool-call",
+  "filtered-tool-call"
+]);
+var CompletionProviderOutputError = class extends Error {
+  code = COMPLETION_PROVIDER_OUTPUT_ERROR_CODE;
+  kind;
+  toolCallId;
+  finishReason;
+  usage;
+  constructor(options) {
+    assertProviderOutputErrorOptions(options);
+    super(providerOutputErrorMessage(options.kind, options.toolCallId));
+    this.name = "CompletionProviderOutputError";
+    this.kind = options.kind;
+    this.toolCallId = options.toolCallId;
+    this.finishReason = options.finishReason;
+    this.usage = options.usage === void 0 ? void 0 : copyUsage(options.usage);
+  }
+};
+function assertCompletionResponseIntegrity(options) {
+  const { response } = options;
+  const toolCalls = response.choice.filter(
+    (content) => content.type === "tool-call"
+  );
+  if (toolCalls.length > 0) {
+    if (response.finishReason !== void 0 && !isCompletionFinishReason2(response.finishReason)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        usage: response.usage
+      });
+    }
+    if (response.finishReason === "length") {
+      throw new CompletionProviderOutputError({
+        kind: "truncated-tool-call",
+        finishReason: response.finishReason,
+        usage: response.usage
+      });
+    }
+    if (response.finishReason === "content-filter") {
+      throw new CompletionProviderOutputError({
+        kind: "filtered-tool-call",
+        finishReason: response.finishReason,
+        usage: response.usage
+      });
+    }
+    if (response.finishReason === "other") {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        finishReason: response.finishReason,
+        usage: response.usage
+      });
+    }
+  } else if (response.finishReason === "tool-calls") {
+    throw new CompletionProviderOutputError({
+      kind: "invalid-tool-call",
+      finishReason: response.finishReason,
+      usage: response.usage
+    });
+  }
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const callIds = /* @__PURE__ */ new Set();
+  for (const toolCall of toolCalls) {
+    if (!isNonblankString(toolCall.toolCallId) || !isNonblankString(toolCall.toolName)) {
+      throw invalidToolCall(toolCall.toolCallId, response.usage);
+    }
+    if (toolCall.callId !== void 0 && !isNonblankString(toolCall.callId)) {
+      throw invalidToolCall(toolCall.toolCallId, response.usage);
+    }
+    if (toolCallIds.has(toolCall.toolCallId)) {
+      throw invalidToolCall(toolCall.toolCallId, response.usage);
+    }
+    toolCallIds.add(toolCall.toolCallId);
+    if (toolCall.callId !== void 0) {
+      if (callIds.has(toolCall.callId)) {
+        throw invalidToolCall(toolCall.toolCallId, response.usage);
+      }
+      callIds.add(toolCall.callId);
+    }
+    if (!isJsonValue(toolCall.input)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-arguments",
+        toolCallId: toolCall.toolCallId,
+        usage: response.usage
+      });
+    }
+  }
+}
+function invalidToolCall(toolCallId, usage) {
+  return new CompletionProviderOutputError({
+    kind: "invalid-tool-call",
+    toolCallId: isNonblankString(toolCallId) ? toolCallId : void 0,
+    usage
+  });
+}
+function assertProviderOutputErrorOptions(options) {
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("CompletionProviderOutputError options must be an object.");
+  }
+  if (!PROVIDER_OUTPUT_ERROR_KINDS.has(options.kind)) {
+    throw new TypeError("CompletionProviderOutputError kind is invalid.");
+  }
+  if (options.toolCallId !== void 0 && !isNonblankString(options.toolCallId)) {
+    throw new TypeError("CompletionProviderOutputError toolCallId must be a non-empty string.");
+  }
+  if (options.finishReason !== void 0 && !isCompletionFinishReason2(options.finishReason)) {
+    throw new TypeError("CompletionProviderOutputError finishReason is invalid.");
+  }
+  if (options.kind === "truncated-tool-call" && options.finishReason !== "length") {
+    throw new TypeError('CompletionProviderOutputError truncated-tool-call requires "length".');
+  }
+  if (options.kind === "filtered-tool-call" && options.finishReason !== "content-filter") {
+    throw new TypeError(
+      'CompletionProviderOutputError filtered-tool-call requires "content-filter".'
+    );
+  }
+  if (options.finishReason === "length" && options.kind !== "truncated-tool-call") {
+    throw new TypeError(
+      'CompletionProviderOutputError finishReason "length" requires truncated-tool-call.'
+    );
+  }
+  if (options.finishReason === "content-filter" && options.kind !== "filtered-tool-call") {
+    throw new TypeError(
+      'CompletionProviderOutputError finishReason "content-filter" requires filtered-tool-call.'
+    );
+  }
+  if (options.usage !== void 0) {
+    assertUsage(options.usage);
+  }
+}
+function providerOutputErrorMessage(kind, toolCallId) {
+  const toolCall = toolCallId === void 0 ? "tool call" : `tool call ${JSON.stringify(displayId(toolCallId))}`;
+  if (kind === "malformed-tool-arguments") {
+    return `Completion provider returned ${toolCall} with malformed JSON arguments.`;
+  }
+  if (kind === "invalid-tool-arguments") {
+    return `Completion provider returned ${toolCall} with arguments that are not a JSON value.`;
+  }
+  if (kind === "invalid-stream-event") {
+    return "Completion provider returned an invalid stream event.";
+  }
+  if (kind === "invalid-response") {
+    return "Completion provider returned a response that cannot be consumed safely.";
+  }
+  if (kind === "incomplete-tool-call") {
+    return "Completion provider stream ended before its tool call was complete.";
+  }
+  if (kind === "incomplete-stream") {
+    return "Completion provider stream ended without a terminal response.";
+  }
+  if (kind === "truncated-tool-call") {
+    return "Completion provider stopped at its output limit before a tool call could be consumed safely.";
+  }
+  if (kind === "filtered-tool-call") {
+    return "Completion provider content filtering prevented a tool call from being consumed safely.";
+  }
+  return `Completion provider returned an invalid ${toolCall}.`;
+}
+function displayId(value) {
+  let sanitized = "";
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    sanitized += code <= 31 || code === 127 ? "\uFFFD" : character;
+  }
+  return sanitized.length <= 128 ? sanitized : `${sanitized.slice(0, 127)}\u2026`;
+}
+function isNonblankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isCompletionFinishReason2(value) {
+  return value === "stop" || value === "length" || value === "content-filter" || value === "tool-calls" || value === "other";
+}
+function assertUsage(usage) {
+  for (const value of [
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.totalTokens,
+    usage.cachedInputTokens,
+    usage.cacheCreationInputTokens
+  ]) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      throw new TypeError("CompletionProviderOutputError usage must contain finite token counts.");
+    }
+  }
+  if (usage.details !== void 0) {
+    for (const value of Object.values(usage.details)) {
+      if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new TypeError(
+          "CompletionProviderOutputError usage details must contain finite token counts."
+        );
+      }
+    }
+  }
+}
+function copyUsage(usage) {
+  const copied = {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    totalTokens: usage.totalTokens,
+    cachedInputTokens: usage.cachedInputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens
+  };
+  if (usage.details !== void 0) copied.details = { ...usage.details };
+  return copied;
+}
+
+// src/internal/completion-request.ts
+function createCompletionRequest(input, options) {
+  const configuredTools = options.tools ?? [];
+  const chatHistory = messagesFromInput(input);
+  assertNoAgentInteractionParts(chatHistory);
+  const request = {
+    chatHistory,
+    documents: [...options.documents ?? []],
+    tools: configuredTools.filter((tool) => !isProviderTool(tool))
+  };
+  const providerTools = configuredTools.filter(isProviderTool);
+  if (providerTools.length > 0) request.providerTools = providerTools;
+  if (options.instructions !== void 0 && options.instructions.length > 0) {
+    request.instructions = options.instructions;
+  }
+  if (options.temperature !== void 0) request.temperature = options.temperature;
+  if (options.maxTokens !== void 0) request.maxTokens = options.maxTokens;
+  if (options.toolChoice !== void 0) request.toolChoice = options.toolChoice;
+  if (options.outputSchema !== void 0) request.outputSchema = options.outputSchema;
+  if (options.providerOptions !== void 0) {
+    assertJsonObject(options.providerOptions, "providerOptions");
+    request.providerOptions = options.providerOptions;
+  }
+  return request;
+}
+function assertNoAgentInteractionParts(messages) {
+  for (const message of messages) {
+    if (message.role === "tool" && message.content.some((part) => part.type !== "tool-result")) {
+      throw new TypeError(
+        "Completion messages contain an unresolved Agent interaction response. Resume the Agent with its continuation instead of sending interaction parts directly to a provider."
+      );
+    }
+  }
+}
+function messagesFromInput(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 0) {
+      throw new Error("input must contain at least one Message.");
+    }
+    return parseMessages(input);
+  }
+  return [parseMessage(input)];
+}
+
+// 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 && !isNonblankString2(event.id) || event.signature !== void 0 && !isNonblankString2(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 (!isNonblankString2(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 (!isNonblankString2(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 (!isNonblankString2(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 (!isNonblankString2(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 (!isNonblankString2(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 (!isNonblankString2(toolCall.toolCallId) || !isNonblankString2(toolCall.toolName) || toolCall.callId !== void 0 && !isNonblankString2(toolCall.callId) || toolCall.signature !== void 0 && !isNonblankString2(toolCall.signature)) {
+      throw new CompletionProviderOutputError({
+        kind: "invalid-tool-call",
+        toolCallId: isNonblankString2(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 isNonblankString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isReasoningContentType(value) {
+  return value === "text" || value === "summary" || value === "encrypted" || value === "redacted";
+}
+
+// src/completion/generate-completion.ts
+var CompletionStructuredOutputError = class extends Error {
+  phase;
+  outputLength;
+  usage;
+  finishReason;
+  providerFinishReason;
+  constructor(options) {
+    const failure = options.phase === "truncated" ? "because the provider reached its output limit" : options.phase === "content-filter" ? "because the provider filtered the response" : options.phase === "parse" ? "during JSON parsing" : "during schema validation";
+    super(`Structured completion output failed ${failure}.`, { cause: options.cause });
+    this.name = "CompletionStructuredOutputError";
+    this.phase = options.phase;
+    this.outputLength = options.outputLength;
+    this.usage = options.usage;
+    this.finishReason = options.finishReason;
+    this.providerFinishReason = options.providerFinishReason;
+  }
+};
+async function generateCompletion(options) {
+  throwIfAborted(options.abortSignal);
+  const request = requestFromOptions(options);
+  assertCompletionRequestSupported(options.model, request);
+  const retries = resolveOptionalRetries(options.retries);
+  const response = await sendCompletion(options.model, request, retries, options.abortSignal);
+  return resultFromResponse(response, structuredOutputSchema(options));
+}
+function streamCompletion(options) {
+  throwIfAborted(options.abortSignal);
+  const request = requestFromOptions(options);
+  if (!isStreamingCompletionModel(options.model) || !options.model.capabilities.streaming) {
+    throw new Error("This completion model does not support streaming");
+  }
+  assertCompletionRequestSupported(options.model, request, { streaming: true });
+  const retries = resolveOptionalRetries(options.retries);
+  return streamCompletionWithRetries(
+    options.model,
+    request,
+    retries,
+    options.abortSignal,
+    structuredOutputSchema(options)
+  );
+}
+async function sendCompletion(model, request, retries, abortSignal) {
+  const callOptions = modelCallOptions(abortSignal);
+  let attempt = 1;
+  let failedUsage = Usage.empty();
+  while (true) {
+    try {
+      throwIfAborted(abortSignal);
+      const response = await model.completion(request, callOptions);
+      assertCompletionResponseIntegrity({ response });
+      return Usage.isEmpty(failedUsage) ? response : { ...response, usage: Usage.add(failedUsage, response.usage) };
+    } catch (error) {
+      const normalizedError = abortSignal?.aborted === true ? abortError(abortSignal.reason) : error;
+      const attemptUsage = completionProviderOutputErrorUsage(normalizedError);
+      if (attemptUsage !== void 0) failedUsage = Usage.add(failedUsage, attemptUsage);
+      const retryOptions = retryOptionsForFailure(retries, {
+        error: normalizedError,
+        attempt,
+        streaming: false
+      });
+      if (retryOptions === void 0) throw normalizedError;
+      await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);
+      attempt += 1;
+    }
+  }
+}
+function resolveOptionalRetries(setting) {
+  return setting === void 0 || setting === false ? void 0 : resolveRetryOptions(setting);
+}
+async function* streamCompletionWithRetries(model, request, retries, abortSignal, outputSchema) {
+  let attempt = 1;
+  let swallowedUsage = Usage.empty();
+  const callOptions = modelCallOptions(abortSignal);
+  attemptLoop: while (true) {
+    let exposedProgress = false;
+    let retryDelay;
+    const accumulator = new CompletionStreamAccumulator();
+    try {
+      throwIfAborted(abortSignal);
+      const events = model.streamCompletion(request, callOptions);
+      for await (const event of events) {
+        if (event.type === "error" && !exposedProgress) {
+          const eventError = abortSignal?.aborted === true ? abortError(abortSignal.reason) : event.error;
+          const eventUsage = event.usage ?? completionProviderOutputErrorUsage(eventError) ?? Usage.empty();
+          const retryOptions = retryOptionsForFailure(retries, {
+            error: eventError,
+            attempt,
+            streaming: true
+          });
+          if (retryOptions !== void 0) {
+            swallowedUsage = Usage.add(swallowedUsage, eventUsage);
+            retryDelay = retryDelayMs(retryOptions, attempt);
+            break;
+          }
+        }
+        if (event.type === "error") {
+          const eventError = abortSignal?.aborted === true ? abortError(abortSignal.reason) : event.error;
+          const eventUsage = event.usage ?? completionProviderOutputErrorUsage(eventError) ?? Usage.empty();
+          yield {
+            type: "error",
+            error: eventError,
+            usage: Usage.add(swallowedUsage, eventUsage)
+          };
+          return;
+        }
+        if (event.type === "final") {
+          const cumulativeUsage = Usage.add(swallowedUsage, event.response.usage);
+          try {
+            accumulator.accept(event);
+            const accumulatedResponse = accumulator.response();
+            const response = Usage.isEmpty(swallowedUsage) ? accumulatedResponse : { ...accumulatedResponse, usage: cumulativeUsage };
+            assertCompletionResponseIntegrity({ response });
+            yield {
+              type: "final",
+              result: resultFromResponse(response, outputSchema)
+            };
+          } catch (error) {
+            const retryOptions = exposedProgress ? void 0 : retryOptionsForFailure(retries, {
+              error,
+              attempt,
+              streaming: true
+            });
+            if (retryOptions !== void 0) {
+              swallowedUsage = cumulativeUsage;
+              await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);
+              attempt += 1;
+              continue attemptLoop;
+            }
+            yield { type: "error", error, usage: cumulativeUsage };
+          }
+          return;
+        }
+        accumulator.accept(event);
+        exposedProgress = true;
+        yield event;
+      }
+      if (retryDelay !== void 0) {
+        await waitForRetry(retryDelay, abortSignal);
+        attempt += 1;
+        continue;
+      }
+      let incomplete;
+      try {
+        accumulator.response();
+        incomplete = new CompletionProviderOutputError({ kind: "incomplete-stream" });
+      } catch (error) {
+        incomplete = error;
+      }
+      if (!exposedProgress) {
+        const retryOptions = retryOptionsForFailure(retries, {
+          error: incomplete,
+          attempt,
+          streaming: true
+        });
+        if (retryOptions !== void 0) {
+          await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);
+          attempt += 1;
+          continue;
+        }
+      }
+      yield { type: "error", error: incomplete, usage: swallowedUsage };
+      return;
+    } catch (error) {
+      const normalizedError = abortSignal?.aborted === true ? abortError(abortSignal.reason) : error;
+      const attemptUsage = completionProviderOutputErrorUsage(normalizedError);
+      const cumulativeUsage = attemptUsage === void 0 ? swallowedUsage : Usage.add(swallowedUsage, attemptUsage);
+      if (!exposedProgress) {
+        const retryOptions = retryOptionsForFailure(retries, {
+          error: normalizedError,
+          attempt,
+          streaming: true
+        });
+        if (retryOptions !== void 0) {
+          try {
+            swallowedUsage = cumulativeUsage;
+            await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);
+            attempt += 1;
+            continue;
+          } catch (waitError) {
+            yield { type: "error", error: waitError, usage: cumulativeUsage };
+            return;
+          }
+        }
+      }
+      yield { type: "error", error: normalizedError, usage: cumulativeUsage };
+      return;
+    }
+  }
+}
+function requestFromOptions(options) {
+  const input = inputFromOptions(options);
+  return createCompletionRequest(input, {
+    instructions: options.instructions,
+    documents: options.documents,
+    tools: options.tools,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    toolChoice: options.toolChoice,
+    providerOptions: options.providerOptions,
+    outputSchema: "outputSchema" in options && options.outputSchema !== void 0 ? toProviderJsonSchema(options.outputSchema) : void 0
+  });
+}
+function inputFromOptions(options) {
+  const prompt = options.prompt;
+  const messages = options.messages;
+  const hasPrompt = prompt !== void 0;
+  const hasMessages = messages !== void 0;
+  if (hasPrompt === hasMessages) {
+    throw new TypeError("Exactly one of prompt or messages must be provided.");
+  }
+  if (hasPrompt) {
+    if (typeof prompt !== "string" || prompt.trim().length === 0) {
+      throw new TypeError("Completion prompt must be a non-empty string.");
+    }
+    return prompt;
+  }
+  if (!Array.isArray(messages)) {
+    throw new TypeError("Completion messages must be an array of Message values.");
+  }
+  return messages;
+}
+function structuredOutputSchema(options) {
+  return options.outputSchema;
+}
+function resultFromResponse(response, outputSchema) {
+  const text = textFromAssistantContent(response.choice);
+  const result = {
+    output: outputSchema === void 0 ? text : parseCompletionOutput(text, outputSchema, response),
+    text,
+    content: [...response.choice],
+    usage: response.usage,
+    rawResponse: response.rawResponse
+  };
+  if (response.finishReason !== void 0) result.finishReason = response.finishReason;
+  if (response.providerFinishReason !== void 0) {
+    result.providerFinishReason = response.providerFinishReason;
+  }
+  if (response.contextUsage !== void 0) result.contextUsage = response.contextUsage;
+  if (response.messageId !== void 0) result.messageId = response.messageId;
+  if (response.sources !== void 0) result.sources = [...response.sources];
+  if (response.providerToolCalls !== void 0) {
+    result.providerToolCalls = [...response.providerToolCalls];
+  }
+  return result;
+}
+function parseCompletionOutput(text, schema, response) {
+  if (response.finishReason === "content-filter") {
+    throw new CompletionStructuredOutputError({
+      phase: "content-filter",
+      outputLength: text.length,
+      usage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason
+    });
+  }
+  if (response.finishReason === "length") {
+    throw new CompletionStructuredOutputError({
+      phase: "truncated",
+      outputLength: text.length,
+      usage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason
+    });
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+    if (!isJsonValue(json)) {
+      throw new TypeError("Structured completion output is not a JSON value.");
+    }
+  } catch (error) {
+    throw new CompletionStructuredOutputError({
+      phase: "parse",
+      outputLength: text.length,
+      usage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason,
+      cause: error
+    });
+  }
+  try {
+    return schema.parse(json);
+  } catch (error) {
+    throw new CompletionStructuredOutputError({
+      phase: "schema",
+      outputLength: text.length,
+      usage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason,
+      cause: error
+    });
+  }
+}
+function modelCallOptions(abortSignal) {
+  return abortSignal === void 0 ? void 0 : { abortSignal };
+}
+function isStreamingCompletionModel(model) {
+  return typeof model.streamCompletion === "function";
+}
+
+export {
+  reasoningDisplayText,
+  isProviderTool,
+  calculateContextUsage,
+  withContextUsage,
+  resolveModelContextLimits,
+  Usage,
+  getAssistantGenerationMetadata,
+  CompletionCapabilityError,
+  assertCompletionRequestSupported,
+  textFromAssistantContent,
+  createCompletionRequest,
+  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
+  CompletionProviderOutputError,
+  assertCompletionResponseIntegrity,
+  CompletionStreamAccumulator,
+  CompletionStructuredOutputError,
+  generateCompletion,
+  streamCompletion,
+  isStreamingCompletionModel
+};
+//# sourceMappingURL=chunk-7PHMK7W4.js.map