@anvia/core 1.5.0 → 1.6.0

package/dist/{chunk-LJGQ6VQB.js → chunk-TD2VYYUT.js}

@@ -3,7 +3,11 @@ import {
 } from "./chunk-2NLINXRF.js";
 import {
   createTool
-} from "./chunk-Y365ABZY.js";
+} from "./chunk-4WSICA6D.js";
+import {
+  abortError,
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
 
 // src/skills/tools.ts
 import { spawn } from "child_process";
@@ -12,6 +16,8 @@ import { isAbsolute, relative, resolve } from "path";
 import { z } from "zod";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var MAX_OUTPUT_CHARS = 2e4;
+var TERMINATION_GRACE_MS = 250;
+var TERMINATION_WATCHDOG_MS = 1250;
 function createSkillTools(skills) {
   const registry = new SkillRegistry(skills);
   return [
@@ -61,7 +67,7 @@ function createSkillTools(skills) {
           timeoutMs: z.number().int().positive().optional().describe("Execution timeout in ms.")
         }),
         outputSchema: z.string(),
-        execute: ({ skillName, scriptPath, args = [], timeoutMs = DEFAULT_TIMEOUT_MS }) => registry.runScript(skillName, scriptPath, args, timeoutMs)
+        execute: ({ skillName, scriptPath, args = [], timeoutMs = DEFAULT_TIMEOUT_MS }, context) => registry.runScript(skillName, scriptPath, args, timeoutMs, context.abortSignal)
       })
     )
   ];
@@ -96,13 +102,13 @@ var SkillRegistry = class {
     }
     return readFile(path, "utf8");
   }
-  async runScript(skillName, scriptPath, args, timeoutMs) {
+  async runScript(skillName, scriptPath, args, timeoutMs, abortSignal) {
     const skill = this.get(skillName);
     const script = this.resolveContainedPath(skill, "scripts", scriptPath);
     if (!skill.scripts.includes(scriptPath)) {
       throw new Error(`Skill script not found: ${skillName}/${scriptPath}`);
     }
-    return runExecutable(script, args, skill.directory, timeoutMs);
+    return runExecutable(script, args, skill.directory, timeoutMs, abortSignal);
   }
   resolveContainedPath(skill, section, requestedPath) {
     if (requestedPath.length === 0 || isAbsolute(requestedPath)) {
@@ -117,8 +123,9 @@ var SkillRegistry = class {
     return resolved;
   }
 };
-function runExecutable(command, args, cwd, timeoutMs) {
+function runExecutable(command, args, cwd, timeoutMs, abortSignal) {
   return new Promise((resolvePromise, reject) => {
+    throwIfAborted(abortSignal);
     const child = spawn(command, args, {
       cwd,
       shell: false,
@@ -126,40 +133,92 @@ function runExecutable(command, args, cwd, timeoutMs) {
     });
     let stdout = "";
     let stderr = "";
-    let timedOut = false;
+    let exited = false;
+    let settled = false;
+    let firstCause;
+    let escalation;
+    let watchdog;
     const timeout = setTimeout(() => {
-      timedOut = true;
-      child.kill();
+      beginTermination(new Error(`Skill script timed out after ${timeoutMs}ms`));
     }, timeoutMs);
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout = appendLimited(stdout, chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr = appendLimited(stderr, chunk);
-    });
-    child.on("error", (error) => {
+    function settle(error, output = "") {
+      if (settled) return;
+      settled = true;
       clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code, signal) => {
+      clearTimeout(escalation);
+      clearTimeout(watchdog);
+      abortSignal?.removeEventListener("abort", onAbort);
+      child.removeListener("error", onError);
+      child.removeListener("exit", onExit);
+      child.removeListener("close", onClose);
+      child.stdout.removeListener("data", onStdout);
+      child.stderr.removeListener("data", onStderr);
+      if (error !== void 0) reject(error);
+      else resolvePromise(output);
+    }
+    function finishTermination() {
+      child.stdout.destroy();
+      child.stderr.destroy();
+      settle(firstCause);
+    }
+    function beginTermination(cause) {
+      if (settled || firstCause !== void 0) return;
+      firstCause = cause;
       clearTimeout(timeout);
-      if (timedOut) {
-        reject(new Error(`Skill script timed out after ${timeoutMs}ms`));
+      if (exited) {
+        finishTermination();
         return;
       }
-      const output = formatProcessOutput(stdout, stderr);
-      if (code !== 0) {
-        reject(new Error(`Skill script exited with code ${code ?? "unknown"}: ${output}`));
+      escalation = setTimeout(() => {
+        if (!exited) child.kill("SIGKILL");
+      }, TERMINATION_GRACE_MS);
+      watchdog = setTimeout(() => {
+        child.stdout.destroy();
+        child.stderr.destroy();
+        settle(new Error("Skill script termination could not be confirmed", { cause: firstCause }));
+      }, TERMINATION_WATCHDOG_MS);
+      child.kill("SIGTERM");
+    }
+    function onAbort() {
+      beginTermination(abortError(abortSignal?.reason));
+    }
+    function onError(error) {
+      if (child.pid === void 0) settle(error);
+      else beginTermination(error);
+    }
+    function onExit() {
+      exited = true;
+      if (firstCause !== void 0) finishTermination();
+    }
+    function onClose(code, signal) {
+      if (firstCause !== void 0) {
+        if (exited) finishTermination();
         return;
       }
-      if (signal !== null) {
-        reject(new Error(`Skill script exited with signal ${signal}: ${output}`));
-        return;
+      const output = formatProcessOutput(stdout, stderr);
+      if (code !== 0) {
+        settle(new Error(`Skill script exited with code ${code ?? "unknown"}: ${output}`));
+      } else if (signal !== null) {
+        settle(new Error(`Skill script exited with signal ${signal}: ${output}`));
+      } else {
+        settle(void 0, output);
       }
-      resolvePromise(output);
-    });
+    }
+    function onStdout(chunk) {
+      stdout = appendLimited(stdout, chunk);
+    }
+    function onStderr(chunk) {
+      stderr = appendLimited(stderr, chunk);
+    }
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", onStdout);
+    child.stderr.on("data", onStderr);
+    child.on("error", onError);
+    child.on("exit", onExit);
+    child.on("close", onClose);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    if (abortSignal?.aborted === true) onAbort();
   });
 }
 function formatProcessOutput(stdout, stderr) {
@@ -186,4 +245,4 @@ function appendLimited(current, chunk) {
 export {
   createSkillTools
 };
-//# sourceMappingURL=chunk-LJGQ6VQB.js.map
+//# sourceMappingURL=chunk-TD2VYYUT.js.map

package/dist/chunk-TD2VYYUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/skills/tools.ts"],"sourcesContent":["import { spawn } from \"node:child_process\";\nimport { readFile } from \"node:fs/promises\";\nimport { isAbsolute, relative, resolve } from \"node:path\";\nimport { z } from \"zod\";\nimport { abortError, throwIfAborted } from \"../internal/abort\";\nimport { type AnyTool, createTool } from \"../tool\";\nimport { markSkillTool } from \"../tool/skill-tool-marker\";\nimport type { Skill } from \"./types\";\n\nconst DEFAULT_TIMEOUT_MS = 30_000;\nconst MAX_OUTPUT_CHARS = 20_000;\nconst TERMINATION_GRACE_MS = 250;\nconst TERMINATION_WATCHDOG_MS = 1_250;\n\nexport function createSkillTools(skills: Skill[]): AnyTool[] {\n  const registry = new SkillRegistry(skills);\n\n  return [\n    markSkillTool(\n      createTool({\n        name: \"get_skill_instructions\",\n        description: \"Load the full SKILL.md instructions for an Agent Skill.\",\n        inputSchema: z.object({\n          skillName: z.string().describe(\"The name of the skill to load.\"),\n        }),\n        outputSchema: z.string(),\n        execute: ({ skillName }) => registry.get(skillName).instructions,\n      }),\n    ),\n    markSkillTool(\n      createTool({\n        name: \"get_skill_reference\",\n        description: \"Read a reference file from an Agent Skill.\",\n        inputSchema: z.object({\n          skillName: z.string().describe(\"The name of the skill.\"),\n          referencePath: z.string().describe(\"A path listed in the skill references.\"),\n        }),\n        outputSchema: z.string(),\n        execute: ({ skillName, referencePath }) => registry.readReference(skillName, referencePath),\n      }),\n    ),\n    markSkillTool(\n      createTool({\n        name: \"get_skill_script\",\n        description: \"Read a script file from an Agent Skill.\",\n        inputSchema: z.object({\n          skillName: z.string().describe(\"The name of the skill.\"),\n          scriptPath: z.string().describe(\"A path listed in the skill scripts.\"),\n        }),\n        outputSchema: z.string(),\n        execute: ({ skillName, scriptPath }) => registry.readScript(skillName, scriptPath),\n      }),\n    ),\n    markSkillTool(\n      createTool({\n        name: \"run_skill_script\",\n        description: \"Execute a script from an Agent Skill with optional arguments.\",\n        inputSchema: z.object({\n          skillName: z.string().describe(\"The name of the skill.\"),\n          scriptPath: z.string().describe(\"A path listed in the skill scripts.\"),\n          args: z.array(z.string()).optional().describe(\"Arguments passed to the script.\"),\n          timeoutMs: z.number().int().positive().optional().describe(\"Execution timeout in ms.\"),\n        }),\n        outputSchema: z.string(),\n        execute: ({ skillName, scriptPath, args = [], timeoutMs = DEFAULT_TIMEOUT_MS }, context) =>\n          registry.runScript(skillName, scriptPath, args, timeoutMs, context.abortSignal),\n      }),\n    ),\n  ];\n}\n\nclass SkillRegistry {\n  private readonly skills = new Map<string, Skill>();\n\n  constructor(skills: Skill[]) {\n    for (const skill of skills) {\n      this.skills.set(skill.name, skill);\n    }\n  }\n\n  get(skillName: string): Skill {\n    const skill = this.skills.get(skillName);\n    if (skill === undefined) {\n      throw new Error(`Skill not found: ${skillName}`);\n    }\n    return skill;\n  }\n\n  async readReference(skillName: string, referencePath: string): Promise<string> {\n    const skill = this.get(skillName);\n    const path = this.resolveContainedPath(skill, \"references\", referencePath);\n    if (!skill.references.includes(referencePath)) {\n      throw new Error(`Skill reference not found: ${skillName}/${referencePath}`);\n    }\n    return readFile(path, \"utf8\");\n  }\n\n  async readScript(skillName: string, scriptPath: string): Promise<string> {\n    const skill = this.get(skillName);\n    const path = this.resolveContainedPath(skill, \"scripts\", scriptPath);\n    if (!skill.scripts.includes(scriptPath)) {\n      throw new Error(`Skill script not found: ${skillName}/${scriptPath}`);\n    }\n    return readFile(path, \"utf8\");\n  }\n\n  async runScript(\n    skillName: string,\n    scriptPath: string,\n    args: string[],\n    timeoutMs: number,\n    abortSignal?: AbortSignal,\n  ): Promise<string> {\n    const skill = this.get(skillName);\n    const script = this.resolveContainedPath(skill, \"scripts\", scriptPath);\n    if (!skill.scripts.includes(scriptPath)) {\n      throw new Error(`Skill script not found: ${skillName}/${scriptPath}`);\n    }\n    return runExecutable(script, args, skill.directory, timeoutMs, abortSignal);\n  }\n\n  private resolveContainedPath(\n    skill: Skill,\n    section: \"references\" | \"scripts\",\n    requestedPath: string,\n  ): string {\n    if (requestedPath.length === 0 || isAbsolute(requestedPath)) {\n      throw new Error(`Invalid skill path: ${requestedPath}`);\n    }\n\n    const root = resolve(skill.directory, section);\n    const resolved = resolve(root, requestedPath);\n    const rel = relative(root, resolved);\n    if (rel === \"..\" || rel.startsWith(`..${\"/\"}`) || rel.startsWith(`..${\"\\\\\"}`)) {\n      throw new Error(`Invalid skill path: ${requestedPath}`);\n    }\n\n    return resolved;\n  }\n}\n\nfunction runExecutable(\n  command: string,\n  args: string[],\n  cwd: string,\n  timeoutMs: number,\n  abortSignal?: AbortSignal,\n): Promise<string> {\n  return new Promise((resolvePromise, reject) => {\n    throwIfAborted(abortSignal);\n    const child = spawn(command, args, {\n      cwd,\n      shell: false,\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    });\n\n    let stdout = \"\";\n    let stderr = \"\";\n    let exited = false;\n    let settled = false;\n    let firstCause: Error | undefined;\n    let escalation: ReturnType<typeof setTimeout> | undefined;\n    let watchdog: ReturnType<typeof setTimeout> | undefined;\n    const timeout = setTimeout(() => {\n      beginTermination(new Error(`Skill script timed out after ${timeoutMs}ms`));\n    }, timeoutMs);\n\n    function settle(error?: Error, output = \"\"): void {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timeout);\n      clearTimeout(escalation);\n      clearTimeout(watchdog);\n      abortSignal?.removeEventListener(\"abort\", onAbort);\n      child.removeListener(\"error\", onError);\n      child.removeListener(\"exit\", onExit);\n      child.removeListener(\"close\", onClose);\n      child.stdout.removeListener(\"data\", onStdout);\n      child.stderr.removeListener(\"data\", onStderr);\n      if (error !== undefined) reject(error);\n      else resolvePromise(output);\n    }\n\n    function finishTermination(): void {\n      // Descendants can hold inherited pipes after the direct child has exited.\n      child.stdout.destroy();\n      child.stderr.destroy();\n      settle(firstCause);\n    }\n\n    function beginTermination(cause: Error): void {\n      if (settled || firstCause !== undefined) return;\n      firstCause = cause;\n      clearTimeout(timeout);\n      if (exited) {\n        finishTermination();\n        return;\n      }\n      escalation = setTimeout(() => {\n        if (!exited) child.kill(\"SIGKILL\");\n      }, TERMINATION_GRACE_MS);\n      watchdog = setTimeout(() => {\n        child.stdout.destroy();\n        child.stderr.destroy();\n        settle(new Error(\"Skill script termination could not be confirmed\", { cause: firstCause }));\n      }, TERMINATION_WATCHDOG_MS);\n      child.kill(\"SIGTERM\");\n    }\n\n    function onAbort(): void {\n      beginTermination(abortError(abortSignal?.reason));\n    }\n\n    function onError(error: Error): void {\n      if (child.pid === undefined) settle(error);\n      else beginTermination(error);\n    }\n\n    function onExit(): void {\n      exited = true;\n      if (firstCause !== undefined) finishTermination();\n    }\n\n    function onClose(code: number | null, signal: NodeJS.Signals | null): void {\n      if (firstCause !== undefined) {\n        if (exited) finishTermination();\n        return;\n      }\n      const output = formatProcessOutput(stdout, stderr);\n      if (code !== 0) {\n        settle(new Error(`Skill script exited with code ${code ?? \"unknown\"}: ${output}`));\n      } else if (signal !== null) {\n        settle(new Error(`Skill script exited with signal ${signal}: ${output}`));\n      } else {\n        settle(undefined, output);\n      }\n    }\n\n    function onStdout(chunk: string): void {\n      stdout = appendLimited(stdout, chunk);\n    }\n\n    function onStderr(chunk: string): void {\n      stderr = appendLimited(stderr, chunk);\n    }\n\n    child.stdout.setEncoding(\"utf8\");\n    child.stderr.setEncoding(\"utf8\");\n    child.stdout.on(\"data\", onStdout);\n    child.stderr.on(\"data\", onStderr);\n    child.on(\"error\", onError);\n    child.on(\"exit\", onExit);\n    child.on(\"close\", onClose);\n    abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\n    if (abortSignal?.aborted === true) onAbort();\n  });\n}\n\nfunction formatProcessOutput(stdout: string, stderr: string): string {\n  const parts: string[] = [];\n  if (stdout.length > 0) {\n    parts.push(`stdout:\\n${stdout}`);\n  }\n  if (stderr.length > 0) {\n    parts.push(`stderr:\\n${stderr}`);\n  }\n  return parts.length === 0 ? \"\" : parts.join(\"\\n\\n\");\n}\n\nfunction appendLimited(current: string, chunk: string): string {\n  const next = current + chunk;\n  if (next.length <= MAX_OUTPUT_CHARS) {\n    return next;\n  }\n  return `${next.slice(0, MAX_OUTPUT_CHARS)}\\n[truncated]`;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MTJDYC6T.js → chunk-TOJSC4GI.js}

@@ -1,12 +1,12 @@
 import {
   Agent
-} from "./chunk-UEUSJ3UQ.js";
+} from "./chunk-MJAM7HZB.js";
 import {
   getAgentToolState
 } from "./chunk-A7BXVZXZ.js";
 import {
   markResolvedAgentOptions
-} from "./chunk-UYODZ7OE.js";
+} from "./chunk-STEAW4JD.js";
 
 // src/agent/resolved-agent.ts
 function createResolvedAgent(options) {
@@ -45,4 +45,4 @@ export {
   createResolvedAgent,
   getResolvedAgentOptions
 };
-//# sourceMappingURL=chunk-MTJDYC6T.js.map
+//# sourceMappingURL=chunk-TOJSC4GI.js.map

package/dist/{chunk-V5DWNXVH.js → chunk-W2XPREWL.js}

@@ -2,7 +2,7 @@ import {
   addUsage,
   evaluationMetadata,
   runJudge
-} from "./chunk-5SJBSCG2.js";
+} from "./chunk-YSR6KLCS.js";
 import {
   resolveActualText,
   resolveExpected
@@ -23,6 +23,9 @@ import {
 import {
   isJsonValue
 } from "./chunk-4C7AXYOM.js";
+import {
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
 
 // src/evals/advanced-metrics.ts
 import { z } from "zod";
@@ -68,6 +71,7 @@ function answerRelevancy(options) {
         instructions: "Break the answer into concise, independently assessable statements. Return every substantive statement using the schema.",
         prompt: `Answer:
 ${actual}`,
+        abortSignal: args.signal,
         retries: config.retries
       });
       const statements = statementResult.data.statements;
@@ -79,6 +83,7 @@ ${actual}`,
           schema: verdictsSchema,
           instructions: "Classify each answer statement for relevance to the user input. Use yes for relevant, no for irrelevant, and idk only when relevance is genuinely indeterminate. Preserve order and return one verdict per statement.",
           prompt: jsonPrompt({ input, statements }),
+          abortSignal: args.signal,
           retries: config.retries
         });
         verdicts = verdictResult.data.verdicts;
@@ -92,6 +97,7 @@ ${actual}`,
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "answer relevancy",
+        abortSignal: args.signal,
         score,
         evidence: { input, verdicts: serializedVerdicts }
       });
@@ -123,6 +129,7 @@ function promptAlignment(options) {
         schema: binaryVerdictsSchema,
         instructions: "Determine whether the answer follows each prompt instruction. Preserve order and return exactly one yes or no verdict per instruction.",
         prompt: jsonPrompt({ input, actual, instructions: options.promptInstructions }),
+        abortSignal: args.signal,
         retries: config.retries
       });
       const verdicts = verdictResult.data.verdicts;
@@ -133,6 +140,7 @@ function promptAlignment(options) {
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "prompt alignment",
+        abortSignal: args.signal,
         score,
         evidence: { verdicts }
       });
@@ -193,6 +201,7 @@ function jsonCorrectness(options) {
               schema: reasonSchema,
               instructions: "Briefly explain why the generated JSON does not match the expected schema. Focus on actionable syntax, field, and type problems.",
               prompt: jsonPrompt({ actual, validationError }),
+              abortSignal: args.signal,
               retries
             });
             comment = reasonResult.data.reason;
@@ -224,6 +233,7 @@ function hallucination(options) {
         schema: binaryVerdictsSchema,
         instructions: "Compare the answer with each trusted context. Use yes when the answer is factually aligned with that context and no when it contradicts it. Preserve order and return one verdict per context.",
         prompt: jsonPrompt({ actual, context }),
+        abortSignal: args.signal,
         retries: config.retries
       });
       const verdicts = verdictResult.data.verdicts;
@@ -234,6 +244,7 @@ function hallucination(options) {
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "hallucination",
+        abortSignal: args.signal,
         score,
         evidence: { verdicts }
       });
@@ -272,6 +283,7 @@ function faithfulness(options) {
           schema: factsSchema,
           instructions: truthsExtractionInstructions(truthsExtractionLimit),
           prompt: jsonPrompt({ retrievalContext }),
+          abortSignal: args.signal,
           retries: config.retries
         }),
         runJudge({
@@ -280,6 +292,7 @@ function faithfulness(options) {
           instructions: "Extract every concise factual claim made by the answer. Return claims in the facts array and omit opinions or purely stylistic text.",
           prompt: `Answer:
 ${actual}`,
+          abortSignal: args.signal,
           retries: config.retries
         })
       ]);
@@ -293,6 +306,7 @@ ${actual}`,
           schema: verdictsSchema,
           instructions: "Determine whether each answer claim is supported by the supplied truths. Use yes for supported, no for contradicted or unsupported, and idk for genuinely ambiguous support. Preserve order and return one verdict per claim.",
           prompt: jsonPrompt({ truths, claims }),
+          abortSignal: args.signal,
           retries: config.retries
         });
         verdicts = verdictResult.data.verdicts;
@@ -310,6 +324,7 @@ ${actual}`,
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "faithfulness",
+        abortSignal: args.signal,
         score,
         evidence: { verdicts: serializedVerdicts, penalizeAmbiguousClaims }
       });
@@ -335,6 +350,7 @@ function abstention(options) {
     dataType: "CATEGORICAL",
     async evaluate(args) {
       try {
+        throwIfAborted(args.signal);
         const actual = await resolveActualText(options.actual, args);
         const shouldAbstain = await resolveExpected(options.shouldAbstain, args);
         if (typeof shouldAbstain !== "boolean") {
@@ -347,12 +363,14 @@ function abstention(options) {
           );
         }
         const judgment = await runJudge({
+          abortSignal: args.signal,
           model: options.model,
           schema: abstentionJudgmentSchema,
           instructions: "Classify whether the answer abstains or gives a confident answer. For a confident answer, grounded is true only when every substantive factual claim is supported by the supplied context. For an abstention, set grounded to false. Return a concise evidence-based reason.",
           prompt: jsonPrompt({ actual, context }),
           retries
         });
+        throwIfAborted(args.signal);
         const category = abstentionCategory(
           shouldAbstain,
           judgment.data.behavior,
@@ -409,6 +427,7 @@ function summarization(options) {
         instructions: `Generate exactly ${questionCount} important yes-or-no assessment questions whose answers capture the source text's essential information.`,
         prompt: `Source text:
 ${input}`,
+        abortSignal: args.signal,
         retries: config.retries
       }) : Promise.resolve({
         data: { questions: suppliedQuestions },
@@ -421,6 +440,7 @@ ${input}`,
           instructions: truthsExtractionInstructions(truthsExtractionLimit),
           prompt: `Source text:
 ${input}`,
+          abortSignal: args.signal,
           retries: config.retries
         }),
         runJudge({
@@ -429,6 +449,7 @@ ${input}`,
           instructions: "Extract every concise factual claim made by the summary. Return claims in the facts array.",
           prompt: `Summary:
 ${actual}`,
+          abortSignal: args.signal,
           retries: config.retries
         }),
         questionPromise
@@ -444,6 +465,7 @@ ${actual}`,
         schema: answersSchema,
         instructions: "Answer each assessment question using only the supplied text. Return one yes or no answer per question in the same order.",
         prompt: jsonPrompt({ questions, text: input }),
+        abortSignal: args.signal,
         retries: config.retries
       });
       const summaryAnswerPromise = runJudge({
@@ -451,6 +473,7 @@ ${actual}`,
         schema: answersSchema,
         instructions: "Answer each assessment question using only the supplied text. Return one yes or no answer per question in the same order.",
         prompt: jsonPrompt({ questions, text: actual }),
+        abortSignal: args.signal,
         retries: config.retries
       });
       const alignmentPromise = claims.length === 0 ? Promise.resolve({ data: { verdicts: [] }, usage: Usage.empty() }) : runJudge({
@@ -458,6 +481,7 @@ ${actual}`,
         schema: verdictsSchema,
         instructions: "Determine whether each summary claim is supported by the source truths. Use yes for supported, no for contradicted, and idk for unsupported filler or ambiguity. Preserve order.",
         prompt: jsonPrompt({ truths, claims }),
+        abortSignal: args.signal,
         retries: config.retries
       });
       const [sourceAnswerResult, summaryAnswerResult, alignmentResult] = await Promise.all([
@@ -489,6 +513,7 @@ ${actual}`,
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "summarization",
+        abortSignal: args.signal,
         score,
         evidence: {
           alignmentVerdicts: serializedAlignmentVerdicts,
@@ -543,35 +568,98 @@ function gEval(options) {
   const config = metricConfig(options, options.name);
   const rubric = validateRubric(options.rubric);
   const scoreRange = rubric.length === 0 ? [0, 10] : [rubric[0]?.scoreRange[0] ?? 0, rubric.at(-1)?.scoreRange[1] ?? 10];
-  let generatedStepsPromise;
-  let generatedUsageClaimed = false;
-  async function resolveSteps() {
+  let pendingPreparation;
+  let preparedSteps;
+  function acceptSteps(result, signal) {
+    throwIfAborted(signal);
+    return { steps: [...result.steps], preparation: result };
+  }
+  async function resolveSteps(signal) {
+    throwIfAborted(signal);
     if (options.evaluationSteps !== void 0) {
-      return { steps: options.evaluationSteps, usage: Usage.empty() };
+      return { steps: [...options.evaluationSteps] };
     }
-    if (generatedStepsPromise === void 0) {
-      generatedStepsPromise = runJudge({
-        model: options.model,
-        schema: z.object({ steps: z.array(z.string()) }),
-        instructions: "Generate three or four concise evaluation steps from the criteria. Explain how the selected parameters should be judged in relation to one another.",
-        prompt: jsonPrompt({ criteria: options.criteria, parameters: options.evaluationParams }),
-        retries: config.retries
-      }).catch((error) => {
-        generatedStepsPromise = void 0;
-        throw error;
-      });
+    if (preparedSteps !== void 0) return acceptSteps(preparedSteps, signal);
+    if (pendingPreparation === void 0) {
+      const controller = new AbortController();
+      const epoch2 = {
+        controller,
+        waiters: /* @__PURE__ */ new Set(),
+        promise: Promise.resolve().then(
+          () => runJudge({
+            model: options.model,
+            schema: z.object({ steps: z.array(z.string()) }),
+            instructions: "Generate three or four concise evaluation steps from the criteria. Explain how the selected parameters should be judged in relation to one another.",
+            prompt: jsonPrompt({
+              criteria: options.criteria,
+              parameters: options.evaluationParams
+            }),
+            retries: config.retries,
+            abortSignal: controller.signal
+          })
+        ).then((result) => {
+          if (result.data.steps.length === 0) {
+            throw new Error("G-Eval generated no evaluation steps.");
+          }
+          const prepared = {
+            steps: [...result.data.steps],
+            usage: result.usage,
+            usageClaimed: false
+          };
+          if (pendingPreparation === epoch2) {
+            preparedSteps = prepared;
+            pendingPreparation = void 0;
+          }
+          return prepared;
+        }).catch((error) => {
+          if (pendingPreparation === epoch2) pendingPreparation = void 0;
+          throw error;
+        })
+      };
+      pendingPreparation = epoch2;
     }
-    const result = await generatedStepsPromise;
-    if (result.data.steps.length === 0) throw new Error("G-Eval generated no evaluation steps.");
-    const usage = generatedUsageClaimed ? Usage.empty() : result.usage;
-    generatedUsageClaimed = true;
-    return { steps: result.data.steps, usage };
+    const epoch = pendingPreparation;
+    const token = {};
+    epoch.waiters.add(token);
+    return new Promise((resolve, reject) => {
+      const release = () => {
+        if (!epoch.waiters.delete(token)) return;
+        signal.removeEventListener("abort", onAbort);
+        if (pendingPreparation === epoch && epoch.waiters.size === 0) {
+          pendingPreparation = void 0;
+          epoch.controller.abort(signal.reason);
+        }
+      };
+      const onAbort = () => {
+        release();
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      epoch.promise.then(
+        (result) => {
+          if (!epoch.waiters.has(token)) return;
+          try {
+            const accepted = acceptSteps(result, signal);
+            release();
+            resolve(accepted);
+          } catch (error) {
+            release();
+            reject(error);
+          }
+        },
+        (error) => {
+          release();
+          reject(error);
+        }
+      );
+    });
   }
   return numericMetric(config.name, config, "higher_is_better", async (args) => {
     try {
       const parameters = await resolveGEvalParameters(options, args);
-      const stepsResult = await resolveSteps();
+      const stepsResult = await resolveSteps(args.signal);
       const scoreResult = await runJudge({
+        abortSignal: args.signal,
         model: options.model,
         schema: z.object({ score: z.number(), reason: z.string() }),
         instructions: config.strictMode ? "Apply the evaluation steps and return score 1 only for complete compliance, otherwise 0. Give a concise evidence-based reason." : `Apply the evaluation steps and return an integer score from ${scoreRange[0]} through ${scoreRange[1]}, plus a concise evidence-based reason.`,
@@ -587,8 +675,11 @@ function gEval(options) {
         throw new RangeError(`G-Eval score ${rawScore} is outside the requested range.`);
       }
       const score = config.strictMode ? rawScore : (rawScore - scoreRange[0]) / (scoreRange[1] - scoreRange[0]);
-      const usage = addUsage(stepsResult.usage, scoreResult.usage);
-      return higherOutcome({
+      throwIfAborted(args.signal);
+      const preparation = stepsResult.preparation;
+      const setupUsage = preparation === void 0 || preparation.usageClaimed ? Usage.empty() : preparation.usage;
+      const usage = addUsage(setupUsage, scoreResult.usage);
+      const outcome = higherOutcome({
         score,
         threshold: config.threshold,
         strictMode: config.strictMode,
@@ -605,6 +696,8 @@ function gEval(options) {
         },
         usage
       });
+      if (preparation !== void 0) preparation.usageClaimed = true;
+      return outcome;
     } catch (error) {
       return EvalOutcome.fromError(error);
     }
@@ -629,6 +722,7 @@ function turnRelevancy(options) {
           schema: binaryVerdictSchema,
           instructions: "Judge whether the final assistant reply is relevant to the preceding conversation. Return yes for relevant and no for irrelevant, with a concise reason.",
           prompt: jsonPrompt({ turns: window }),
+          abortSignal: args.signal,
           retries: config.retries
         })
       );
@@ -642,6 +736,7 @@ function turnRelevancy(options) {
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "turn relevancy",
+        abortSignal: args.signal,
         score,
         evidence: { verdicts }
       });
@@ -677,6 +772,7 @@ function knowledgeRetention(options) {
             previousTurns: turns.slice(0, entry.index),
             userMessage: entry.turn.content
           }),
+          abortSignal: args.signal,
           retries: config.retries
         })
       );
@@ -696,6 +792,7 @@ function knowledgeRetention(options) {
           schema: z.object({ attrition: z.boolean(), reason: z.string() }),
           instructions: "Determine whether the assistant reply forgets, contradicts, or unnecessarily asks again for information already supplied by the user. Set attrition true only when knowledge was lost.",
           prompt: jsonPrompt({ knownFacts: entry.facts, assistantReply: entry.turn.content }),
+          abortSignal: args.signal,
           retries: config.retries
         })
       );
@@ -710,6 +807,7 @@ function knowledgeRetention(options) {
         includeReason: config.includeReason,
         retries: config.retries,
         metric: "knowledge retention",
+        abortSignal: args.signal,
         score,
         evidence: { verdicts }
       });
@@ -738,7 +836,16 @@ function numericMetric(name, config, direction, evaluate) {
     direction,
     threshold: config.strictMode === true ? direction === "higher_is_better" ? 1 : 0 : config.threshold,
     dataType: "NUMERIC",
-    evaluate
+    async evaluate(args) {
+      try {
+        throwIfAborted(args.signal);
+        const outcome = await evaluate(args);
+        throwIfAborted(args.signal);
+        return outcome;
+      } catch (error) {
+        return EvalOutcome.fromError(error);
+      }
+    }
   };
 }
 function metricConfig(options, defaultName) {
@@ -788,12 +895,14 @@ function lowerOutcome(args) {
   return score <= threshold ? EvalOutcome.pass(score, options) : EvalOutcome.fail(score, options);
 }
 async function maybeReason(args) {
+  throwIfAborted(args.abortSignal);
   if (!args.includeReason) return { usage: Usage.empty() };
   const result = await runJudge({
     model: args.model,
     schema: reasonSchema,
     instructions: `Write a concise final explanation for the ${args.metric} score. Ground it only in the supplied evidence and do not repeat the numeric score.`,
     prompt: jsonPrompt({ score: args.score, evidence: args.evidence }),
+    abortSignal: args.abortSignal,
     retries: args.retries
   });
   return { reason: result.data.reason, usage: result.usage };
@@ -1004,4 +1113,4 @@ export {
   turnRelevancy,
   knowledgeRetention
 };
-//# sourceMappingURL=chunk-V5DWNXVH.js.map
+//# sourceMappingURL=chunk-W2XPREWL.js.map