@anvia/core 1.2.2 → 1.3.0

package/dist/{chunk-3EX524LK.js → chunk-VKRGWGA4.js}

@@ -1,7 +1,3 @@
-import {
-  TEAM_INSTRUCTIONS,
-  teamTools
-} from "./chunk-5TMN4MYN.js";
 import {
   TeamChanges,
   TeamSlots,
@@ -12,6 +8,10 @@ import {
   memberSummary,
   steeringMessages
 } from "./chunk-FSBDE6RF.js";
+import {
+  TEAM_INSTRUCTIONS,
+  teamTools
+} from "./chunk-CJKGTEN4.js";
 import {
   AgentTeamInteractionError,
   AgentTeamLimitError
@@ -19,10 +19,10 @@ import {
 import {
   createResolvedAgent,
   getResolvedAgentOptions
-} from "./chunk-VQTSZ4ZW.js";
+} from "./chunk-IYDGPF3C.js";
 import {
   AgentRun
-} from "./chunk-4PGI5HYY.js";
+} from "./chunk-A3DGCDGF.js";
 import {
   withInternalAgentRunOptions
 } from "./chunk-KITX3HDN.js";
@@ -36,7 +36,7 @@ import {
 } from "./chunk-KFAVEL5F.js";
 import {
   isStreamingCompletionModel
-} from "./chunk-BD2USPK5.js";
+} from "./chunk-YMTBHHLQ.js";
 import {
   Usage
 } from "./chunk-HJ6KTQTZ.js";
@@ -619,4 +619,4 @@ var TeamRun = class {
 export {
   TeamRun
 };
-//# sourceMappingURL=chunk-3EX524LK.js.map
+//# sourceMappingURL=chunk-VKRGWGA4.js.map

package/dist/{chunk-NA44V5OE.js → chunk-WCWSPU74.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-6BTJC3ES.js";
 import {
   isToolIndex
-} from "./chunk-VCMBQTR4.js";
+} from "./chunk-4BDSO4PQ.js";
 import {
   isMcpTool
 } from "./chunk-PLDJCCVL.js";
@@ -109,4 +109,4 @@ export {
   resolveAgentOptions,
   markResolvedAgentOptions
 };
-//# sourceMappingURL=chunk-NA44V5OE.js.map
+//# sourceMappingURL=chunk-WCWSPU74.js.map

package/dist/{chunk-WUZG6B3Q.js → chunk-Y365ABZY.js}

@@ -1,11 +1,11 @@
-import {
-  assertToolApprovalRequirement
-} from "./chunk-YZVFIW5D.js";
 import {
   attachPreparedToolOwner,
   preparedToolInput,
   withoutPreparedToolInput
 } from "./chunk-647TQE3E.js";
+import {
+  assertToolApprovalRequirement
+} from "./chunk-YZVFIW5D.js";
 import {
   toProviderJsonSchema
 } from "./chunk-SQAAVYJG.js";
@@ -55,4 +55,4 @@ function snapshotApprovalRequirement(requirement) {
 export {
   createTool
 };
-//# sourceMappingURL=chunk-WUZG6B3Q.js.map
+//# sourceMappingURL=chunk-Y365ABZY.js.map

package/dist/{chunk-BD2USPK5.js → chunk-YMTBHHLQ.js}

@@ -1,3 +1,11 @@
+import {
+  toProviderJsonSchemaFromStandardSchema,
+  tryToProviderJsonSchemaFromStandardSchema
+} from "./chunk-YOLOFTAY.js";
+import {
+  formatStandardSchemaIssues,
+  validateStandardSchema
+} from "./chunk-6OO5C5GW.js";
 import {
   createCompletionRequest
 } from "./chunk-GSVOMQEE.js";
@@ -16,9 +24,6 @@ import {
 import {
   isJsonValue
 } from "./chunk-4C7AXYOM.js";
-import {
-  toProviderJsonSchema
-} from "./chunk-SQAAVYJG.js";
 import {
   completionProviderOutputErrorUsage,
   resolveRetryOptions,
@@ -51,7 +56,7 @@ var CompletionStructuredOutputError = class extends Error {
 };
 async function generateCompletion(options) {
   throwIfAborted(options.abortSignal);
-  const request = requestFromOptions(options);
+  const request = await requestFromOptions(options);
   assertCompletionRequestSupported(options.model, request);
   const retries = resolveOptionalRetries(options.retries);
   const response = await sendCompletion(options.model, request, retries, options.abortSignal);
@@ -59,15 +64,20 @@ async function generateCompletion(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 { request, pendingSchema } = requestFromOptionsSync(options);
+  assertCompletionRequestSupported(
+    options.model,
+    pendingSchema === void 0 ? request : { ...request, outputSchema: request.outputSchema ?? {} },
+    { streaming: true }
+  );
   const retries = resolveOptionalRetries(options.retries);
   return streamCompletionWithRetries(
     options.model,
     request,
+    pendingSchema,
     retries,
     options.abortSignal,
     structuredOutputSchema(options)
@@ -101,7 +111,14 @@ async function sendCompletion(model, request, retries, abortSignal) {
 function resolveOptionalRetries(setting) {
   return setting === void 0 || setting === false ? void 0 : resolveRetryOptions(setting);
 }
-async function* streamCompletionWithRetries(model, request, retries, abortSignal, outputSchema) {
+async function* streamCompletionWithRetries(model, initialRequest, pendingSchema, retries, abortSignal, outputSchema) {
+  let request = initialRequest;
+  if (pendingSchema !== void 0) {
+    request = {
+      ...request,
+      outputSchema: await toProviderJsonSchemaFromStandardSchema(pendingSchema)
+    };
+  }
   let attempt = 1;
   let swallowedUsage = Usage.empty();
   const callOptions = modelCallOptions(abortSignal);
@@ -221,9 +238,28 @@ async function* streamCompletionWithRetries(model, request, retries, abortSignal
     }
   }
 }
-function requestFromOptions(options) {
+async function requestFromOptions(options) {
+  const { request, pendingSchema } = requestFromOptionsSync(options);
+  if (pendingSchema === void 0) return request;
+  return {
+    ...request,
+    outputSchema: await toProviderJsonSchemaFromStandardSchema(pendingSchema)
+  };
+}
+function requestFromOptionsSync(options) {
   const input = inputFromOptions(options);
-  return createCompletionRequest(input, {
+  const schema = structuredOutputSchema(options);
+  let outputSchema;
+  let pendingSchema;
+  if (schema !== void 0) {
+    const converted = tryToProviderJsonSchemaFromStandardSchema(schema);
+    if (converted.jsonSchema !== void 0) {
+      outputSchema = converted.jsonSchema;
+    } else {
+      pendingSchema = schema;
+    }
+  }
+  const request = createCompletionRequest(input, {
     instructions: options.instructions,
     documents: options.documents,
     tools: options.tools,
@@ -232,8 +268,9 @@ function requestFromOptions(options) {
     toolChoice: options.toolChoice,
     controls: options.controls,
     providerOptions: options.providerOptions,
-    outputSchema: "outputSchema" in options && options.outputSchema !== void 0 ? toProviderJsonSchema(options.outputSchema) : void 0
+    outputSchema
   });
+  return { request, pendingSchema };
 }
 function inputFromOptions(options) {
   const prompt = options.prompt;
@@ -313,8 +350,9 @@ function parseCompletionOutput(text, schema, response) {
       cause: error
     });
   }
+  let validation;
   try {
-    return schema.parse(json);
+    validation = validateStandardSchema(schema, json);
   } catch (error) {
     throw new CompletionStructuredOutputError({
       phase: "schema",
@@ -325,6 +363,17 @@ function parseCompletionOutput(text, schema, response) {
       cause: error
     });
   }
+  if (!validation.success) {
+    throw new CompletionStructuredOutputError({
+      phase: "schema",
+      outputLength: text.length,
+      usage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason,
+      cause: new Error(formatStandardSchemaIssues(validation.issues))
+    });
+  }
+  return validation.value;
 }
 function modelCallOptions(abortSignal) {
   return abortSignal === void 0 ? void 0 : { abortSignal };
@@ -339,4 +388,4 @@ export {
   streamCompletion,
   isStreamingCompletionModel
 };
-//# sourceMappingURL=chunk-BD2USPK5.js.map
+//# sourceMappingURL=chunk-YMTBHHLQ.js.map

package/dist/chunk-YMTBHHLQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/completion/generate-completion.ts"],"sourcesContent":["import { abortError, throwIfAborted } from \"../internal/abort\";\nimport { createCompletionRequest } from \"../internal/completion-request\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  completionProviderOutputErrorUsage,\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  retryDelayMs,\n  retryOptionsForFailure,\n  waitForRetry,\n} from \"../retry\";\nimport {\n  toProviderJsonSchemaFromStandardSchema,\n  tryToProviderJsonSchemaFromStandardSchema,\n} from \"../schema/standard-json-schema\";\nimport {\n  formatStandardSchemaIssues,\n  type StandardSchemaV1,\n  validateStandardSchema,\n} from \"../schema/standard-schema\";\nimport { isJsonValue } from \"./json\";\nimport {\n  assertCompletionResponseIntegrity,\n  CompletionProviderOutputError,\n} from \"./provider-output-error\";\nimport { CompletionStreamAccumulator } from \"./stream-accumulator\";\nimport type {\n  CompletionControlValues,\n  CompletionModel,\n  CompletionModelControlsOf,\n  CompletionModelStreamEvent,\n  CompletionRequest,\n  CompletionResponse,\n  CompletionResult,\n  CompletionStreamEvent,\n  CompletionTool,\n  Document,\n  JsonObject,\n  Message as MessageType,\n  StreamingCompletionModel,\n  ToolChoice,\n} from \"./types\";\nimport { assertCompletionRequestSupported, textFromAssistantContent, Usage } from \"./types\";\n\nexport type CompletionStructuredOutputPhase = \"truncated\" | \"content-filter\" | \"parse\" | \"schema\";\n\nexport class CompletionStructuredOutputError extends Error {\n  readonly phase: CompletionStructuredOutputPhase;\n  readonly outputLength: number;\n  readonly usage: Usage;\n  readonly finishReason: CompletionResponse[\"finishReason\"];\n  readonly providerFinishReason: string | undefined;\n\n  constructor(options: {\n    phase: CompletionStructuredOutputPhase;\n    outputLength: number;\n    usage: Usage;\n    finishReason?: CompletionResponse[\"finishReason\"];\n    providerFinishReason?: string | undefined;\n    cause?: unknown;\n  }) {\n    const failure =\n      options.phase === \"truncated\"\n        ? \"because the provider reached its output limit\"\n        : options.phase === \"content-filter\"\n          ? \"because the provider filtered the response\"\n          : options.phase === \"parse\"\n            ? \"during JSON parsing\"\n            : \"during schema validation\";\n    super(`Structured completion output failed ${failure}.`, { cause: options.cause });\n    this.name = \"CompletionStructuredOutputError\";\n    this.phase = options.phase;\n    this.outputLength = options.outputLength;\n    this.usage = options.usage;\n    this.finishReason = options.finishReason;\n    this.providerFinishReason = options.providerFinishReason;\n  }\n}\n\nexport type CompletionInput =\n  | { prompt: string; messages?: never }\n  | { messages: readonly MessageType[]; prompt?: never };\n\nexport type CompletionBaseOptions<Model extends CompletionModel = CompletionModel> =\n  CompletionInput & {\n    model: Model;\n    instructions?: string | undefined;\n    documents?: readonly Document[] | undefined;\n    tools?: readonly CompletionTool[] | undefined;\n    temperature?: number | undefined;\n    maxTokens?: number | undefined;\n    toolChoice?: ToolChoice | undefined;\n    controls?: CompletionControlValues<CompletionModelControlsOf<Model>> | undefined;\n    providerOptions?: JsonObject | undefined;\n    retries?: RetrySetting | undefined;\n    abortSignal?: AbortSignal | undefined;\n  };\n\nexport type GenerateCompletionOptions<Model extends CompletionModel = CompletionModel> =\n  CompletionBaseOptions<Model> & { outputSchema?: never };\n\nexport type GenerateStructuredCompletionOptions<\n  Output,\n  Model extends CompletionModel = CompletionModel,\n> = CompletionBaseOptions<Model> & { outputSchema: StandardSchemaV1<unknown, Output> };\n\nexport type StreamCompletionOptions<\n  Model extends StreamingCompletionModel = StreamingCompletionModel,\n> = GenerateCompletionOptions<Model>;\n\nexport type StreamStructuredCompletionOptions<\n  Output,\n  Model extends StreamingCompletionModel = StreamingCompletionModel,\n> = GenerateStructuredCompletionOptions<Output, Model>;\n\ntype RawResponseOf<Model> =\n  Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;\n\nexport function generateCompletion<Output, Model extends CompletionModel>(\n  options: GenerateStructuredCompletionOptions<Output, Model>,\n): Promise<CompletionResult<Output, RawResponseOf<Model>>>;\nexport function generateCompletion<Model extends CompletionModel>(\n  options: GenerateCompletionOptions<Model>,\n): Promise<CompletionResult<string, RawResponseOf<Model>>>;\nexport async function generateCompletion<Output, Model extends CompletionModel>(\n  options: GenerateCompletionOptions<Model> | GenerateStructuredCompletionOptions<Output, Model>,\n): Promise<CompletionResult<Output | string, RawResponseOf<Model>>> {\n  throwIfAborted(options.abortSignal);\n  const request = await requestFromOptions(options);\n  assertCompletionRequestSupported(options.model, request);\n  const retries = resolveOptionalRetries(options.retries);\n  const response = await sendCompletion(options.model, request, retries, options.abortSignal);\n  return resultFromResponse(response, structuredOutputSchema(options));\n}\n\nexport function streamCompletion<Output, Model extends StreamingCompletionModel>(\n  options: StreamStructuredCompletionOptions<Output, Model>,\n): AsyncIterable<CompletionStreamEvent<Output, RawResponseOf<Model>>>;\nexport function streamCompletion<Model extends StreamingCompletionModel>(\n  options: StreamCompletionOptions<Model>,\n): AsyncIterable<CompletionStreamEvent<string, RawResponseOf<Model>>>;\nexport function streamCompletion<Output, Model extends StreamingCompletionModel>(\n  options: StreamCompletionOptions<Model> | StreamStructuredCompletionOptions<Output, Model>,\n): AsyncIterable<CompletionStreamEvent<Output | string, RawResponseOf<Model>>> {\n  throwIfAborted(options.abortSignal);\n  if (!isStreamingCompletionModel(options.model) || !options.model.capabilities.streaming) {\n    throw new Error(\"This completion model does not support streaming\");\n  }\n  const { request, pendingSchema } = requestFromOptionsSync(options);\n  // Schemas whose JSON Schema conversion is deferred still count as an output\n  // schema for capability validation.\n  assertCompletionRequestSupported(\n    options.model,\n    pendingSchema === undefined\n      ? request\n      : { ...request, outputSchema: request.outputSchema ?? {} },\n    { streaming: true },\n  );\n  const retries = resolveOptionalRetries(options.retries);\n  return streamCompletionWithRetries(\n    options.model,\n    request,\n    pendingSchema,\n    retries,\n    options.abortSignal,\n    structuredOutputSchema(options),\n  );\n}\n\nasync function sendCompletion<Model extends CompletionModel>(\n  model: Model,\n  request: CompletionRequest,\n  retries: ResolvedRetryOptions | undefined,\n  abortSignal: AbortSignal | undefined,\n): Promise<CompletionResponse<RawResponseOf<Model>>> {\n  const callOptions = modelCallOptions(abortSignal);\n  let attempt = 1;\n  let failedUsage = Usage.empty();\n  while (true) {\n    try {\n      throwIfAborted(abortSignal);\n      const response = (await model.completion(request, callOptions)) as CompletionResponse<\n        RawResponseOf<Model>\n      >;\n      assertCompletionResponseIntegrity({ response });\n      return Usage.isEmpty(failedUsage)\n        ? response\n        : { ...response, usage: Usage.add(failedUsage, response.usage) };\n    } catch (error) {\n      const normalizedError =\n        abortSignal?.aborted === true ? abortError(abortSignal.reason) : error;\n      const attemptUsage = completionProviderOutputErrorUsage(normalizedError);\n      if (attemptUsage !== undefined) failedUsage = Usage.add(failedUsage, attemptUsage);\n      const retryOptions = retryOptionsForFailure(retries, {\n        error: normalizedError,\n        attempt,\n        streaming: false,\n      });\n      if (retryOptions === undefined) throw normalizedError;\n      await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);\n      attempt += 1;\n    }\n  }\n}\n\nfunction resolveOptionalRetries(\n  setting: RetrySetting | undefined,\n): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nasync function* streamCompletionWithRetries<Output, Model extends StreamingCompletionModel>(\n  model: Model,\n  initialRequest: CompletionRequest,\n  pendingSchema: StandardSchemaV1<unknown, Output> | undefined,\n  retries: ResolvedRetryOptions | undefined,\n  abortSignal: AbortSignal | undefined,\n  outputSchema: StandardSchemaV1<unknown, Output> | undefined,\n): AsyncIterable<CompletionStreamEvent<Output | string, RawResponseOf<Model>>> {\n  let request = initialRequest;\n  if (pendingSchema !== undefined) {\n    request = {\n      ...request,\n      outputSchema: await toProviderJsonSchemaFromStandardSchema(pendingSchema),\n    };\n  }\n  let attempt = 1;\n  let swallowedUsage = Usage.empty();\n  const callOptions = modelCallOptions(abortSignal);\n\n  attemptLoop: while (true) {\n    let exposedProgress = false;\n    let retryDelay: number | undefined;\n    const accumulator = new CompletionStreamAccumulator<RawResponseOf<Model>>();\n    try {\n      throwIfAborted(abortSignal);\n      const events = model.streamCompletion(request, callOptions) as AsyncIterable<\n        CompletionModelStreamEvent<RawResponseOf<Model>>\n      >;\n      for await (const event of events) {\n        if (event.type === \"error\" && !exposedProgress) {\n          const eventError =\n            abortSignal?.aborted === true ? abortError(abortSignal.reason) : event.error;\n          const eventUsage =\n            event.usage ?? completionProviderOutputErrorUsage(eventError) ?? Usage.empty();\n          const retryOptions = retryOptionsForFailure(retries, {\n            error: eventError,\n            attempt,\n            streaming: true,\n          });\n          if (retryOptions !== undefined) {\n            swallowedUsage = Usage.add(swallowedUsage, eventUsage);\n            retryDelay = retryDelayMs(retryOptions, attempt);\n            break;\n          }\n        }\n\n        if (event.type === \"error\") {\n          const eventError =\n            abortSignal?.aborted === true ? abortError(abortSignal.reason) : event.error;\n          const eventUsage =\n            event.usage ?? completionProviderOutputErrorUsage(eventError) ?? Usage.empty();\n          yield {\n            type: \"error\",\n            error: eventError,\n            usage: Usage.add(swallowedUsage, eventUsage),\n          };\n          return;\n        }\n\n        if (event.type === \"final\") {\n          const cumulativeUsage = Usage.add(swallowedUsage, event.response.usage);\n          try {\n            accumulator.accept(event);\n            const accumulatedResponse = accumulator.response();\n            const response = Usage.isEmpty(swallowedUsage)\n              ? accumulatedResponse\n              : { ...accumulatedResponse, usage: cumulativeUsage };\n            assertCompletionResponseIntegrity({ response });\n            yield {\n              type: \"final\",\n              result: resultFromResponse(response, outputSchema),\n            };\n          } catch (error) {\n            const retryOptions = exposedProgress\n              ? undefined\n              : retryOptionsForFailure(retries, {\n                  error,\n                  attempt,\n                  streaming: true,\n                });\n            if (retryOptions !== undefined) {\n              swallowedUsage = cumulativeUsage;\n              await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);\n              attempt += 1;\n              continue attemptLoop;\n            }\n            yield { type: \"error\", error, usage: cumulativeUsage };\n          }\n          return;\n        }\n\n        accumulator.accept(event);\n        exposedProgress = true;\n        yield event;\n      }\n\n      if (retryDelay !== undefined) {\n        await waitForRetry(retryDelay, abortSignal);\n        attempt += 1;\n        continue;\n      }\n\n      let incomplete: unknown;\n      try {\n        accumulator.response();\n        incomplete = new CompletionProviderOutputError({ kind: \"incomplete-stream\" });\n      } catch (error) {\n        incomplete = error;\n      }\n      if (!exposedProgress) {\n        const retryOptions = retryOptionsForFailure(retries, {\n          error: incomplete,\n          attempt,\n          streaming: true,\n        });\n        if (retryOptions !== undefined) {\n          await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);\n          attempt += 1;\n          continue;\n        }\n      }\n      yield { type: \"error\", error: incomplete, usage: swallowedUsage };\n      return;\n    } catch (error) {\n      const normalizedError =\n        abortSignal?.aborted === true ? abortError(abortSignal.reason) : error;\n      const attemptUsage = completionProviderOutputErrorUsage(normalizedError);\n      const cumulativeUsage =\n        attemptUsage === undefined ? swallowedUsage : Usage.add(swallowedUsage, attemptUsage);\n      if (!exposedProgress) {\n        const retryOptions = retryOptionsForFailure(retries, {\n          error: normalizedError,\n          attempt,\n          streaming: true,\n        });\n        if (retryOptions !== undefined) {\n          try {\n            swallowedUsage = cumulativeUsage;\n            await waitForRetry(retryDelayMs(retryOptions, attempt), abortSignal);\n            attempt += 1;\n            continue;\n          } catch (waitError) {\n            yield { type: \"error\", error: waitError, usage: cumulativeUsage };\n            return;\n          }\n        }\n      }\n      yield { type: \"error\", error: normalizedError, usage: cumulativeUsage };\n      return;\n    }\n  }\n}\n\nasync function requestFromOptions<Model extends CompletionModel, Output>(\n  options: GenerateCompletionOptions<Model> | GenerateStructuredCompletionOptions<Output, Model>,\n): Promise<CompletionRequest> {\n  const { request, pendingSchema } = requestFromOptionsSync(options);\n  if (pendingSchema === undefined) return request;\n  return {\n    ...request,\n    outputSchema: await toProviderJsonSchemaFromStandardSchema(pendingSchema),\n  };\n}\n\nfunction requestFromOptionsSync<Model extends CompletionModel, Output>(\n  options: GenerateCompletionOptions<Model> | GenerateStructuredCompletionOptions<Output, Model>,\n): {\n  request: CompletionRequest;\n  pendingSchema: StandardSchemaV1<unknown, Output> | undefined;\n} {\n  const input = inputFromOptions(options);\n  const schema = structuredOutputSchema(options);\n  let outputSchema: JsonObject | undefined;\n  let pendingSchema: StandardSchemaV1<unknown, Output> | undefined;\n  if (schema !== undefined) {\n    const converted = tryToProviderJsonSchemaFromStandardSchema(schema);\n    if (converted.jsonSchema !== undefined) {\n      outputSchema = converted.jsonSchema;\n    } else {\n      pendingSchema = schema;\n    }\n  }\n  const request = createCompletionRequest(input, {\n    instructions: options.instructions,\n    documents: options.documents,\n    tools: options.tools,\n    temperature: options.temperature,\n    maxTokens: options.maxTokens,\n    toolChoice: options.toolChoice,\n    controls: options.controls,\n    providerOptions: options.providerOptions,\n    outputSchema,\n  });\n  return { request, pendingSchema };\n}\n\nfunction inputFromOptions(options: CompletionInput): string | readonly MessageType[] {\n  const prompt = (options as { prompt?: unknown }).prompt;\n  const messages = (options as { messages?: unknown }).messages;\n  const hasPrompt = prompt !== undefined;\n  const hasMessages = messages !== undefined;\n  if (hasPrompt === hasMessages) {\n    throw new TypeError(\"Exactly one of prompt or messages must be provided.\");\n  }\n  if (hasPrompt) {\n    if (typeof prompt !== \"string\" || prompt.trim().length === 0) {\n      throw new TypeError(\"Completion prompt must be a non-empty string.\");\n    }\n    return prompt;\n  }\n  if (!Array.isArray(messages)) {\n    throw new TypeError(\"Completion messages must be an array of Message values.\");\n  }\n  return messages as readonly MessageType[];\n}\n\nfunction structuredOutputSchema<Output>(options: {\n  outputSchema?: StandardSchemaV1<unknown, Output> | undefined;\n}): StandardSchemaV1<unknown, Output> | undefined {\n  return options.outputSchema;\n}\n\nfunction resultFromResponse<Output, RawResponse>(\n  response: CompletionResponse<RawResponse>,\n  outputSchema: StandardSchemaV1<unknown, Output> | undefined,\n): CompletionResult<Output | string, RawResponse> {\n  const text = textFromAssistantContent(response.choice);\n  const result: CompletionResult<Output | string, RawResponse> = {\n    output: outputSchema === undefined ? text : parseCompletionOutput(text, outputSchema, response),\n    text,\n    content: [...response.choice],\n    usage: response.usage,\n    rawResponse: response.rawResponse,\n  };\n  if (response.finishReason !== undefined) result.finishReason = response.finishReason;\n  if (response.providerFinishReason !== undefined) {\n    result.providerFinishReason = response.providerFinishReason;\n  }\n  if (response.contextUsage !== undefined) result.contextUsage = response.contextUsage;\n  if (response.messageId !== undefined) result.messageId = response.messageId;\n  if (response.sources !== undefined) result.sources = [...response.sources];\n  if (response.providerToolCalls !== undefined) {\n    result.providerToolCalls = [...response.providerToolCalls];\n  }\n  return result;\n}\n\nfunction parseCompletionOutput<Output, RawResponse>(\n  text: string,\n  schema: StandardSchemaV1<unknown, Output>,\n  response: CompletionResponse<RawResponse>,\n): Output {\n  if (response.finishReason === \"content-filter\") {\n    throw new CompletionStructuredOutputError({\n      phase: \"content-filter\",\n      outputLength: text.length,\n      usage: response.usage,\n      finishReason: response.finishReason,\n      providerFinishReason: response.providerFinishReason,\n    });\n  }\n  if (response.finishReason === \"length\") {\n    throw new CompletionStructuredOutputError({\n      phase: \"truncated\",\n      outputLength: text.length,\n      usage: response.usage,\n      finishReason: response.finishReason,\n      providerFinishReason: response.providerFinishReason,\n    });\n  }\n  let json: unknown;\n  try {\n    json = JSON.parse(text);\n    if (!isJsonValue(json)) {\n      throw new TypeError(\"Structured completion output is not a JSON value.\");\n    }\n  } catch (error) {\n    throw new CompletionStructuredOutputError({\n      phase: \"parse\",\n      outputLength: text.length,\n      usage: response.usage,\n      finishReason: response.finishReason,\n      providerFinishReason: response.providerFinishReason,\n      cause: error,\n    });\n  }\n  let validation: ReturnType<typeof validateStandardSchema<Output>>;\n  try {\n    validation = validateStandardSchema(schema, json);\n  } catch (error) {\n    throw new CompletionStructuredOutputError({\n      phase: \"schema\",\n      outputLength: text.length,\n      usage: response.usage,\n      finishReason: response.finishReason,\n      providerFinishReason: response.providerFinishReason,\n      cause: error,\n    });\n  }\n  if (!validation.success) {\n    throw new CompletionStructuredOutputError({\n      phase: \"schema\",\n      outputLength: text.length,\n      usage: response.usage,\n      finishReason: response.finishReason,\n      providerFinishReason: response.providerFinishReason,\n      cause: new Error(formatStandardSchemaIssues(validation.issues)),\n    });\n  }\n  return validation.value;\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nexport function isStreamingCompletionModel(\n  model: CompletionModel,\n): model is StreamingCompletionModel {\n  return typeof (model as { streamCompletion?: unknown }).streamCompletion === \"function\";\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-YOLOFTAY.js

@@ -0,0 +1,144 @@
+import {
+  toProviderJsonSchema
+} from "./chunk-SQAAVYJG.js";
+
+// src/schema/standard-json-schema.ts
+var JSON_SCHEMA_TARGET = "draft-2020-12";
+function tryToProviderJsonSchemaFromStandardSchema(schema) {
+  const props = schema["~standard"];
+  if (props.vendor === "zod") {
+    const jsonSchema2 = toProviderZodJsonSchema(schema);
+    completeStrictObjectRefinements(jsonSchema2);
+    return { jsonSchema: jsonSchema2 };
+  }
+  const jsonSchema = props.jsonSchema;
+  if (typeof jsonSchema === "object" && jsonSchema !== null) {
+    return {
+      jsonSchema: toProviderJsonSchemaShape(jsonSchema.input({ target: JSON_SCHEMA_TARGET }))
+    };
+  }
+  return { pendingSchema: schema };
+}
+function toProviderZodJsonSchema(schema) {
+  let outputJsonSchema;
+  try {
+    outputJsonSchema = toProviderJsonSchema(schema, { io: "output" });
+  } catch {
+    return toProviderJsonSchema(schema, { io: "input" });
+  }
+  let inputJsonSchema;
+  try {
+    inputJsonSchema = toProviderJsonSchema(schema, { io: "input" });
+  } catch {
+    return outputJsonSchema;
+  }
+  return jsonSchemaMatchesInputShape(inputJsonSchema, outputJsonSchema) ? outputJsonSchema : inputJsonSchema;
+}
+function jsonSchemaMatchesInputShape(input, output) {
+  if (Array.isArray(input) || Array.isArray(output)) {
+    return Array.isArray(input) && Array.isArray(output) && input.length === output.length && input.every((item, index) => jsonSchemaMatchesInputShape(item, output[index]));
+  }
+  if (typeof input === "object" && input !== null && typeof output === "object" && output !== null) {
+    const inputKeys = Object.keys(input).sort();
+    const outputKeys = Object.keys(output).filter((key) => key !== "additionalProperties").sort();
+    return inputKeys.length === outputKeys.length && inputKeys.every((key, index) => {
+      const outputKey = outputKeys[index];
+      if (outputKey === void 0 || key !== outputKey) return false;
+      const inputValue = input[key];
+      const outputValue = output[outputKey];
+      return jsonSchemaMatchesInputShape(inputValue, outputValue);
+    });
+  }
+  return input === output;
+}
+async function toProviderJsonSchemaFromStandardSchema(schema) {
+  const converted = tryToProviderJsonSchemaFromStandardSchema(schema);
+  if (converted.jsonSchema !== void 0) return converted.jsonSchema;
+  const pending = converted.pendingSchema;
+  const vendor = pending["~standard"].vendor;
+  if (vendor === "valibot") {
+    return valibotToProviderJsonSchema(pending);
+  }
+  throw new Error(
+    `Structured output schemas from vendor "${vendor}" cannot be converted to a provider JSON schema. Use a Zod or Valibot schema, or make the schema implement the Standard JSON Schema interface ("~standard.jsonSchema").`
+  );
+}
+var valibotToJsonSchemaModule;
+async function loadValibotToJsonSchema() {
+  valibotToJsonSchemaModule ??= import("@valibot/to-json-schema");
+  try {
+    return await valibotToJsonSchemaModule;
+  } catch (error) {
+    valibotToJsonSchemaModule = void 0;
+    throw new Error(
+      'The structured output schema is a Valibot schema, but "@valibot/to-json-schema" is not installed. Install it to use Valibot schemas for structured output.',
+      { cause: error }
+    );
+  }
+}
+async function valibotToProviderJsonSchema(schema) {
+  const { toJsonSchema } = await loadValibotToJsonSchema();
+  const jsonSchema = toJsonSchema(schema, {
+    target: JSON_SCHEMA_TARGET,
+    typeMode: "input"
+  });
+  return toProviderJsonSchemaShape(jsonSchema);
+}
+function toProviderJsonSchemaShape(jsonSchema) {
+  const { $schema: _schema, ...providerSchema } = jsonSchema;
+  completeStrictObjectRefinements(providerSchema);
+  return providerSchema;
+}
+function completeStrictObjectRefinements(jsonSchema) {
+  completeSchemaNode(jsonSchema);
+}
+var SCHEMA_POSITIONS = /* @__PURE__ */ new Set([
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "contains",
+  "contentSchema",
+  "else",
+  "if",
+  "items",
+  "not",
+  "oneOf",
+  "prefixItems",
+  "propertyNames",
+  "then",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+]);
+var SCHEMA_MAP_POSITIONS = /* @__PURE__ */ new Set([
+  "$defs",
+  "definitions",
+  "dependencies",
+  "dependentSchemas",
+  "patternProperties",
+  "properties"
+]);
+function completeSchemaNode(node) {
+  if (Array.isArray(node)) {
+    for (const item of node) completeSchemaNode(item);
+    return;
+  }
+  if (typeof node !== "object" || node === null) return;
+  const schema = node;
+  if (schema.type === "object" && schema.additionalProperties === void 0) {
+    schema.additionalProperties = false;
+  }
+  for (const [key, value] of Object.entries(schema)) {
+    if (SCHEMA_POSITIONS.has(key)) {
+      completeSchemaNode(value);
+    } else if (SCHEMA_MAP_POSITIONS.has(key) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      for (const child of Object.values(value)) completeSchemaNode(child);
+    }
+  }
+}
+
+export {
+  tryToProviderJsonSchemaFromStandardSchema,
+  toProviderJsonSchemaFromStandardSchema
+};
+//# sourceMappingURL=chunk-YOLOFTAY.js.map

package/dist/chunk-YOLOFTAY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema/standard-json-schema.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport type { JsonObject, JsonValue } from \"../completion/index\";\nimport type { StandardJSONSchemaV1, StandardSchemaV1 } from \"./standard-schema\";\nimport { toProviderJsonSchema } from \"./zod-schema\";\n\nconst JSON_SCHEMA_TARGET = \"draft-2020-12\";\n\n/** The outcome of converting a Standard Schema to a provider JSON Schema. */\nexport type StandardSchemaJsonSchemaConversion =\n  | { readonly jsonSchema: JsonObject; readonly pendingSchema?: undefined }\n  | { readonly jsonSchema?: undefined; readonly pendingSchema: StandardSchemaV1 };\n\n/**\n * Converts a Standard Schema to the JSON Schema sent to providers when the\n * conversion can happen synchronously; otherwise returns the schema as pending\n * so callers can resolve it asynchronously with\n * {@link toProviderJsonSchemaFromStandardSchema}.\n *\n * Providers receive the schema's input representation: the raw provider\n * response is what `~standard.validate` receives as its validation input,\n * while the validated (possibly transformed) value becomes the completion\n * output. Object nodes are completed with `additionalProperties: false` so\n * payloads remain eligible for provider strict modes such as OpenAI\n * structured outputs.\n */\nexport function tryToProviderJsonSchemaFromStandardSchema(\n  schema: StandardSchemaV1,\n): StandardSchemaJsonSchemaConversion {\n  const props = schema[\"~standard\"];\n  // Zod keeps its native converter. Prefer the output representation: it\n  // validates identically for schemas without input/output differences and\n  // carries zod's strict-object refinements (additionalProperties: false)\n  // that provider strict modes such as OpenAI structured outputs require.\n  if (props.vendor === \"zod\") {\n    const jsonSchema = toProviderZodJsonSchema(schema as z.ZodType);\n    completeStrictObjectRefinements(jsonSchema);\n    return { jsonSchema };\n  }\n  // Generic support for any library implementing the Standard JSON Schema spec.\n  const jsonSchema = (\n    props as {\n      jsonSchema?: StandardJSONSchemaV1[\"~standard\"][\"jsonSchema\"] | undefined;\n    }\n  ).jsonSchema;\n  if (typeof jsonSchema === \"object\" && jsonSchema !== null) {\n    return {\n      jsonSchema: toProviderJsonSchemaShape(jsonSchema.input({ target: JSON_SCHEMA_TARGET })),\n    };\n  }\n  // Vendor-specific converters may need to be loaded asynchronously.\n  return { pendingSchema: schema };\n}\n\nfunction toProviderZodJsonSchema(schema: z.ZodType): JsonObject {\n  let outputJsonSchema: JsonObject;\n  try {\n    outputJsonSchema = toProviderJsonSchema(schema, { io: \"output\" });\n  } catch {\n    // Transformed schemas are unrepresentable on the output side. Describe the\n    // validation input instead so the provider emits values the schema\n    // accepts, and the transformed output becomes the completion result.\n    return toProviderJsonSchema(schema, { io: \"input\" });\n  }\n  let inputJsonSchema: JsonObject;\n  try {\n    inputJsonSchema = toProviderJsonSchema(schema, { io: \"input\" });\n  } catch {\n    // The input side is not representable while the output side is; the\n    // output side remains the best available description.\n    return outputJsonSchema;\n  }\n  // The provider response is fed to `~standard.validate` as its input, so the\n  // output representation may only be used when it describes the same accepted\n  // values as the input side. Ignoring additionalProperties keeps zod's\n  // strict-object refinements (which provider strict modes such as OpenAI\n  // structured outputs require) while still detecting schemas whose input and\n  // output values genuinely differ, like `z.string().pipe(z.coerce.number())`.\n  return jsonSchemaMatchesInputShape(inputJsonSchema, outputJsonSchema)\n    ? outputJsonSchema\n    : inputJsonSchema;\n}\n\n/** Checks whether the output-side schema shape equals the input-side shape, ignoring strictness. */\nfunction jsonSchemaMatchesInputShape(input: JsonValue, output: JsonValue): boolean {\n  if (Array.isArray(input) || Array.isArray(output)) {\n    return (\n      Array.isArray(input) &&\n      Array.isArray(output) &&\n      input.length === output.length &&\n      input.every((item, index) => jsonSchemaMatchesInputShape(item, output[index]))\n    );\n  }\n  if (\n    typeof input === \"object\" &&\n    input !== null &&\n    typeof output === \"object\" &&\n    output !== null\n  ) {\n    const inputKeys = Object.keys(input).sort();\n    const outputKeys = Object.keys(output)\n      .filter((key) => key !== \"additionalProperties\")\n      .sort();\n    return (\n      inputKeys.length === outputKeys.length &&\n      inputKeys.every((key, index) => {\n        const outputKey = outputKeys[index];\n        if (outputKey === undefined || key !== outputKey) return false;\n        // Keys come from Object.keys, so the indexed values exist by construction.\n        const inputValue = (input as Record<string, JsonValue>)[key] as JsonValue;\n        const outputValue = (output as Record<string, JsonValue>)[outputKey] as JsonValue;\n        return jsonSchemaMatchesInputShape(inputValue, outputValue);\n      })\n    );\n  }\n  return input === output;\n}\n\n/**\n * Converts any supported Standard Schema to the JSON Schema sent to providers.\n * Synchronously convertible schemas resolve immediately; Valibot schemas load\n * the optional `@valibot/to-json-schema` converter on first use.\n */\nexport async function toProviderJsonSchemaFromStandardSchema(\n  schema: StandardSchemaV1,\n): Promise<JsonObject> {\n  const converted = tryToProviderJsonSchemaFromStandardSchema(schema);\n  if (converted.jsonSchema !== undefined) return converted.jsonSchema;\n  const pending = converted.pendingSchema;\n  const vendor = pending[\"~standard\"].vendor;\n  if (vendor === \"valibot\") {\n    return valibotToProviderJsonSchema(pending);\n  }\n  throw new Error(\n    `Structured output schemas from vendor \"${vendor}\" cannot be converted to a provider JSON schema. ` +\n      `Use a Zod or Valibot schema, or make the schema implement the Standard JSON Schema interface (\"~standard.jsonSchema\").`,\n  );\n}\n\ntype ValibotToJsonSchemaModule = {\n  toJsonSchema: (\n    schema: StandardSchemaV1,\n    config?: {\n      readonly target?: \"draft-07\" | \"draft-2020-12\" | \"openapi-3.0\" | undefined;\n      readonly typeMode?: \"ignore\" | \"input\" | \"output\" | undefined;\n    },\n  ) => Record<string, unknown>;\n};\n\nlet valibotToJsonSchemaModule: Promise<ValibotToJsonSchemaModule> | undefined;\n\nasync function loadValibotToJsonSchema(): Promise<ValibotToJsonSchemaModule> {\n  valibotToJsonSchemaModule ??=\n    import(\"@valibot/to-json-schema\") as unknown as Promise<ValibotToJsonSchemaModule>;\n  try {\n    return await valibotToJsonSchemaModule;\n  } catch (error) {\n    valibotToJsonSchemaModule = undefined;\n    throw new Error(\n      'The structured output schema is a Valibot schema, but \"@valibot/to-json-schema\" is not installed. ' +\n        \"Install it to use Valibot schemas for structured output.\",\n      { cause: error },\n    );\n  }\n}\n\nasync function valibotToProviderJsonSchema(schema: StandardSchemaV1): Promise<JsonObject> {\n  const { toJsonSchema } = await loadValibotToJsonSchema();\n  const jsonSchema = toJsonSchema(schema, {\n    target: JSON_SCHEMA_TARGET,\n    typeMode: \"input\",\n  });\n  return toProviderJsonSchemaShape(jsonSchema);\n}\n\nfunction toProviderJsonSchemaShape(jsonSchema: Record<string, unknown>): JsonObject {\n  const { $schema: _schema, ...providerSchema } = jsonSchema;\n  completeStrictObjectRefinements(providerSchema);\n  // JSON Schema documents are JSON values by construction.\n  return providerSchema as JsonObject;\n}\n\n/**\n * Adds `additionalProperties: false` to object schema nodes that do not declare\n * it. Restricting the provider to declared properties is validation-safe\n * because schema libraries strip or accept unknown input keys, and provider\n * strict modes such as OpenAI structured outputs require the refinement.\n * Explicit values (for example permissive objects) are left untouched.\n *\n * Recursion follows schema-bearing keywords only, so literal values under\n * `const`, `enum`, `default`, `examples`, or extension keywords — which may\n * legitimately be objects with a `type` field — are never rewritten.\n */\nfunction completeStrictObjectRefinements(jsonSchema: unknown): void {\n  completeSchemaNode(jsonSchema);\n}\n\n// Schema-bearing keywords of the drafts the converters are requested to\n// produce (draft-07, draft-2020-12), so literal values under const, enum,\n// annotations, and extension keywords are never rewritten.\nconst SCHEMA_POSITIONS: ReadonlySet<string> = new Set([\n  \"additionalItems\",\n  \"additionalProperties\",\n  \"allOf\",\n  \"anyOf\",\n  \"contains\",\n  \"contentSchema\",\n  \"else\",\n  \"if\",\n  \"items\",\n  \"not\",\n  \"oneOf\",\n  \"prefixItems\",\n  \"propertyNames\",\n  \"then\",\n  \"unevaluatedItems\",\n  \"unevaluatedProperties\",\n]);\n\nconst SCHEMA_MAP_POSITIONS: ReadonlySet<string> = new Set([\n  \"$defs\",\n  \"definitions\",\n  \"dependencies\",\n  \"dependentSchemas\",\n  \"patternProperties\",\n  \"properties\",\n]);\n\nfunction completeSchemaNode(node: unknown): void {\n  if (Array.isArray(node)) {\n    // Lists of schemas, like prefixItems and draft-07 items.\n    for (const item of node) completeSchemaNode(item);\n    return;\n  }\n  if (typeof node !== \"object\" || node === null) return;\n  const schema = node as Record<string, unknown>;\n  if (schema.type === \"object\" && schema.additionalProperties === undefined) {\n    schema.additionalProperties = false;\n  }\n  for (const [key, value] of Object.entries(schema)) {\n    if (SCHEMA_POSITIONS.has(key)) {\n      completeSchemaNode(value);\n    } else if (\n      SCHEMA_MAP_POSITIONS.has(key) &&\n      typeof value === \"object\" &&\n      value !== null &&\n      !Array.isArray(value)\n    ) {\n      for (const child of Object.values(value)) completeSchemaNode(child);\n    }\n  }\n}\n"],"mappings":"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","names":["jsonSchema"]}

package/dist/{chunk-HAVSSHOW.js → chunk-ZGDUEOSH.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-V3FFZWF3.js";
 import {
   extract
-} from "./chunk-3P65RSBB.js";
+} from "./chunk-7TUAAGVR.js";
 import {
   mapWithConcurrency
 } from "./chunk-4FIVU53H.js";
@@ -372,4 +372,4 @@ function normalizeParallelBranches(branches) {
 export {
   Pipeline
 };
-//# sourceMappingURL=chunk-HAVSSHOW.js.map
+//# sourceMappingURL=chunk-ZGDUEOSH.js.map

package/dist/completion/generate-completion.js

@@ -3,7 +3,9 @@ import {
   generateCompletion,
   isStreamingCompletionModel,
   streamCompletion
-} from "../chunk-BD2USPK5.js";
+} from "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";

package/dist/completion/index.d.ts

@@ -1,9 +1,8 @@
 export { M as ModelCallOptions } from '../model-call-options-CZkSw_xN.js';
 export { R as RetryContext, a as RetryOptions, b as RetrySetting } from '../retry-CjvSlKGW.js';
-export { C as COMPLETION_PROVIDER_OUTPUT_ERROR_CODE, a as CompletionBaseOptions, b as CompletionInput, c as CompletionProviderOutputError, d as CompletionProviderOutputErrorKind, e as CompletionProviderOutputErrorOptions, f as CompletionStructuredOutputError, g as CompletionStructuredOutputPhase, G as GenerateCompletionOptions, h as GenerateStructuredCompletionOptions, M as MessageMetadataSchema, R as REASONING_EFFORT_CONTROL_ID, i as ReasoningEffortControls, S as StreamCompletionOptions, j as StreamStructuredCompletionOptions, k as createMessageSchema, l as defineCompletionModelControls, m as generateCompletion, n as isJsonValue, o as isMessage, u as isStreamingCompletionModel, v as mergeCompletionControlValues, p as messageSchema, q as messagesSchema, r as parseMessage, s as parseMessages, t as streamCompletion } from '../provider-output-error-CMVoe1xT.js';
+export { C as COMPLETION_PROVIDER_OUTPUT_ERROR_CODE, a as CompletionBaseOptions, b as CompletionInput, c as CompletionProviderOutputError, d as CompletionProviderOutputErrorKind, e as CompletionProviderOutputErrorOptions, f as CompletionStructuredOutputError, g as CompletionStructuredOutputPhase, G as GenerateCompletionOptions, h as GenerateStructuredCompletionOptions, M as MessageMetadataSchema, R as REASONING_EFFORT_CONTROL_ID, i as ReasoningEffortControls, k as StreamCompletionOptions, l as StreamStructuredCompletionOptions, m as createMessageSchema, n as defineCompletionModelControls, o as generateCompletion, p as isJsonValue, q as isMessage, x as isStreamingCompletionModel, y as mergeCompletionControlValues, s as messageSchema, t as messagesSchema, u as parseMessage, v as parseMessages, w as streamCompletion } from '../provider-output-error-CQD0MWey.js';
 import { D as Document, M as Message } from '../types-DYqZKDA8.js';
 export { A as AssistantContentPart, a as AssistantGenerationMetadata, b as AssistantMessage, Z as CompletionCapabilityError, C as CompletionControlValues, c as CompletionFinishReason, d as CompletionModel, _ as CompletionModelCapabilities, e as CompletionModelControls, f as CompletionModelControlsOf, g as CompletionModelInfo, h as CompletionModelSelectControl, i as CompletionModelStreamEvent, j as CompletionRequest, k as CompletionResponse, l as CompletionResult, m as CompletionSource, n as CompletionStreamEvent, $ as CompletionStreamPart, o as CompletionTool, p as ContextUsage, F as FileData, q as FilePart, I as ImageDetail, r as ImagePart, J as JsonObject, s as JsonPrimitive, t as JsonValue, u as ModelContextLimits, N as NoCompletionModelControls, P as ProviderTool, v as ProviderToolCall, R as ReasoningContentType, w as ReasoningDetail, x as ReasoningPart, a0 as StreamingCompletionModel, S as SystemMessage, T as TextPart, a1 as ToolApprovalResponsePart, a2 as ToolCallArgumentsMode, y as ToolCallPart, z as ToolChoice, B as ToolDefinition, a3 as ToolInteractionResponsePart, E as ToolMessage, a4 as ToolQuestionAnswer, a5 as ToolQuestionResponsePart, G as ToolResultContentPart, H as ToolResultOutput, K as ToolResultPart, U as Usage, a6 as UsageDetails, L as UserContentPart, O as UserMessage, a7 as assertCompletionControlsSupported, a8 as assertCompletionRequestSupported, Q as calculateContextUsage, V as getAssistantGenerationMetadata, W as isProviderTool, a9 as reasoningDisplayText, X as resolveModelContextLimits, aa as textFromAssistantContent, Y as withContextUsage } from '../types-DYqZKDA8.js';
-import '../zod-schema-C7F4clpm.js';
 import 'zod';
 
 declare function normalizeDocuments(documents: Document[]): Message | undefined;

package/dist/completion/index.js

@@ -13,7 +13,9 @@ import {
   generateCompletion,
   isStreamingCompletionModel,
   streamCompletion
-} from "../chunk-BD2USPK5.js";
+} from "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";

package/dist/embeddings/index.js

@@ -1,5 +1,4 @@
 import "../chunk-ERN7P6Q4.js";
-import "../chunk-DU4WA6LQ.js";
 import {
   angularDistance,
   chebyshevDistance,
@@ -15,6 +14,7 @@ import {
   embedText,
   embedTexts
 } from "../chunk-HHMLE3TZ.js";
+import "../chunk-DU4WA6LQ.js";
 import "../chunk-4FIVU53H.js";
 import "../chunk-POXHJF3H.js";
 import "../chunk-USRKPEQN.js";

package/dist/evals/advanced-metrics.js

@@ -9,18 +9,20 @@ import {
   promptAlignment,
   summarization,
   turnRelevancy
-} from "../chunk-VPTAGK7G.js";
-import "../chunk-63DUKYEG.js";
+} from "../chunk-V5DWNXVH.js";
+import "../chunk-5SJBSCG2.js";
 import "../chunk-ZPXOBQDS.js";
 import "../chunk-3P3YVJ7V.js";
-import "../chunk-3P65RSBB.js";
+import "../chunk-7TUAAGVR.js";
 import "../chunk-ZYXMWEL4.js";
 import "../chunk-EJR6VVB3.js";
 import "../chunk-TP3MCUXS.js";
 import "../chunk-6RQYWZI3.js";
 import "../chunk-NF6WBPFG.js";
 import "../chunk-4FIVU53H.js";
-import "../chunk-BD2USPK5.js";
+import "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";

package/dist/evals/cli.js

@@ -16,7 +16,9 @@ import "../chunk-JMMZICU7.js";
 import "../chunk-TP3MCUXS.js";
 import "../chunk-6RQYWZI3.js";
 import "../chunk-NF6WBPFG.js";
-import "../chunk-BD2USPK5.js";
+import "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";

package/dist/evals/index.js

@@ -19,7 +19,7 @@ import {
   notContains,
   requiredFields,
   semanticSimilarity
-} from "../chunk-N2AQUFGO.js";
+} from "../chunk-RFFOL6ON.js";
 import {
   abstention,
   answerRelevancy,
@@ -31,14 +31,14 @@ import {
   promptAlignment,
   summarization,
   turnRelevancy
-} from "../chunk-VPTAGK7G.js";
-import "../chunk-63DUKYEG.js";
+} from "../chunk-V5DWNXVH.js";
+import "../chunk-5SJBSCG2.js";
 import {
   selectEvalCaseIds,
   selectPromptOutput
 } from "../chunk-ZPXOBQDS.js";
 import "../chunk-3P3YVJ7V.js";
-import "../chunk-3P65RSBB.js";
+import "../chunk-7TUAAGVR.js";
 import {
   AgentEvalSuspensionError,
   agentEvalTarget
@@ -75,11 +75,13 @@ import "../chunk-TP3MCUXS.js";
 import "../chunk-6RQYWZI3.js";
 import "../chunk-NF6WBPFG.js";
 import "../chunk-ERN7P6Q4.js";
-import "../chunk-DU4WA6LQ.js";
 import "../chunk-7F53DOML.js";
 import "../chunk-HHMLE3TZ.js";
+import "../chunk-DU4WA6LQ.js";
 import "../chunk-4FIVU53H.js";
-import "../chunk-BD2USPK5.js";
+import "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";

package/dist/evals/judge.js

@@ -2,13 +2,15 @@ import {
   addUsage,
   evaluationMetadata,
   runJudge
-} from "../chunk-63DUKYEG.js";
+} from "../chunk-5SJBSCG2.js";
 import "../chunk-3P3YVJ7V.js";
-import "../chunk-3P65RSBB.js";
+import "../chunk-7TUAAGVR.js";
 import "../chunk-TP3MCUXS.js";
 import "../chunk-6RQYWZI3.js";
 import "../chunk-NF6WBPFG.js";
-import "../chunk-BD2USPK5.js";
+import "../chunk-YMTBHHLQ.js";
+import "../chunk-YOLOFTAY.js";
+import "../chunk-6OO5C5GW.js";
 import "../chunk-GSVOMQEE.js";
 import "../chunk-4ONUNWGC.js";
 import "../chunk-2JZV4LUS.js";