@abelxiaoxing/cadence 1.0.0 → 1.0.2

package/src/child-session.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import type { Model, Usage } from "@earendil-works/pi-ai";
 import {
   createAgentSession,
@@ -16,6 +17,20 @@ import {
   type SubmitClassification,
 } from "./submit-tool.ts";
 
+function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  signal.throwIfAborted();
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise
+      .then(resolve, reject)
+      .finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
 const ZERO_USAGE: Usage = {
   input: 0,
   output: 0,
@@ -52,9 +67,22 @@ export class UsageAggregator {
   }
 }
 
-function wrapScopedTools(roots: string[]) {
+function wrapScopedTools(
+  roots: string[],
+  cwd: string,
+  allowedPaths?: string[],
+) {
   const order = ["read", "grep", "find", "ls"];
-  return createScopedTools({ roots })
+  return createScopedTools({
+    roots,
+    ...(allowedPaths
+      ? {
+          allowedPaths: allowedPaths.map((relative) =>
+            path.resolve(cwd, relative),
+          ),
+        }
+      : {}),
+  })
     .sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name))
     .map((scoped) =>
       defineTool({
@@ -78,17 +106,22 @@ function wrapScopedTools(roots: string[]) {
     );
 }
 
+export type ChildFailureKind = "failed" | "cancelled" | "timed-out";
+
 export async function runChildSession(input: {
   cwd: string;
   modelRuntime: ModelRuntime;
   model: Model<string>;
   systemPrompt: string;
   requestId: string;
+  taskId?: string;
   role: string;
   phase?: string;
   output: "evidence" | "diff";
   roots: string[];
+  allowedPaths?: string[];
   timeoutMs: number;
+  signal?: AbortSignal;
 }): Promise<
   | {
       ok: true;
@@ -102,26 +135,37 @@ export async function runChildSession(input: {
   | {
       ok: false;
       error: string;
+      failureKind: ChildFailureKind;
+      transportFailure: boolean;
       disposeCount: number;
       classification: SubmitClassification;
     }
 > {
   const submit = createSubmitTool({
     requestId: input.requestId,
+    taskId: input.taskId,
     role: input.role,
     phase: input.phase ?? "red",
     output: input.output,
   });
-  const readTools = wrapScopedTools(input.roots);
+  const readTools = wrapScopedTools(input.roots, input.cwd, input.allowedPaths);
   const customTools = [...readTools, submit.tool];
   const toolNames = customTools.map((tool) => tool.name);
   let disposeCount = 0;
   const usage = new UsageAggregator();
   const abort = new AbortController();
-  const timer = setTimeout(
-    () => abort.abort(new Error("child phase timeout")),
-    input.timeoutMs,
-  );
+  const forwardCancellation = () =>
+    abort.abort(input.signal?.reason ?? new Error("child phase cancelled"));
+  if (input.signal?.aborted) forwardCancellation();
+  else
+    input.signal?.addEventListener("abort", forwardCancellation, {
+      once: true,
+    });
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    abort.abort(new Error("child phase timeout"));
+  }, input.timeoutMs);
   let session:
     | Awaited<ReturnType<typeof createAgentSession>>["session"]
     | undefined;
@@ -159,8 +203,26 @@ export async function runChildSession(input: {
       identity: submit.getIdentity(),
     };
   };
+  const transportFailed = (): boolean => {
+    const final = session?.messages
+      .filter((message) => message.role === "assistant")
+      .at(-1);
+    if (final === undefined) return true;
+    if (final.stopReason === "error") {
+      return (
+        submit.getAttempts() === 0 &&
+        !final.content.some(
+          (content) =>
+            content.type === "toolCall" &&
+            content.name === "abel_submit_result",
+        )
+      );
+    }
+    return final.stopReason === "aborted";
+  };
   try {
-    ({ session } = await createAgentSession({
+    abort.signal.throwIfAborted();
+    const creation = createAgentSession({
       cwd: input.cwd,
       modelRuntime: input.modelRuntime,
       model: input.model,
@@ -173,7 +235,16 @@ export async function runChildSession(input: {
         compaction: { enabled: false },
         retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
       }),
-    }));
+    });
+    try {
+      ({ session } = await abortable(creation, abort.signal));
+    } catch (error) {
+      void creation
+        .then(({ session: lateSession }) => lateSession.dispose())
+        .catch(() => undefined);
+      throw error;
+    }
+    abort.signal.throwIfAborted();
     unsubscribe = session.subscribe((event) => {
       if (event.type === "message_end" && event.message.role === "assistant") {
         usage.add(
@@ -185,6 +256,7 @@ export async function runChildSession(input: {
     const onAbort = () => void session?.abort();
     abort.signal.addEventListener("abort", onAbort, { once: true });
     try {
+      if (abort.signal.aborted) throw abort.signal.reason;
       await Promise.race([
         session.prompt(input.systemPrompt, { expandPromptTemplates: false }),
         new Promise<never>((_, reject) =>
@@ -202,10 +274,13 @@ export async function runChildSession(input: {
     const attempts = submit.getAttempts();
     const classification = classifySession();
     if (!result || attempts !== 1) {
+      const transportFailure = transportFailed();
       disposeOnce();
       return {
         ok: false,
         error: "child did not retain exactly one structural submission",
+        failureKind: "failed",
+        transportFailure,
         disposeCount,
         classification,
       };
@@ -223,6 +298,8 @@ export async function runChildSession(input: {
       return {
         ok: false,
         error: "final assistant message is not one structural submit",
+        failureKind: "failed",
+        transportFailure: false,
         disposeCount,
         classification,
       };
@@ -238,15 +315,26 @@ export async function runChildSession(input: {
       classification,
     };
   } catch (error) {
+    const failureKind: ChildFailureKind = timedOut
+      ? "timed-out"
+      : input.signal !== undefined &&
+          (input.signal.aborted || abort.signal.reason === input.signal.reason)
+        ? "cancelled"
+        : "failed";
+    const classification = classifySession();
+    const transportFailure = transportFailed();
     disposeOnce();
     return {
       ok: false,
       error: (error as Error).message,
+      failureKind,
+      transportFailure,
       disposeCount,
-      classification: classifySession(),
+      classification,
     };
   } finally {
     clearTimeout(timer);
+    input.signal?.removeEventListener("abort", forwardCancellation);
     unsubscribe?.();
     disposeOnce();
   }