@anvia/core 1.1.1 → 1.2.0

package/dist/chunk-OI3LSMJG.js

@@ -1,1545 +0,0 @@
-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;
-  assertCompletionControlsSupported(model, request.controls);
-  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 assertCompletionControlsSupported(model, controls) {
-  const modelLabel = `${model.provider}:${model.modelId}`;
-  for (const [controlId, value] of Object.entries(controls ?? {})) {
-    if (value === void 0) continue;
-    const modelControls = model.controls;
-    const control = modelControls !== void 0 && Object.hasOwn(modelControls, controlId) ? modelControls[controlId] : void 0;
-    if (control === void 0) {
-      throw new CompletionCapabilityError(
-        `${modelLabel} does not support completion control "${controlId}".`
-      );
-    }
-    if (!control.options.includes(value)) {
-      throw new CompletionCapabilityError(
-        `${modelLabel} completion control "${controlId}" does not support value "${value}".`
-      );
-    }
-  }
-}
-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.controls !== void 0) {
-    const controls = Object.fromEntries(
-      Object.entries(options.controls).filter(
-        (entry) => typeof entry[1] === "string"
-      )
-    );
-    if (Object.keys(controls).length > 0) request.controls = Object.freeze(controls);
-  }
-  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,
-    controls: options.controls,
-    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,
-  assertCompletionControlsSupported,
-  textFromAssistantContent,
-  createCompletionRequest,
-  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
-  CompletionProviderOutputError,
-  assertCompletionResponseIntegrity,
-  CompletionStreamAccumulator,
-  CompletionStructuredOutputError,
-  generateCompletion,
-  streamCompletion,
-  isStreamingCompletionModel
-};
-//# sourceMappingURL=chunk-OI3LSMJG.js.map