@anvia/core 1.1.2 → 1.2.0

package/dist/chunk-5AETKC4L.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/agent/team/agent-team.ts"],"sourcesContent":["import { Agent } from \"../agent\";\nimport type { CompletionModel } from \"../../completion\";\nimport { assertPositiveSafeInteger } from \"../../internal/agent-runtime/run-validation\";\nimport { TeamRun } from \"../../internal/team-runtime/run\";\nimport { TeamStream } from \"../../internal/team-runtime/stream\";\nimport { TeamPolicy } from \"../../internal/team-runtime/policy\";\nimport type {\n  AgentTeamLimits,\n  AgentTeamMember,\n  AgentTeamOptions,\n  AgentTeamOutcome,\n  AgentTeamRunOptions,\n  AgentTeamStream,\n} from \"./types\";\n\nexport class AgentTeam<\n  Output = string,\n  M extends CompletionModel = CompletionModel,\n  ContextDocument = unknown,\n> {\n  readonly id: string;\n  readonly members: readonly AgentTeamMember[];\n  readonly limits: Readonly<Required<AgentTeamLimits>>;\n  private readonly coordinator: Agent<Output, M, ContextDocument>;\n  private readonly policy: TeamPolicy;\n\n  constructor(options: AgentTeamOptions<Output, M, ContextDocument>) {\n    this.coordinator = new Agent(options);\n    this.id = this.coordinator.id;\n    if (!Array.isArray(options.members)) throw new TypeError(\"AgentTeam requires a members array.\");\n    const ids = new Set<string>();\n    for (const member of options.members) {\n      if (!(member instanceof Agent))\n        throw new TypeError(\"AgentTeam members must be Agent instances.\");\n      if (ids.has(member.id)) throw new TypeError(`Duplicate AgentTeam member ID: ${member.id}`);\n      if (!/^[a-zA-Z0-9_-]{1,58}$/.test(member.id))\n        throw new TypeError(\n          \"AgentTeam member IDs must form valid spawn tool names (1–58 letters, digits, underscores, or hyphens).\",\n        );\n      ids.add(member.id);\n    }\n    const reserved = new Set([\n      \"send_message\",\n      \"wait_for_agent\",\n      \"list_agents\",\n      \"cancel_agent\",\n      ...[...ids].map((id) => `spawn_${id}`),\n    ]);\n    for (const agent of [this.coordinator, ...options.members]) {\n      for (const tool of agent.tools) {\n        if (reserved.has(tool.name))\n          throw new TypeError(`Tool \"${tool.name}\" conflicts with an AgentTeam tool.`);\n      }\n    }\n    this.members = Object.freeze([...options.members]);\n    this.policy = new TeamPolicy(this.members, options.communication, options.spawning);\n    this.limits = Object.freeze({\n      maxDepth: assertPositiveSafeInteger(options.limits?.maxDepth ?? 3, \"maxDepth\"),\n      maxConcurrentAgents: assertPositiveSafeInteger(\n        options.limits?.maxConcurrentAgents ?? 4,\n        \"maxConcurrentAgents\",\n      ),\n      maxAgentInstances: assertPositiveSafeInteger(\n        options.limits?.maxAgentInstances ?? 12,\n        \"maxAgentInstances\",\n      ),\n      maxTotalTurns: assertPositiveSafeInteger(\n        options.limits?.maxTotalTurns ?? 100,\n        \"maxTotalTurns\",\n      ),\n      maxBufferedEvents: assertPositiveSafeInteger(\n        options.limits?.maxBufferedEvents ?? 1024,\n        \"maxBufferedEvents\",\n      ),\n    });\n  }\n\n  generate(options: AgentTeamRunOptions<Output, M>): Promise<AgentTeamOutcome<Output>> {\n    return this.createStream(options, false).result;\n  }\n\n  stream(options: AgentTeamRunOptions<Output, M>): AgentTeamStream<Output> {\n    return this.createStream(options, true);\n  }\n\n  private createStream(\n    options: AgentTeamRunOptions<Output, M>,\n    streaming: boolean,\n  ): AgentTeamStream<Output> {\n    if (\n      typeof options !== \"object\" ||\n      options === null ||\n      (options.prompt === undefined) === (options.messages === undefined)\n    ) {\n      throw new TypeError(\"AgentTeam runs require exactly one of prompt or messages.\");\n    }\n    if (\n      options.resolveInteraction !== undefined &&\n      typeof options.resolveInteraction !== \"function\"\n    ) {\n      throw new TypeError(\"resolveInteraction must be a function.\");\n    }\n    return new TeamStream(\n      (emit) =>\n        // The scheduler runs heterogeneous definitions. Public inputs are checked against M above.\n        new TeamRun(\n          this.coordinator,\n          this.policy,\n          this.limits,\n          { ...options } as AgentTeamRunOptions<unknown>,\n          streaming,\n          emit,\n        ),\n      this.limits.maxBufferedEvents,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeO,IAAM,YAAN,MAIL;AAAA,EACS;AAAA,EACA;AAAA,EACA;AAAA,EACQ;AAAA,EACA;AAAA,EAEjB,YAAY,SAAuD;AACjE,SAAK,cAAc,IAAI,MAAM,OAAO;AACpC,SAAK,KAAK,KAAK,YAAY;AAC3B,QAAI,CAAC,MAAM,QAAQ,QAAQ,OAAO,EAAG,OAAM,IAAI,UAAU,qCAAqC;AAC9F,UAAM,MAAM,oBAAI,IAAY;AAC5B,eAAW,UAAU,QAAQ,SAAS;AACpC,UAAI,EAAE,kBAAkB;AACtB,cAAM,IAAI,UAAU,4CAA4C;AAClE,UAAI,IAAI,IAAI,OAAO,EAAE,EAAG,OAAM,IAAI,UAAU,kCAAkC,OAAO,EAAE,EAAE;AACzF,UAAI,CAAC,wBAAwB,KAAK,OAAO,EAAE;AACzC,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AACF,UAAI,IAAI,OAAO,EAAE;AAAA,IACnB;AACA,UAAM,WAAW,oBAAI,IAAI;AAAA,MACvB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,GAAG,CAAC,GAAG,GAAG,EAAE,IAAI,CAAC,OAAO,SAAS,EAAE,EAAE;AAAA,IACvC,CAAC;AACD,eAAW,SAAS,CAAC,KAAK,aAAa,GAAG,QAAQ,OAAO,GAAG;AAC1D,iBAAW,QAAQ,MAAM,OAAO;AAC9B,YAAI,SAAS,IAAI,KAAK,IAAI;AACxB,gBAAM,IAAI,UAAU,SAAS,KAAK,IAAI,qCAAqC;AAAA,MAC/E;AAAA,IACF;AACA,SAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;AACjD,SAAK,SAAS,IAAI,WAAW,KAAK,SAAS,QAAQ,eAAe,QAAQ,QAAQ;AAClF,SAAK,SAAS,OAAO,OAAO;AAAA,MAC1B,UAAU,0BAA0B,QAAQ,QAAQ,YAAY,GAAG,UAAU;AAAA,MAC7E,qBAAqB;AAAA,QACnB,QAAQ,QAAQ,uBAAuB;AAAA,QACvC;AAAA,MACF;AAAA,MACA,mBAAmB;AAAA,QACjB,QAAQ,QAAQ,qBAAqB;AAAA,QACrC;AAAA,MACF;AAAA,MACA,eAAe;AAAA,QACb,QAAQ,QAAQ,iBAAiB;AAAA,QACjC;AAAA,MACF;AAAA,MACA,mBAAmB;AAAA,QACjB,QAAQ,QAAQ,qBAAqB;AAAA,QACrC;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,SAAS,SAA4E;AACnF,WAAO,KAAK,aAAa,SAAS,KAAK,EAAE;AAAA,EAC3C;AAAA,EAEA,OAAO,SAAkE;AACvE,WAAO,KAAK,aAAa,SAAS,IAAI;AAAA,EACxC;AAAA,EAEQ,aACN,SACA,WACyB;AACzB,QACE,OAAO,YAAY,YACnB,YAAY,QACX,QAAQ,WAAW,YAAgB,QAAQ,aAAa,SACzD;AACA,YAAM,IAAI,UAAU,2DAA2D;AAAA,IACjF;AACA,QACE,QAAQ,uBAAuB,UAC/B,OAAO,QAAQ,uBAAuB,YACtC;AACA,YAAM,IAAI,UAAU,wCAAwC;AAAA,IAC9D;AACA,WAAO,IAAI;AAAA,MACT,CAAC;AAAA;AAAA,QAEC,IAAI;AAAA,UACF,KAAK;AAAA,UACL,KAAK;AAAA,UACL,KAAK;AAAA,UACL,EAAE,GAAG,QAAQ;AAAA,UACb;AAAA,UACA;AAAA,QACF;AAAA;AAAA,MACF,KAAK,OAAO;AAAA,IACd;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-5I2NVRHC.js

@@ -0,0 +1,146 @@
+import {
+  parseAgentQuestionPrompts
+} from "./chunk-LBYJPMHC.js";
+import {
+  parseMessages
+} from "./chunk-BONQTXRQ.js";
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+
+// src/internal/agent-runtime/continuation-state.ts
+function serializeContinuationState(state) {
+  const value = structuredClone(state);
+  if (!isJsonValue(value) || Array.isArray(value) || value === null) {
+    throw new TypeError("Agent continuation state must be strict JSON.");
+  }
+  return value;
+}
+function parseContinuationState(value, interaction) {
+  requireOnlyKeys(value, [
+    "kind",
+    "history",
+    "messages",
+    "pending",
+    "remainingToolCalls",
+    "steering",
+    "memoryScope"
+  ]);
+  if (value.kind !== "anvia.agent-continuation") {
+    throw new TypeError("Agent continuation has an unsupported internal state.");
+  }
+  const history = parseMessages(value.history);
+  const messages = parseMessages(value.messages);
+  const pending = parsePending(value.pending);
+  const remainingToolCalls = parseToolCalls(value.remainingToolCalls);
+  const steering = parseSteering(value.steering);
+  if (pending.toolCall.toolCallId !== interaction.toolCallId || pending.toolCall.toolName !== interaction.toolName || pending.toolCall.callId !== interaction.callId || pending.internalCallId !== interaction.internalCallId) {
+    throw new TypeError("Agent continuation interaction does not match its pending tool call.");
+  }
+  if (interaction.type === "tool-approval" && !jsonEqual(interaction.input, pending.input)) {
+    throw new TypeError("Agent continuation approval input does not match its pending tool input.");
+  }
+  if (interaction.type === "tool-question") {
+    const questions = object(pending.input) && "questions" in pending.input ? parseAgentQuestionPrompts(pending.input.questions) : void 0;
+    if (questions === void 0 || !jsonEqual(interaction.questions, questions)) {
+      throw new TypeError(
+        "Agent continuation questions do not match its pending question tool input."
+      );
+    }
+  }
+  const state = {
+    kind: "anvia.agent-continuation",
+    history,
+    messages,
+    pending,
+    remainingToolCalls,
+    steering
+  };
+  if (value.memoryScope !== void 0) {
+    state.memoryScope = parseOptionalJsonObject(value.memoryScope, "memoryScope");
+  }
+  return state;
+}
+function questionResult(answers) {
+  return { type: "json", value: { answers: structuredClone([...answers]) } };
+}
+function parsePending(value) {
+  if (!object(value)) throw new TypeError("Agent continuation pending state is invalid.");
+  const [toolCall] = parseToolCalls([value.toolCall]);
+  if (toolCall === void 0) throw new TypeError("Agent continuation pending tool is missing.");
+  if (typeof value.effectiveArgs !== "string" || typeof value.internalCallId !== "string") {
+    throw new TypeError("Agent continuation pending execution metadata is invalid.");
+  }
+  const pending = {
+    toolCall,
+    effectiveArgs: value.effectiveArgs,
+    input: parseJsonValue(value.input, "pending input"),
+    internalCallId: value.internalCallId
+  };
+  if (typeof value.rejectMessage === "string") {
+    pending.rejectMessage = value.rejectMessage;
+  }
+  return pending;
+}
+function parseJsonValue(value, name) {
+  if (!isJsonValue(value)) {
+    throw new TypeError(`Agent continuation ${name} is invalid.`);
+  }
+  return structuredClone(value);
+}
+function parseToolCalls(value) {
+  if (!Array.isArray(value)) throw new TypeError("Agent continuation tool calls must be an array.");
+  const message = parseMessages([{ role: "assistant", content: value }])[0];
+  if (message?.role !== "assistant" || typeof message.content === "string") {
+    throw new TypeError("Agent continuation tool calls are invalid.");
+  }
+  if (!message.content.every((part) => part.type === "tool-call")) {
+    throw new TypeError("Agent continuation contains a non-tool-call part.");
+  }
+  return message.content;
+}
+function parseSteering(value) {
+  if (!Array.isArray(value)) throw new TypeError("Agent continuation steering state is invalid.");
+  return value.map((item) => {
+    if (!object(item) || typeof item.id !== "string") {
+      throw new TypeError("Agent continuation steering entry is invalid.");
+    }
+    return { id: item.id, messages: parseMessages(item.messages) };
+  });
+}
+function parseOptionalJsonObject(value, name) {
+  if (value === void 0) return void 0;
+  if (!object(value) || !isJsonValue(value)) {
+    throw new TypeError(`Agent continuation ${name} is invalid.`);
+  }
+  return structuredClone(value);
+}
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireOnlyKeys(value, allowed) {
+  const allowedKeys = new Set(allowed);
+  const unknown = Object.keys(value).find((key) => !allowedKeys.has(key));
+  if (unknown !== void 0) {
+    throw new TypeError(`Agent continuation state contains unknown key "${unknown}".`);
+  }
+}
+function jsonEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((value, index) => jsonEqual(value, right[index]));
+  }
+  if (object(left)) {
+    if (!object(right)) return false;
+    const keys = Object.keys(left);
+    return keys.length === Object.keys(right).length && keys.every((key) => key in right && jsonEqual(left[key], right[key]));
+  }
+  return false;
+}
+
+export {
+  serializeContinuationState,
+  parseContinuationState,
+  questionResult
+};
+//# sourceMappingURL=chunk-5I2NVRHC.js.map

package/dist/chunk-5I2NVRHC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/agent-runtime/continuation-state.ts"],"sourcesContent":["import type { AgentInteractionRequest, AgentQuestionAnswer } from \"../../agent/interactions\";\nimport { parseAgentQuestionPrompts } from \"../../agent/interactions\";\nimport {\n  isJsonValue,\n  type JsonObject,\n  type JsonValue,\n  type Message,\n  parseMessages,\n  type ToolCallPart,\n  type ToolResultPart,\n} from \"../../completion\";\nimport type { MemoryScope } from \"../../memory\";\nimport type { PendingToolExecution } from \"./interaction-suspension\";\n\nexport type QueuedSteering = {\n  id: string;\n  messages: Message[];\n};\n\nexport type AgentContinuationState = {\n  kind: \"anvia.agent-continuation\";\n  history: Message[];\n  messages: Message[];\n  pending: PendingToolExecution;\n  remainingToolCalls: ToolCallPart[];\n  steering: QueuedSteering[];\n  memoryScope?: MemoryScope;\n};\n\nexport function serializeContinuationState(state: AgentContinuationState): JsonObject {\n  const value = structuredClone(state) as unknown;\n  if (!isJsonValue(value) || Array.isArray(value) || value === null) {\n    throw new TypeError(\"Agent continuation state must be strict JSON.\");\n  }\n  return value as JsonObject;\n}\n\nexport function parseContinuationState(\n  value: JsonObject,\n  interaction: AgentInteractionRequest,\n): AgentContinuationState {\n  requireOnlyKeys(value, [\n    \"kind\",\n    \"history\",\n    \"messages\",\n    \"pending\",\n    \"remainingToolCalls\",\n    \"steering\",\n    \"memoryScope\",\n  ]);\n  if (value.kind !== \"anvia.agent-continuation\") {\n    throw new TypeError(\"Agent continuation has an unsupported internal state.\");\n  }\n  const history = parseMessages(value.history);\n  const messages = parseMessages(value.messages);\n  const pending = parsePending(value.pending);\n  const remainingToolCalls = parseToolCalls(value.remainingToolCalls);\n  const steering = parseSteering(value.steering);\n  if (\n    pending.toolCall.toolCallId !== interaction.toolCallId ||\n    pending.toolCall.toolName !== interaction.toolName ||\n    pending.toolCall.callId !== interaction.callId ||\n    pending.internalCallId !== interaction.internalCallId\n  ) {\n    throw new TypeError(\"Agent continuation interaction does not match its pending tool call.\");\n  }\n  if (interaction.type === \"tool-approval\" && !jsonEqual(interaction.input, pending.input)) {\n    throw new TypeError(\"Agent continuation approval input does not match its pending tool input.\");\n  }\n  if (interaction.type === \"tool-question\") {\n    const questions =\n      object(pending.input) && \"questions\" in pending.input\n        ? parseAgentQuestionPrompts(pending.input.questions)\n        : undefined;\n    if (questions === undefined || !jsonEqual(interaction.questions, questions)) {\n      throw new TypeError(\n        \"Agent continuation questions do not match its pending question tool input.\",\n      );\n    }\n  }\n  const state: AgentContinuationState = {\n    kind: \"anvia.agent-continuation\",\n    history,\n    messages,\n    pending,\n    remainingToolCalls,\n    steering,\n  };\n  if (value.memoryScope !== undefined) {\n    state.memoryScope = parseOptionalJsonObject(value.memoryScope, \"memoryScope\") as MemoryScope;\n  }\n  return state;\n}\n\nexport function questionResult(\n  answers: readonly AgentQuestionAnswer[],\n): Extract<ToolResultPart[\"output\"], { type: \"json\" }> {\n  return { type: \"json\", value: { answers: structuredClone([...answers]) } };\n}\n\nfunction parsePending(value: unknown): PendingToolExecution {\n  if (!object(value)) throw new TypeError(\"Agent continuation pending state is invalid.\");\n  const [toolCall] = parseToolCalls([value.toolCall]);\n  if (toolCall === undefined) throw new TypeError(\"Agent continuation pending tool is missing.\");\n  if (typeof value.effectiveArgs !== \"string\" || typeof value.internalCallId !== \"string\") {\n    throw new TypeError(\"Agent continuation pending execution metadata is invalid.\");\n  }\n  const pending: PendingToolExecution = {\n    toolCall,\n    effectiveArgs: value.effectiveArgs,\n    input: parseJsonValue(value.input, \"pending input\"),\n    internalCallId: value.internalCallId,\n  };\n  if (typeof value.rejectMessage === \"string\") {\n    pending.rejectMessage = value.rejectMessage;\n  }\n  return pending;\n}\n\nfunction parseJsonValue(value: unknown, name: string): JsonValue {\n  if (!isJsonValue(value)) {\n    throw new TypeError(`Agent continuation ${name} is invalid.`);\n  }\n  return structuredClone(value);\n}\n\nfunction parseToolCalls(value: unknown): ToolCallPart[] {\n  if (!Array.isArray(value)) throw new TypeError(\"Agent continuation tool calls must be an array.\");\n  const message = parseMessages([{ role: \"assistant\", content: value }])[0];\n  if (message?.role !== \"assistant\" || typeof message.content === \"string\") {\n    throw new TypeError(\"Agent continuation tool calls are invalid.\");\n  }\n  if (!message.content.every((part) => part.type === \"tool-call\")) {\n    throw new TypeError(\"Agent continuation contains a non-tool-call part.\");\n  }\n  return message.content as ToolCallPart[];\n}\n\nfunction parseSteering(value: unknown): QueuedSteering[] {\n  if (!Array.isArray(value)) throw new TypeError(\"Agent continuation steering state is invalid.\");\n  return value.map((item) => {\n    if (!object(item) || typeof item.id !== \"string\") {\n      throw new TypeError(\"Agent continuation steering entry is invalid.\");\n    }\n    return { id: item.id, messages: parseMessages(item.messages) };\n  });\n}\n\nfunction parseOptionalJsonObject(value: unknown, name: string): JsonObject | undefined {\n  if (value === undefined) return undefined;\n  if (!object(value) || !isJsonValue(value)) {\n    throw new TypeError(`Agent continuation ${name} is invalid.`);\n  }\n  return structuredClone(value);\n}\n\nfunction object(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction requireOnlyKeys(value: JsonObject, allowed: readonly string[]): void {\n  const allowedKeys = new Set(allowed);\n  const unknown = Object.keys(value).find((key) => !allowedKeys.has(key));\n  if (unknown !== undefined) {\n    throw new TypeError(`Agent continuation state contains unknown key \"${unknown}\".`);\n  }\n}\n\nfunction jsonEqual(left: unknown, right: unknown): boolean {\n  if (Object.is(left, right)) return true;\n  if (Array.isArray(left)) {\n    return (\n      Array.isArray(right) &&\n      left.length === right.length &&\n      left.every((value, index) => jsonEqual(value, right[index]))\n    );\n  }\n  if (object(left)) {\n    if (!object(right)) return false;\n    const keys = Object.keys(left);\n    return (\n      keys.length === Object.keys(right).length &&\n      keys.every((key) => key in right && jsonEqual(left[key], right[key]))\n    );\n  }\n  return false;\n}\n"],"mappings":";;;;;;;;;;;AA6BO,SAAS,2BAA2B,OAA2C;AACpF,QAAM,QAAQ,gBAAgB,KAAK;AACnC,MAAI,CAAC,YAAY,KAAK,KAAK,MAAM,QAAQ,KAAK,KAAK,UAAU,MAAM;AACjE,UAAM,IAAI,UAAU,+CAA+C;AAAA,EACrE;AACA,SAAO;AACT;AAEO,SAAS,uBACd,OACA,aACwB;AACxB,kBAAgB,OAAO;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,MAAI,MAAM,SAAS,4BAA4B;AAC7C,UAAM,IAAI,UAAU,uDAAuD;AAAA,EAC7E;AACA,QAAM,UAAU,cAAc,MAAM,OAAO;AAC3C,QAAM,WAAW,cAAc,MAAM,QAAQ;AAC7C,QAAM,UAAU,aAAa,MAAM,OAAO;AAC1C,QAAM,qBAAqB,eAAe,MAAM,kBAAkB;AAClE,QAAM,WAAW,cAAc,MAAM,QAAQ;AAC7C,MACE,QAAQ,SAAS,eAAe,YAAY,cAC5C,QAAQ,SAAS,aAAa,YAAY,YAC1C,QAAQ,SAAS,WAAW,YAAY,UACxC,QAAQ,mBAAmB,YAAY,gBACvC;AACA,UAAM,IAAI,UAAU,sEAAsE;AAAA,EAC5F;AACA,MAAI,YAAY,SAAS,mBAAmB,CAAC,UAAU,YAAY,OAAO,QAAQ,KAAK,GAAG;AACxF,UAAM,IAAI,UAAU,0EAA0E;AAAA,EAChG;AACA,MAAI,YAAY,SAAS,iBAAiB;AACxC,UAAM,YACJ,OAAO,QAAQ,KAAK,KAAK,eAAe,QAAQ,QAC5C,0BAA0B,QAAQ,MAAM,SAAS,IACjD;AACN,QAAI,cAAc,UAAa,CAAC,UAAU,YAAY,WAAW,SAAS,GAAG;AAC3E,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,QAAM,QAAgC;AAAA,IACpC,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,MAAI,MAAM,gBAAgB,QAAW;AACnC,UAAM,cAAc,wBAAwB,MAAM,aAAa,aAAa;AAAA,EAC9E;AACA,SAAO;AACT;AAEO,SAAS,eACd,SACqD;AACrD,SAAO,EAAE,MAAM,QAAQ,OAAO,EAAE,SAAS,gBAAgB,CAAC,GAAG,OAAO,CAAC,EAAE,EAAE;AAC3E;AAEA,SAAS,aAAa,OAAsC;AAC1D,MAAI,CAAC,OAAO,KAAK,EAAG,OAAM,IAAI,UAAU,8CAA8C;AACtF,QAAM,CAAC,QAAQ,IAAI,eAAe,CAAC,MAAM,QAAQ,CAAC;AAClD,MAAI,aAAa,OAAW,OAAM,IAAI,UAAU,6CAA6C;AAC7F,MAAI,OAAO,MAAM,kBAAkB,YAAY,OAAO,MAAM,mBAAmB,UAAU;AACvF,UAAM,IAAI,UAAU,2DAA2D;AAAA,EACjF;AACA,QAAM,UAAgC;AAAA,IACpC;AAAA,IACA,eAAe,MAAM;AAAA,IACrB,OAAO,eAAe,MAAM,OAAO,eAAe;AAAA,IAClD,gBAAgB,MAAM;AAAA,EACxB;AACA,MAAI,OAAO,MAAM,kBAAkB,UAAU;AAC3C,YAAQ,gBAAgB,MAAM;AAAA,EAChC;AACA,SAAO;AACT;AAEA,SAAS,eAAe,OAAgB,MAAyB;AAC/D,MAAI,CAAC,YAAY,KAAK,GAAG;AACvB,UAAM,IAAI,UAAU,sBAAsB,IAAI,cAAc;AAAA,EAC9D;AACA,SAAO,gBAAgB,KAAK;AAC9B;AAEA,SAAS,eAAe,OAAgC;AACtD,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,OAAM,IAAI,UAAU,iDAAiD;AAChG,QAAM,UAAU,cAAc,CAAC,EAAE,MAAM,aAAa,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC;AACxE,MAAI,SAAS,SAAS,eAAe,OAAO,QAAQ,YAAY,UAAU;AACxE,UAAM,IAAI,UAAU,4CAA4C;AAAA,EAClE;AACA,MAAI,CAAC,QAAQ,QAAQ,MAAM,CAAC,SAAS,KAAK,SAAS,WAAW,GAAG;AAC/D,UAAM,IAAI,UAAU,mDAAmD;AAAA,EACzE;AACA,SAAO,QAAQ;AACjB;AAEA,SAAS,cAAc,OAAkC;AACvD,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,OAAM,IAAI,UAAU,+CAA+C;AAC9F,SAAO,MAAM,IAAI,CAAC,SAAS;AACzB,QAAI,CAAC,OAAO,IAAI,KAAK,OAAO,KAAK,OAAO,UAAU;AAChD,YAAM,IAAI,UAAU,+CAA+C;AAAA,IACrE;AACA,WAAO,EAAE,IAAI,KAAK,IAAI,UAAU,cAAc,KAAK,QAAQ,EAAE;AAAA,EAC/D,CAAC;AACH;AAEA,SAAS,wBAAwB,OAAgB,MAAsC;AACrF,MAAI,UAAU,OAAW,QAAO;AAChC,MAAI,CAAC,OAAO,KAAK,KAAK,CAAC,YAAY,KAAK,GAAG;AACzC,UAAM,IAAI,UAAU,sBAAsB,IAAI,cAAc;AAAA,EAC9D;AACA,SAAO,gBAAgB,KAAK;AAC9B;AAEA,SAAS,OAAO,OAAkD;AAChE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,gBAAgB,OAAmB,SAAkC;AAC5E,QAAM,cAAc,IAAI,IAAI,OAAO;AACnC,QAAM,UAAU,OAAO,KAAK,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,YAAY,IAAI,GAAG,CAAC;AACtE,MAAI,YAAY,QAAW;AACzB,UAAM,IAAI,UAAU,kDAAkD,OAAO,IAAI;AAAA,EACnF;AACF;AAEA,SAAS,UAAU,MAAe,OAAyB;AACzD,MAAI,OAAO,GAAG,MAAM,KAAK,EAAG,QAAO;AACnC,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,WACE,MAAM,QAAQ,KAAK,KACnB,KAAK,WAAW,MAAM,UACtB,KAAK,MAAM,CAAC,OAAO,UAAU,UAAU,OAAO,MAAM,KAAK,CAAC,CAAC;AAAA,EAE/D;AACA,MAAI,OAAO,IAAI,GAAG;AAChB,QAAI,CAAC,OAAO,KAAK,EAAG,QAAO;AAC3B,UAAM,OAAO,OAAO,KAAK,IAAI;AAC7B,WACE,KAAK,WAAW,OAAO,KAAK,KAAK,EAAE,UACnC,KAAK,MAAM,CAAC,QAAQ,OAAO,SAAS,UAAU,KAAK,GAAG,GAAG,MAAM,GAAG,CAAC,CAAC;AAAA,EAExE;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-5IURMWFN.js

@@ -0,0 +1,53 @@
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+
+// src/internal/agent-runtime/interaction-suspension.ts
+var AgentInteractionSignal = class extends Error {
+  constructor(interaction, rejectMessage) {
+    super("Agent execution requires a human interaction.");
+    this.interaction = interaction;
+    this.rejectMessage = rejectMessage;
+    this.name = "AgentInteractionSignal";
+  }
+  interaction;
+  rejectMessage;
+};
+var ToolExecutionSuspension = class extends Error {
+  constructor(interaction, pending) {
+    super("Tool execution suspended for human interaction.");
+    this.interaction = interaction;
+    this.pending = pending;
+    this.name = "ToolExecutionSuspension";
+  }
+  interaction;
+  pending;
+  completedResults = [];
+  remainingToolCalls = [];
+};
+function approvalInteraction(request) {
+  if (request.toolCallId === void 0) {
+    throw new TypeError("Tool approval requires a canonical toolCallId.");
+  }
+  if (!isJsonValue(request.args)) {
+    throw new TypeError("Tool approval input must be strict JSON.");
+  }
+  let interaction = {
+    type: "tool-approval",
+    id: request.id,
+    toolName: request.toolName,
+    toolCallId: request.toolCallId,
+    internalCallId: request.internalCallId,
+    input: request.args
+  };
+  if (request.callId !== void 0) interaction = { ...interaction, callId: request.callId };
+  if (request.reason !== void 0) interaction = { ...interaction, reason: request.reason };
+  return interaction;
+}
+
+export {
+  AgentInteractionSignal,
+  ToolExecutionSuspension,
+  approvalInteraction
+};
+//# sourceMappingURL=chunk-5IURMWFN.js.map

package/dist/chunk-5IURMWFN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/agent-runtime/interaction-suspension.ts"],"sourcesContent":["import type { AgentInteractionRequest, AgentToolApprovalRequest } from \"../../agent/interactions\";\nimport {\n  isJsonValue,\n  type JsonValue,\n  type ToolCallPart,\n  type ToolResultPart,\n} from \"../../completion\";\n\nexport type PendingToolExecution = {\n  toolCall: ToolCallPart;\n  effectiveArgs: string;\n  input: JsonValue;\n  internalCallId: string;\n  rejectMessage?: string;\n};\n\nexport class AgentInteractionSignal extends Error {\n  constructor(\n    readonly interaction: AgentInteractionRequest,\n    readonly rejectMessage?: string,\n  ) {\n    super(\"Agent execution requires a human interaction.\");\n    this.name = \"AgentInteractionSignal\";\n  }\n}\n\nexport class ToolExecutionSuspension extends Error {\n  completedResults: ToolResultPart[] = [];\n  remainingToolCalls: ToolCallPart[] = [];\n\n  constructor(\n    readonly interaction: AgentInteractionRequest,\n    readonly pending: PendingToolExecution,\n  ) {\n    super(\"Tool execution suspended for human interaction.\");\n    this.name = \"ToolExecutionSuspension\";\n  }\n}\n\nexport function approvalInteraction(request: {\n  id: string;\n  toolName: string;\n  toolCallId?: string;\n  callId?: string;\n  internalCallId: string;\n  args: unknown;\n  reason?: string | undefined;\n  rejectMessage?: string | undefined;\n}): AgentToolApprovalRequest {\n  if (request.toolCallId === undefined) {\n    throw new TypeError(\"Tool approval requires a canonical toolCallId.\");\n  }\n  if (!isJsonValue(request.args)) {\n    throw new TypeError(\"Tool approval input must be strict JSON.\");\n  }\n  let interaction: AgentToolApprovalRequest = {\n    type: \"tool-approval\",\n    id: request.id,\n    toolName: request.toolName,\n    toolCallId: request.toolCallId,\n    internalCallId: request.internalCallId,\n    input: request.args,\n  };\n  if (request.callId !== undefined) interaction = { ...interaction, callId: request.callId };\n  if (request.reason !== undefined) interaction = { ...interaction, reason: request.reason };\n  return interaction;\n}\n"],"mappings":";;;;;AAgBO,IAAM,yBAAN,cAAqC,MAAM;AAAA,EAChD,YACW,aACA,eACT;AACA,UAAM,+CAA+C;AAH5C;AACA;AAGT,SAAK,OAAO;AAAA,EACd;AAAA,EALW;AAAA,EACA;AAKb;AAEO,IAAM,0BAAN,cAAsC,MAAM;AAAA,EAIjD,YACW,aACA,SACT;AACA,UAAM,iDAAiD;AAH9C;AACA;AAGT,SAAK,OAAO;AAAA,EACd;AAAA,EALW;AAAA,EACA;AAAA,EALX,mBAAqC,CAAC;AAAA,EACtC,qBAAqC,CAAC;AASxC;AAEO,SAAS,oBAAoB,SASP;AAC3B,MAAI,QAAQ,eAAe,QAAW;AACpC,UAAM,IAAI,UAAU,gDAAgD;AAAA,EACtE;AACA,MAAI,CAAC,YAAY,QAAQ,IAAI,GAAG;AAC9B,UAAM,IAAI,UAAU,0CAA0C;AAAA,EAChE;AACA,MAAI,cAAwC;AAAA,IAC1C,MAAM;AAAA,IACN,IAAI,QAAQ;AAAA,IACZ,UAAU,QAAQ;AAAA,IAClB,YAAY,QAAQ;AAAA,IACpB,gBAAgB,QAAQ;AAAA,IACxB,OAAO,QAAQ;AAAA,EACjB;AACA,MAAI,QAAQ,WAAW,OAAW,eAAc,EAAE,GAAG,aAAa,QAAQ,QAAQ,OAAO;AACzF,MAAI,QAAQ,WAAW,OAAW,eAAc,EAAE,GAAG,aAAa,QAAQ,QAAQ,OAAO;AACzF,SAAO;AACT;","names":[]}

package/dist/chunk-5M6GTA3T.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-5M6GTA3T.js.map

package/dist/chunk-5M6GTA3T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-5N5W7CX7.js

@@ -0,0 +1,18 @@
+// src/model-listing/errors.ts
+var ModelListingError = class extends Error {
+  provider;
+  statusCode;
+  cause;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "ModelListingError";
+    this.provider = options.provider;
+    this.statusCode = options.statusCode;
+    this.cause = options.cause;
+  }
+};
+
+export {
+  ModelListingError
+};
+//# sourceMappingURL=chunk-5N5W7CX7.js.map

package/dist/chunk-5N5W7CX7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/model-listing/errors.ts"],"sourcesContent":["type ModelListingErrorOptions = {\n  provider?: string | undefined;\n  statusCode?: number | undefined;\n  cause?: unknown;\n};\n\nexport class ModelListingError extends Error {\n  readonly provider?: string | undefined;\n  readonly statusCode?: number | undefined;\n  override readonly cause?: unknown;\n\n  constructor(message: string, options: ModelListingErrorOptions = {}) {\n    super(message, { cause: options.cause });\n    this.name = \"ModelListingError\";\n    this.provider = options.provider;\n    this.statusCode = options.statusCode;\n    this.cause = options.cause;\n  }\n}\n"],"mappings":";AAMO,IAAM,oBAAN,cAAgC,MAAM;AAAA,EAClC;AAAA,EACA;AAAA,EACS;AAAA,EAElB,YAAY,SAAiB,UAAoC,CAAC,GAAG;AACnE,UAAM,SAAS,EAAE,OAAO,QAAQ,MAAM,CAAC;AACvC,SAAK,OAAO;AACZ,SAAK,WAAW,QAAQ;AACxB,SAAK,aAAa,QAAQ;AAC1B,SAAK,QAAQ,QAAQ;AAAA,EACvB;AACF;","names":[]}

package/dist/chunk-5P2YOQSA.js

@@ -0,0 +1,355 @@
+import {
+  runEvalSuite
+} from "./chunk-JOQ2T3QP.js";
+
+// src/evals/cli.ts
+var EvalAssertionError = class extends Error {
+  mismatches;
+  constructor(message, mismatches) {
+    super(`${message}
+${mismatches.map((mismatch) => `- ${mismatch}`).join("\n")}`);
+    this.name = "EvalAssertionError";
+    this.mismatches = mismatches;
+  }
+};
+function defineEvalExpectations(_suite, expectations) {
+  return expectations;
+}
+function formatEvalResult(result, options = {}) {
+  const format = options.format ?? "pretty";
+  if (format === "quiet") return "";
+  validatePrintOptions(options);
+  return format === "json" ? jsonResult(result, options) : prettyResult(result, options);
+}
+function printEvalResult(result, options = {}) {
+  const format = options.format ?? "pretty";
+  if (format === "quiet") return;
+  const write = options.output?.stdout ?? ((text) => process.stdout.write(text));
+  write(`${formatEvalResult(result, options)}
+`);
+}
+function evalExitCode(result, expectations) {
+  const hasExpectations = expectations?.totals !== void 0 || expectations?.outcomes !== void 0;
+  const mismatches = hasExpectations ? expectationMismatches(result, expectations) : [];
+  if (hasExpectations && mismatches.length === 0) return 0;
+  if (hasExpectations && hasUnexpectedInvalid(result, expectations)) return 2;
+  if (hasExpectations) return 1;
+  if (requiredMetricCount(result, "invalid") > 0) return 2;
+  return requiredMetricCount(result, "fail") > 0 ? 1 : 0;
+}
+function assertEvalTotals(result, expected) {
+  const mismatches = totalMismatches(result, expected);
+  if (mismatches.length > 0) {
+    throw new EvalAssertionError("Evaluation totals did not match expectations.", mismatches);
+  }
+}
+function assertEvalOutcomes(result, expected) {
+  const mismatches = outcomeMismatches(result, expected);
+  if (mismatches.length > 0) {
+    throw new EvalAssertionError("Evaluation outcomes did not match expectations.", mismatches);
+  }
+}
+async function runEvalCli(options) {
+  const { format, exitCode, expectations, output, maxValueLength, redact: redact2, ...suiteOptions } = options;
+  const result = await runEvalSuite(
+    suiteOptions
+  );
+  printEvalResult(result, { format, output, maxValueLength, redact: redact2 });
+  const code = evalExitCode(result, expectations);
+  const mismatches = expectationMismatches(result, expectations);
+  if (mismatches.length > 0 && format !== "quiet") {
+    const write = output?.stderr ?? ((text) => process.stderr.write(text));
+    write(
+      `Evaluation expectation mismatches:
+${mismatches.map((value) => `- ${value}`).join("\n")}
+`
+    );
+  }
+  const currentExitCode = typeof process.exitCode === "number" ? process.exitCode : Number(process.exitCode ?? 0);
+  if (exitCode === true && code > currentExitCode) process.exitCode = code;
+  return result;
+}
+function prettyResult(result, options) {
+  const lines = [
+    `${result.name} (${result.run.id})`,
+    `Cases: ${totalsText(result.cases)}`,
+    `Metrics: ${totalsText(result.metrics)}`
+  ];
+  for (const caseResult of result.results) {
+    lines.push(``, `[${caseResult.outcome.toUpperCase()}] ${caseResult.case.id}`);
+    if (caseResult.targetStatus === "succeeded") {
+      lines.push(
+        `  output: ${displayValue(
+          redact(caseResult.output, options, { kind: "output", caseId: caseResult.case.id }),
+          options.maxValueLength
+        )}`
+      );
+    }
+    if (caseResult.targetStatus === "failed") {
+      lines.push(
+        `  target error: ${errorText(
+          redact(caseResult.targetError, options, { kind: "error", caseId: caseResult.case.id }),
+          options.maxValueLength
+        )}`
+      );
+    }
+    for (const metric of caseResult.metrics) {
+      const parts = [`  - ${metric.metricName}: ${metric.outcome.outcome}`];
+      if (metric.outcome.score !== void 0) {
+        parts.push(
+          `score=${displayValue(
+            redact(metric.outcome.score, options, {
+              kind: "score",
+              caseId: caseResult.case.id,
+              metricName: metric.metricName
+            }),
+            options.maxValueLength
+          )}`
+        );
+      }
+      if (metric.threshold !== void 0) parts.push(`threshold=${metric.threshold}`);
+      if (metric.direction !== void 0) parts.push(`direction=${metric.direction}`);
+      if (!metric.required) parts.push("optional");
+      lines.push(parts.join(" | "));
+      const explanation = metric.outcome.comment ?? (metric.outcome.outcome === "invalid" ? metric.outcome.reason : void 0);
+      if (explanation !== void 0) {
+        lines.push(
+          `    ${displayValue(
+            redact(explanation, options, {
+              kind: "comment",
+              caseId: caseResult.case.id,
+              metricName: metric.metricName
+            }),
+            options.maxValueLength
+          )}`
+        );
+      }
+    }
+  }
+  lines.push(
+    ``,
+    `Usage: target=${result.usage.target.totalTokens} evaluation=${result.usage.evaluation.totalTokens} total=${result.usage.total.totalTokens} tokens`
+  );
+  if (result.cost !== void 0) {
+    lines.push(
+      `Cost: target=${result.cost.target} evaluation=${result.cost.evaluation} total=${result.cost.total} ${result.cost.currency}`
+    );
+  }
+  lines.push(`Duration: ${result.durationMs}ms`);
+  return lines.join("\n");
+}
+function jsonResult(result, options) {
+  return JSON.stringify(
+    redactJsonResult(result, options),
+    (_key, value) => {
+      if (value instanceof Error) {
+        return { name: value.name, message: value.message, stack: value.stack };
+      }
+      if (value instanceof RegExp) return String(value);
+      if (typeof value === "string") return truncate(value, options.maxValueLength);
+      return value;
+    },
+    2
+  );
+}
+function expectationMismatches(result, expectations) {
+  if (expectations === void 0) return [];
+  const mismatches = [];
+  if (expectations.totals !== void 0) {
+    mismatches.push(...totalMismatches(result, expectations.totals));
+  }
+  if (expectations.outcomes !== void 0) {
+    mismatches.push(...outcomeMismatches(result, expectations.outcomes));
+  }
+  return mismatches;
+}
+function totalMismatches(result, expected) {
+  const directMetrics = {};
+  if (expected.total !== void 0) directMetrics.total = expected.total;
+  if (expected.passed !== void 0) directMetrics.passed = expected.passed;
+  if (expected.failed !== void 0) directMetrics.failed = expected.failed;
+  if (expected.invalid !== void 0) directMetrics.invalid = expected.invalid;
+  return [
+    ...totalsGroupMismatches("metrics", result.metrics, {
+      ...directMetrics,
+      ...expected.metrics
+    }),
+    ...totalsGroupMismatches("cases", result.cases, expected.cases)
+  ];
+}
+function totalsGroupMismatches(label, actual, expected) {
+  if (expected === void 0) return [];
+  const mismatches = [];
+  for (const key of ["total", "passed", "failed", "invalid"]) {
+    if (expected[key] !== void 0 && actual[key] !== expected[key]) {
+      mismatches.push(`${label}.${key}: expected ${expected[key]}, received ${actual[key]}`);
+    }
+  }
+  return mismatches;
+}
+function outcomeMismatches(result, expected) {
+  const mismatches = [];
+  const actualCases = new Map(result.results.map((caseResult) => [caseResult.case.id, caseResult]));
+  for (const [caseId, metrics] of Object.entries(expected)) {
+    const caseResult = actualCases.get(caseId);
+    if (caseResult === void 0) {
+      mismatches.push(`${caseId}: expected case was not present`);
+      continue;
+    }
+    for (const [metricName, expectedOutcome] of Object.entries(metrics)) {
+      const metric = caseResult.metrics.find((candidate) => candidate.metricName === metricName);
+      if (metric === void 0) {
+        mismatches.push(`${caseId}.${metricName}: expected metric was not present`);
+      } else if (metric.outcome.outcome !== expectedOutcome) {
+        mismatches.push(
+          `${caseId}.${metricName}: expected ${expectedOutcome}, received ${metric.outcome.outcome}`
+        );
+      }
+    }
+  }
+  for (const caseResult of result.results) {
+    for (const metric of caseResult.metrics) {
+      if (!metric.required) continue;
+      const expectedOutcome = expected[caseResult.case.id]?.[metric.metricName] ?? "pass";
+      if (metric.outcome.outcome !== expectedOutcome) {
+        const message = `${caseResult.case.id}.${metric.metricName}: expected ${expectedOutcome}, received ${metric.outcome.outcome}`;
+        if (!mismatches.includes(message)) mismatches.push(message);
+      }
+    }
+  }
+  return mismatches;
+}
+function hasUnexpectedInvalid(result, expectations) {
+  if (expectations?.outcomes !== void 0) {
+    return result.results.some(
+      (caseResult) => caseResult.metrics.some(
+        (metric) => metric.required && metric.outcome.outcome === "invalid" && expectations.outcomes?.[caseResult.case.id]?.[metric.metricName] !== "invalid"
+      )
+    );
+  }
+  const expectedInvalid = expectations?.totals?.metrics?.invalid ?? expectations?.totals?.invalid;
+  return result.metrics.invalid > (expectedInvalid ?? 0);
+}
+function requiredMetricCount(result, status) {
+  return result.results.reduce(
+    (total, caseResult) => total + caseResult.metrics.filter((metric) => metric.required && metric.outcome.outcome === status).length,
+    0
+  );
+}
+function totalsText(totals) {
+  return `${totals.total} total / ${totals.passed} pass / ${totals.failed} fail / ${totals.invalid} invalid`;
+}
+function displayValue(value, maxValueLength) {
+  let text;
+  if (typeof value === "string") text = value;
+  else {
+    try {
+      text = JSON.stringify(value) ?? String(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  return truncate(text, maxValueLength);
+}
+function errorText(error, maxValueLength) {
+  return truncate(error instanceof Error ? error.message : displayValue(error), maxValueLength);
+}
+function truncate(value, maxValueLength) {
+  return maxValueLength !== void 0 && value.length > maxValueLength ? `${value.slice(0, maxValueLength)}\u2026` : value;
+}
+function redact(value, options, context) {
+  return options.redact === void 0 ? value : options.redact(value, context);
+}
+function redactJsonResult(result, options) {
+  return {
+    ...result,
+    run: {
+      ...result.run,
+      metadata: result.run.metadata === void 0 ? void 0 : redact(result.run.metadata, options, {
+        kind: "metadata"
+      })
+    },
+    results: result.results.map((caseResult) => ({
+      ...caseResult,
+      case: {
+        ...caseResult.case,
+        input: redact(caseResult.case.input, options, {
+          kind: "input",
+          caseId: caseResult.case.id
+        }),
+        expected: redact(caseResult.case.expected, options, {
+          kind: "expected",
+          caseId: caseResult.case.id
+        }),
+        context: redact(caseResult.case.context, options, {
+          kind: "context",
+          caseId: caseResult.case.id
+        }),
+        retrievalContext: redact(caseResult.case.retrievalContext, options, {
+          kind: "retrievalContext",
+          caseId: caseResult.case.id
+        }),
+        metadata: caseResult.case.metadata === void 0 ? void 0 : redact(caseResult.case.metadata, options, {
+          kind: "metadata",
+          caseId: caseResult.case.id
+        })
+      },
+      output: caseResult.targetStatus === "succeeded" ? redact(caseResult.output, options, { kind: "output", caseId: caseResult.case.id }) : void 0,
+      targetError: caseResult.targetStatus === "failed" ? redact(caseResult.targetError, options, {
+        kind: "error",
+        caseId: caseResult.case.id
+      }) : void 0,
+      metrics: caseResult.metrics.map((metric) => ({
+        ...metric,
+        reporterErrors: metric.reporterErrors.map(
+          (error) => redact(error, options, {
+            kind: "error",
+            caseId: caseResult.case.id,
+            metricName: metric.metricName
+          })
+        ),
+        outcome: redactOutcome(metric.outcome, options, caseResult.case.id, metric.metricName)
+      })),
+      scores: Object.fromEntries(
+        caseResult.metrics.map((metric) => [
+          metric.metricName,
+          redactOutcome(metric.outcome, options, caseResult.case.id, metric.metricName)
+        ])
+      )
+    })),
+    reporterErrors: result.reporterErrors.map((error) => redact(error, options, { kind: "error" }))
+  };
+}
+function redactOutcome(outcome, options, caseId, metricName) {
+  return {
+    ...outcome,
+    ...outcome.score === void 0 ? {} : { score: redact(outcome.score, options, { kind: "score", caseId, metricName }) },
+    ...outcome.comment === void 0 ? {} : { comment: redact(outcome.comment, options, { kind: "comment", caseId, metricName }) },
+    ...!("reason" in outcome) || outcome.reason === void 0 ? {} : { reason: redact(outcome.reason, options, { kind: "comment", caseId, metricName }) },
+    ...outcome.metadata === void 0 ? {} : {
+      metadata: redact(outcome.metadata, options, {
+        kind: "metadata",
+        caseId,
+        metricName
+      })
+    },
+    ...!("error" in outcome) || outcome.error === void 0 ? {} : { error: redact(outcome.error, options, { kind: "error", caseId, metricName }) }
+  };
+}
+function validatePrintOptions(options) {
+  if (options.maxValueLength !== void 0 && (!Number.isSafeInteger(options.maxValueLength) || options.maxValueLength < 1)) {
+    throw new RangeError("Evaluation maxValueLength must be a positive integer.");
+  }
+}
+
+export {
+  EvalAssertionError,
+  defineEvalExpectations,
+  formatEvalResult,
+  printEvalResult,
+  evalExitCode,
+  assertEvalTotals,
+  assertEvalOutcomes,
+  runEvalCli
+};
+//# sourceMappingURL=chunk-5P2YOQSA.js.map