@anvia/core 1.0.0-rc.6 → 1.0.0-rc.8

package/dist/chunk-HT4P3SSG.js

@@ -1,573 +0,0 @@
-import {
-  parseMessage,
-  parseMessages,
-  toProviderJsonSchema
-} from "./chunk-G5OACQEI.js";
-import {
-  isJsonValue
-} from "./chunk-SROQA7I7.js";
-import {
-  abortError,
-  resolveRetryOptions,
-  retryDelayMs,
-  retryOptionsForFailure,
-  runWithRetries,
-  throwIfAborted,
-  waitForRetry
-} from "./chunk-UBE4WH6G.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;
-  }
-};
-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/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) 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/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 === "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);
-  return runWithRetries(
-    () => {
-      throwIfAborted(abortSignal);
-      return model.completion(request, callOptions);
-    },
-    retries,
-    { streaming: false, abortSignal }
-  );
-}
-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);
-  while (true) {
-    let exposedProgress = false;
-    let retryDelay;
-    try {
-      throwIfAborted(abortSignal);
-      const events = model.streamCompletion(request, callOptions);
-      for await (const event of events) {
-        if (event.type === "error" && !exposedProgress) {
-          const retryOptions = retryOptionsForFailure(retries, {
-            error: event.error,
-            attempt,
-            streaming: true
-          });
-          if (retryOptions !== void 0) {
-            swallowedUsage = Usage.add(swallowedUsage, event.usage ?? Usage.empty());
-            retryDelay = retryDelayMs(retryOptions, attempt);
-            break;
-          }
-        }
-        if (event.type === "error") {
-          yield {
-            type: "error",
-            error: event.error,
-            usage: Usage.add(swallowedUsage, event.usage ?? Usage.empty())
-          };
-          return;
-        }
-        if (event.type === "final") {
-          const response = swallowedUsage.totalTokens === 0 ? event.response : {
-            ...event.response,
-            usage: Usage.add(swallowedUsage, event.response.usage)
-          };
-          try {
-            yield {
-              type: "final",
-              result: resultFromResponse(response, outputSchema)
-            };
-          } catch (error) {
-            yield { type: "error", error, usage: response.usage };
-          }
-          return;
-        }
-        exposedProgress = true;
-        yield event;
-      }
-      if (retryDelay !== void 0) {
-        await waitForRetry(retryDelay, abortSignal);
-        attempt += 1;
-        continue;
-      }
-      yield {
-        type: "error",
-        error: new Error("The completion model stream ended without a final event."),
-        usage: swallowedUsage
-      };
-      return;
-    } catch (error) {
-      const normalizedError = abortSignal?.aborted === true ? abortError(abortSignal.reason) : error;
-      if (!exposedProgress) {
-        const retryOptions = retryOptionsForFailure(retries, {
-          error: normalizedError,
-          attempt,
-          streaming: true
-        });
-        if (retryOptions !== void 0) {
-          try {
-            await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);
-            attempt += 1;
-            continue;
-          } catch (waitError) {
-            yield { type: "error", error: waitError, usage: swallowedUsage };
-            return;
-          }
-        }
-      }
-      yield { type: "error", error: normalizedError, usage: swallowedUsage };
-      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 === "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);
-  } 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,
-  CompletionStructuredOutputError,
-  generateCompletion,
-  streamCompletion,
-  isStreamingCompletionModel
-};
-//# sourceMappingURL=chunk-HT4P3SSG.js.map