@liy/agent-runner 0.1.0 → 0.2.1

package/dist/harness-drivers/pi-rpc.d.ts

@@ -1,5 +1,115 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { ResolvedAgentRunnerHarnessConfig } from "../config.js";
 import type { HarnessSpawn, TaskAgentHarnessDriver } from "./types.js";
+/**
+ * Pi extension runtime error event emitted by RPC mode.
+ *
+ * @remarks
+ * Pi 0.74.0 emits this record from RPC mode but does not include it in the
+ * exported `AgentSessionEvent` union. Keep it structural so downstream Mote UI
+ * code can still switch on the upstream `extension_error` spelling.
+ *
+ * @public
+ */
+export interface PiExtensionErrorEvent {
+    /**
+     * Upstream Pi event discriminator.
+     */
+    type: "extension_error";
+    /**
+     * Extension file path that raised the error.
+     */
+    extensionPath: string;
+    /**
+     * Extension event name being handled when the error occurred.
+     */
+    event: string;
+    /**
+     * Human-readable extension error text.
+     */
+    error: string;
+}
+/**
+ * Native Pi event forwarded by the Pi RPC harness driver.
+ *
+ * @public
+ */
+export type PiEvent = AgentSessionEvent | PiExtensionErrorEvent;
+/**
+ * Native Pi assistant-message stream event.
+ *
+ * @public
+ */
+export type PiAssistantMessageEvent = Extract<PiEvent, {
+    type: "message_update";
+}>["assistantMessageEvent"];
+/**
+ * Structural copy of Pi RPC extension UI requests.
+ *
+ * @remarks
+ * The Pi package exports this type from an internal path in 0.74.0 but not from
+ * its public package root. Mote forwards the request opaquely and does not
+ * implement response handling in this pass.
+ *
+ * @public
+ */
+export type PiExtensionUiRequest = {
+    type: "extension_ui_request";
+    id: string;
+    method: "select";
+    title: string;
+    options: string[];
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "confirm";
+    title: string;
+    message: string;
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "input";
+    title: string;
+    placeholder?: string;
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "editor";
+    title: string;
+    prefill?: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "notify";
+    message: string;
+    notifyType?: "info" | "warning" | "error";
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setStatus";
+    statusKey: string;
+    statusText: string | undefined;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setWidget";
+    widgetKey: string;
+    widgetLines: string[] | undefined;
+    widgetPlacement?: "aboveEditor" | "belowEditor";
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setTitle";
+    title: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "set_editor_text";
+    text: string;
+};
 /**
  * Create the Pi RPC driver adapter.
  *

package/dist/harness-drivers/shared.d.ts

@@ -63,15 +63,16 @@ export declare class JsonlByteBufferParser {
  */
 export declare function forwardJsonlByteStream(stream: Readable, onLine: (line: string) => void): Promise<void>;
 /**
- * Forward one generic harness output line as JSON progress or text log.
+ * Forward one generic harness output line as redacted subprocess stream text.
  *
  * @param channel - Connected control channel.
+ * @param taskId - Runtime task id for control-channel correlation.
+ * @param harness - Harness driver id that produced the line.
  * @param line - Raw harness output line.
  * @param streamName - Source stream name.
  * @param sanitizer - Output sanitizer.
- * @param driver - Optional driver id to include in forwarded payloads.
  */
-export declare function forwardHarnessLine(channel: ControlChannel, line: string, streamName: "stdout" | "stderr", sanitizer: HarnessOutputSanitizer, driver?: string): void;
+export declare function forwardHarnessLine(channel: ControlChannel, taskId: string, harness: string, line: string, streamName: "stdout" | "stderr", sanitizer: HarnessOutputSanitizer): void;
 /**
  * Wait for one child process to close.
  *

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./config.js";
 export * from "./runtime.js";
 export * from "./runner.js";
+export type { PiAssistantMessageEvent, PiEvent, PiExtensionErrorEvent, PiExtensionUiRequest, } from "./harness-drivers/pi-rpc.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire as ___liy_agent_runnerCreateRequire } from "node:module";var require = ___liy_agent_runnerCreateRequire(import.meta.url);
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15511,25 +15512,17 @@ function forwardJsonlByteStream(stream, onLine) {
     });
   });
 }
-function forwardHarnessLine(channel, line, streamName, sanitizer, driver) {
+function forwardHarnessLine(channel, taskId, harness, line, streamName, sanitizer) {
   const trimmed = sanitizer.redactText(line.trim());
   if (!trimmed) {
     return;
   }
-  try {
-    const parsed = JSON.parse(trimmed);
-    channel.send(createExecuteTaskRpcNotification("task.progress", {
-      ...driver ? { driver } : {},
-      stream: streamName,
-      event: sanitizer.redactJson(parsed)
-    }));
-  } catch {
-    channel.send(createExecuteTaskRpcNotification("task.log", {
-      ...driver ? { driver } : {},
-      stream: streamName,
-      message: trimmed
-    }));
-  }
+  channel.send(createExecuteTaskRpcNotification(`harness.${streamName}`, {
+    taskId,
+    harness,
+    stream: streamName,
+    message: trimmed
+  }));
 }
 function waitForChildClose(child) {
   return new Promise((resolve, reject) => {
@@ -15609,10 +15602,10 @@ function startCodexJsonlHarness(input, spawnProcess) {
   let cleanupTermination = () => void 0;
   child.stdin.end(input.prompt);
   const stdoutDone = forwardHarnessLines(child.stdout, (line) => {
-    forwardHarnessLine(input.channel, line, "stdout", sanitizer);
+    forwardHarnessLine(input.channel, input.spec.taskId, "codex-jsonl", line, "stdout", sanitizer);
   });
   const stderrDone = forwardHarnessLines(child.stderr, (line) => {
-    forwardHarnessLine(input.channel, line, "stderr", sanitizer);
+    forwardHarnessLine(input.channel, input.spec.taskId, "codex-jsonl", line, "stderr", sanitizer);
   });
   const result = waitForChildClose(child).then(async (closeResult) => {
     cleanupTermination();
@@ -15689,6 +15682,7 @@ function buildPiRpcArgs(harness) {
     model,
     "--thinking",
     thinking,
+    "--no-session",
     "--no-extensions",
     "--no-prompt-templates",
     "--no-themes",
@@ -15762,11 +15756,11 @@ function startPiRpcHarness(input, spawnProcess) {
     cleanupTermination();
     await Promise.all([stdoutDone, stderrDone]);
     if (!agentEndReached && terminal.exitCode !== 0) {
-      input.channel.send(createExecuteTaskRpcNotification("task.log", {
-        driver: "pi-rpc",
-        stream: "stderr",
-        message: `pi-rpc process closed before agent_end with ${formatHarnessExit(terminal)}`
-      }));
+      forwardPiHarnessStreamLine(
+        input,
+        "stderr",
+        `pi-rpc process closed before agent_end with ${formatHarnessExit(terminal)}`
+      );
     }
     return terminal;
   })();
@@ -15788,37 +15782,57 @@ function handlePiRpcStdoutLine(input) {
   try {
     parsed = JSON.parse(trimmed);
   } catch {
-    input.input.channel.send(createExecuteTaskRpcNotification("task.log", {
-      driver: "pi-rpc",
-      stream: "stdout",
-      message: input.sanitizer.redactText(trimmed)
-    }));
+    forwardPiHarnessStreamLine(input.input, "stdout", input.sanitizer.redactText(trimmed));
     return;
   }
-  input.input.channel.send(createExecuteTaskRpcNotification("task.progress", {
-    driver: "pi-rpc",
-    stream: "stdout",
-    event: input.sanitizer.redactJson(parsed)
-  }));
-  if (parsed.type === "response" && parsed.command === "prompt" && parsed.success === false) {
-    input.onPromptRejected(new Error(`Pi RPC prompt was rejected: ${formatPiRpcError(parsed, input.sanitizer.redactText)}`));
+  if (isPiRpcResponse(parsed)) {
+    if (parsed.command === "prompt" && parsed.success === false) {
+      input.onPromptRejected(new Error(`Pi RPC prompt was rejected: ${formatPiRpcError(parsed, input.sanitizer.redactText)}`));
+    }
+    return;
+  }
+  if (isPiExtensionUiRequest(parsed)) {
+    forwardPiExtensionUiRequest(input.input, input.sanitizer.redactJson(parsed));
     return;
   }
+  forwardPiEvent(input.input, input.sanitizer.redactJson(parsed));
   if (parsed.type === "agent_end") {
     input.onAgentEnd();
   }
 }
-function forwardPiStderrLine(input, line, sanitizer) {
-  const trimmed = sanitizer.redactText(line.trim());
+function forwardPiEvent(input, event) {
+  input.channel.send(createExecuteTaskRpcNotification("pi.event", {
+    taskId: input.spec.taskId,
+    event
+  }));
+}
+function forwardPiExtensionUiRequest(input, request) {
+  input.channel.send(createExecuteTaskRpcNotification("pi.extension_ui_request", {
+    taskId: input.spec.taskId,
+    request
+  }));
+}
+function isPiRpcResponse(parsed) {
+  return parsed.type === "response" && typeof parsed.command === "string";
+}
+function isPiExtensionUiRequest(parsed) {
+  return parsed.type === "extension_ui_request" && typeof parsed.id === "string";
+}
+function forwardPiHarnessStreamLine(input, stream, message) {
+  const trimmed = message.trim();
   if (!trimmed) {
     return;
   }
-  input.channel.send(createExecuteTaskRpcNotification("task.log", {
-    driver: "pi-rpc",
-    stream: "stderr",
+  input.channel.send(createExecuteTaskRpcNotification(`harness.${stream}`, {
+    taskId: input.spec.taskId,
+    harness: "pi-rpc",
+    stream,
     message: trimmed
   }));
 }
+function forwardPiStderrLine(input, line, sanitizer) {
+  forwardPiHarnessStreamLine(input, "stderr", sanitizer.redactText(line));
+}
 function writePiRpcCommand(child, command) {
   child.stdin.write(`${JSON.stringify(command)}
 `);
@@ -15876,30 +15890,41 @@ async function runTaskAgentRunner(spec, options = {}) {
     const harness = resolveAgentRunnerHarness(config2, spec.agentRunner);
     const channel = await openControlChannel(spec.rpcUrl);
     try {
-      channel.send(createExecuteTaskRpcNotification("task.started", {
+      sendTaskStatus(channel, {
         taskId: spec.taskId,
-        workspaceDir: spec.workspaceDir
-      }));
+        status: "running"
+      });
       const completion = await runHarnessAndReadCompletion({
         spec,
         harness,
         channel,
+        ...spec.timeouts?.taskMs !== void 0 ? { timeoutMs: spec.timeouts.taskMs } : {},
         ...options.env ? { env: options.env } : {}
       });
-      channel.send(createExecuteTaskRpcNotification(`task.${completion.status}`, {
+      sendTaskStatus(channel, {
         taskId: spec.taskId,
         ...completion
-      }));
+      });
       return completion;
+    } catch (error48) {
+      const completion = createFailedCompletion(error48);
+      await writeTaskCompletion({
+        paths,
+        completion
+      }).catch(() => void 0);
+      try {
+        sendTaskStatus(channel, {
+          taskId: spec.taskId,
+          ...completion
+        });
+      } catch {
+      }
+      throw error48;
     } finally {
       channel.close();
     }
   } catch (error48) {
-    const completion = {
-      status: "failed",
-      summary: error48 instanceof Error ? error48.message : String(error48),
-      artifactIds: []
-    };
+    const completion = createFailedCompletion(error48);
     await writeTaskCompletion({
       paths,
       completion
@@ -15907,6 +15932,16 @@ async function runTaskAgentRunner(spec, options = {}) {
     throw error48;
   }
 }
+function sendTaskStatus(channel, params) {
+  channel.send(createExecuteTaskRpcNotification("task.status", params));
+}
+function createFailedCompletion(error48) {
+  return {
+    status: "failed",
+    summary: error48 instanceof Error ? error48.message : String(error48),
+    artifactIds: []
+  };
+}
 function createHarnessEnvironment(input) {
   const baseEnv = input.env ?? process.env;
   const harnessEnv = {};
@@ -16001,7 +16036,28 @@ async function runHarnessAndReadCompletion(input) {
       ...input.env ? { env: input.env } : {}
     })
   });
-  const result = await activeRun.result;
+  const result = await waitForHarnessResult({
+    run: activeRun,
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+  });
+  if (result === "timeout") {
+    activeRun.cancel();
+    await waitForHarnessCleanup(activeRun.result);
+    const recovered = await readTaskCompletion(paths).catch(() => void 0);
+    if (recovered) {
+      await validateTaskArtifactFiles({
+        paths,
+        completion: recovered
+      });
+      return recovered;
+    }
+    const completion2 = createTimeoutCompletion(input.timeoutMs);
+    await writeTaskCompletion({
+      paths,
+      completion: completion2
+    });
+    return completion2;
+  }
   if (cancelRequested) {
     const completion2 = {
       status: "cancelled",
@@ -16014,7 +16070,14 @@ async function runHarnessAndReadCompletion(input) {
     });
     return completion2;
   }
-  const completion = await readTaskCompletion(paths);
+  const completion = await readTaskCompletion(paths).catch(async (error48) => {
+    const fallback = createMissingCompletionFailure(error48);
+    await writeTaskCompletion({
+      paths,
+      completion: fallback
+    });
+    return fallback;
+  });
   await validateTaskArtifactFiles({
     paths,
     completion
@@ -16024,6 +16087,46 @@ async function runHarnessAndReadCompletion(input) {
   }
   return completion;
 }
+async function waitForHarnessResult(input) {
+  const timeoutMs = normalizeTimeoutMs(input.timeoutMs);
+  if (timeoutMs === void 0) {
+    return input.run.result;
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      input.run.result,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function waitForHarnessCleanup(result) {
+  await Promise.race([
+    result.catch(() => void 0),
+    sleep(1e4)
+  ]);
+}
+function createTimeoutCompletion(timeoutMs) {
+  return {
+    status: "failed",
+    summary: timeoutMs === void 0 ? "execute_task harness timed out" : `execute_task harness timed out after ${timeoutMs}ms`,
+    artifactIds: []
+  };
+}
+function createMissingCompletionFailure(error48) {
+  const detail = error48 instanceof Error ? error48.message : String(error48);
+  return {
+    status: "failed",
+    summary: `harness ended without writing state/completion.json: ${detail}`,
+    artifactIds: []
+  };
+}
 function validateRunnerSpec(spec) {
   if ("harness" in spec) {
     throw new Error("task spec harness is no longer supported; use task spec agentRunner");
@@ -16037,6 +16140,9 @@ function validateRunnerSpec(spec) {
   if (!spec.rpcUrl?.trim()) {
     throw new Error("task spec rpcUrl is required");
   }
+  if (spec.timeouts?.taskMs !== void 0 && normalizeTimeoutMs(spec.timeouts.taskMs) === void 0) {
+    throw new Error("task spec timeouts.taskMs must be a positive finite number");
+  }
   if (spec.agentRunner?.harness !== void 0 && typeof spec.agentRunner.harness !== "string") {
     throw new Error("task spec agentRunner.harness must be a string");
   }
@@ -16049,6 +16155,14 @@ function validateRunnerSpec(spec) {
   }
   assertNoForbiddenSpecKeys(spec);
 }
+function normalizeTimeoutMs(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 async function openControlChannel(url2) {
   const WebSocketCtor = globalThis.WebSocket;
   if (!WebSocketCtor) {