@liy/agent-runner 0.3.1 → 0.3.2

package/dist/debug/pi-rpc-trace.d.ts

@@ -0,0 +1,54 @@
+/**
+ * One bounded Pi RPC trace record written to a task-local debug JSONL file.
+ *
+ * @public
+ */
+export interface PiRpcTraceEvent {
+    /**
+     * Stable trace event name, such as `prompt.sent` or `stdout.event`.
+     */
+    kind: string;
+    /**
+     * Direction or process stream that produced the event.
+     */
+    stream?: "stdin" | "stdout" | "stderr" | "process";
+    /**
+     * Redacted trace payload. Large payloads are replaced with a preview before
+     * they are written.
+     */
+    payload?: unknown;
+}
+/**
+ * Append-only task-local Pi RPC trace writer.
+ *
+ * @public
+ */
+export interface PiRpcTrace {
+    /**
+     * Absolute path to the trace file when it was opened successfully.
+     */
+    filePath?: string;
+    /**
+     * Append one redacted trace record.
+     *
+     * @param event - Trace event to serialize as one JSONL record.
+     */
+    write(event: PiRpcTraceEvent): void;
+    /**
+     * Flush and close the trace file.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create a Pi RPC trace writer under the task workspace debug directory.
+ *
+ * @param input - Task identity and workspace location.
+ * @returns Writable trace, or a no-op trace when the debug file cannot open.
+ *
+ * @public
+ */
+export declare function createPiRpcTrace(input: {
+    taskId: string;
+    workspaceDir: string;
+    now?: () => Date;
+}): PiRpcTrace;

package/dist/index.js

@@ -15079,7 +15079,7 @@ var QuerySchema = external_exports.object({
   limit: external_exports.number().int().positive().max(1e4).default(1e3),
   accessLevel: AccessLevelSchema.default("serving")
 }).superRefine((query, ctx) => {
-  const surfaces = [query.from.surface, ...query.joins.map((join2) => join2.surface)];
+  const surfaces = [query.from.surface, ...query.joins.map((join3) => join3.surface)];
   const knownSurfaces = /* @__PURE__ */ new Set();
   for (const [index, surface] of surfaces.entries()) {
     if (knownSurfaces.has(surface)) {
@@ -15114,8 +15114,8 @@ var QuerySchema = external_exports.object({
       path: ["time", "bucket", "fn"]
     });
   }
-  for (const [index, join2] of query.joins.entries()) {
-    visitConditionFields(join2.on, (field) => {
+  for (const [index, join3] of query.joins.entries()) {
+    visitConditionFields(join3.on, (field) => {
       validateFieldRef(field, ["joins", index, "on"]);
     });
   }
@@ -15632,6 +15632,92 @@ async function forwardHarnessLines(stream, handler) {
 
 // src/harness-drivers/pi-rpc.ts
 import { spawn as nodeSpawn2 } from "node:child_process";
+
+// src/debug/pi-rpc-trace.ts
+import { once } from "node:events";
+import { createWriteStream, mkdirSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+var MAX_TRACE_LINE_BYTES = 16384;
+var MAX_TRACE_PREVIEW_CHARS = 8e3;
+function createPiRpcTrace(input) {
+  const filePath = join2(input.workspaceDir, "debug", "pi-rpc.jsonl");
+  try {
+    mkdirSync(dirname2(filePath), { recursive: true });
+    const stream = createWriteStream(filePath, {
+      flags: "a",
+      mode: 384
+    });
+    return createStreamTrace({
+      filePath,
+      stream,
+      taskId: input.taskId,
+      now: input.now ?? (() => /* @__PURE__ */ new Date())
+    });
+  } catch {
+    return createNoopTrace();
+  }
+}
+function createStreamTrace(input) {
+  let closed = false;
+  let failed = false;
+  input.stream.on("error", () => {
+    failed = true;
+  });
+  return {
+    filePath: input.filePath,
+    write(event) {
+      if (closed || failed) {
+        return;
+      }
+      input.stream.write(serializeTraceRecord({
+        ts: input.now().toISOString(),
+        taskId: input.taskId,
+        ...event
+      }));
+    },
+    async close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (failed) {
+        return;
+      }
+      input.stream.end();
+      await once(input.stream, "finish").then(() => void 0, () => void 0);
+    }
+  };
+}
+function createNoopTrace() {
+  return {
+    write() {
+    },
+    async close() {
+    }
+  };
+}
+function serializeTraceRecord(record2) {
+  const line = `${JSON.stringify(record2)}
+`;
+  if (Buffer.byteLength(line, "utf8") <= MAX_TRACE_LINE_BYTES) {
+    return line;
+  }
+  return `${JSON.stringify({
+    ...record2,
+    truncated: true,
+    payload: previewPayload(record2.payload)
+  })}
+`;
+}
+function previewPayload(payload) {
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload) ?? "undefined";
+  if (text.length <= MAX_TRACE_PREVIEW_CHARS) {
+    return text;
+  }
+  return `${text.slice(0, MAX_TRACE_PREVIEW_CHARS)}...[truncated]`;
+}
+
+// src/harness-drivers/pi-rpc.ts
 var driverOwnedPiFlags = /* @__PURE__ */ new Set([
   "--mode",
   "--provider",
@@ -15689,7 +15775,8 @@ function buildPiRpcArgs(harness) {
 }
 function startPiRpcHarness(input, spawnProcess) {
   const harness = input.harness;
-  const child = spawnProcess(harness.command, buildPiRpcArgs(harness), {
+  const args = buildPiRpcArgs(harness);
+  const child = spawnProcess(harness.command, args, {
     cwd: input.spec.workspaceDir,
     env: input.env,
     stdio: ["pipe", "pipe", "pipe"]
@@ -15697,6 +15784,19 @@ function startPiRpcHarness(input, spawnProcess) {
   const sanitizer = createHarnessOutputSanitizer(input.env, [
     ...input.harness.secretEnv ?? []
   ]);
+  const trace = createPiRpcTrace({
+    taskId: input.spec.taskId,
+    workspaceDir: input.spec.workspaceDir
+  });
+  trace.write({
+    kind: "process.started",
+    stream: "process",
+    payload: {
+      command: harness.command,
+      args,
+      cwd: input.spec.workspaceDir
+    }
+  });
   let cleanupTermination = () => void 0;
   let agentEndReached = false;
   let resolveAgentEnd = () => void 0;
@@ -15713,6 +15813,7 @@ function startPiRpcHarness(input, spawnProcess) {
       input,
       line,
       sanitizer,
+      trace,
       onAgentEnd() {
         agentEndReached = true;
         resolveAgentEnd("agent-end");
@@ -15723,20 +15824,36 @@ function startPiRpcHarness(input, spawnProcess) {
     });
   });
   const stderrDone = forwardJsonlByteStream(child.stderr, (line) => {
-    forwardPiStderrLine(input, line, sanitizer);
+    forwardPiStderrLine(input, line, sanitizer, trace);
   });
-  writePiRpcCommand(child, {
+  const promptCommand = {
     id: `mote-${input.spec.taskId}`,
     type: "prompt",
     message: input.prompt
+  };
+  writePiRpcCommand(child, promptCommand);
+  trace.write({
+    kind: "prompt.sent",
+    stream: "stdin",
+    payload: {
+      id: promptCommand.id,
+      type: promptCommand.type,
+      messageLength: input.prompt.length
+    }
   });
   const result = (async () => {
     let terminal;
     try {
       terminal = await Promise.race([closePromise, agentEndPromise]);
     } catch (error48) {
+      trace.write({
+        kind: "process.error",
+        stream: "process",
+        payload: formatTraceError(error48)
+      });
       cleanupTermination();
       cleanupTermination = terminateChildProcess(child);
+      await trace.close();
       throw error48;
     }
     if (terminal === "agent-end") {
@@ -15745,6 +15862,12 @@ function startPiRpcHarness(input, spawnProcess) {
       const closeResult = await closePromise;
       cleanupTermination();
       await Promise.all([stdoutDone, stderrDone]);
+      trace.write({
+        kind: "process.closed",
+        stream: "process",
+        payload: closeResult
+      });
+      await trace.close();
       return {
         exitCode: closeResult.exitCode,
         signal: closeResult.signal,
@@ -15753,6 +15876,12 @@ function startPiRpcHarness(input, spawnProcess) {
     }
     cleanupTermination();
     await Promise.all([stdoutDone, stderrDone]);
+    trace.write({
+      kind: "process.closed",
+      stream: "process",
+      payload: terminal
+    });
+    await trace.close();
     if (!agentEndReached && terminal.exitCode !== 0) {
       forwardPiHarnessStreamLine(
         input,
@@ -15780,20 +15909,44 @@ function handlePiRpcStdoutLine(input) {
   try {
     parsed = JSON.parse(trimmed);
   } catch {
-    forwardPiHarnessStreamLine(input.input, "stdout", input.sanitizer.redactText(trimmed));
+    const message = input.sanitizer.redactText(trimmed);
+    input.trace.write({
+      kind: "stdout.text",
+      stream: "stdout",
+      payload: {
+        message
+      }
+    });
+    forwardPiHarnessStreamLine(input.input, "stdout", message);
     return;
   }
+  const redacted = input.sanitizer.redactJson(parsed);
   if (isPiRpcResponse(parsed)) {
+    input.trace.write({
+      kind: "stdout.response",
+      stream: "stdout",
+      payload: redacted
+    });
     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));
+    input.trace.write({
+      kind: "stdout.extension_ui_request",
+      stream: "stdout",
+      payload: redacted
+    });
+    forwardPiExtensionUiRequest(input.input, redacted);
     return;
   }
-  forwardPiEvent(input.input, input.sanitizer.redactJson(parsed));
+  input.trace.write({
+    kind: "stdout.event",
+    stream: "stdout",
+    payload: redacted
+  });
+  forwardPiEvent(input.input, redacted);
   if (parsed.type === "agent_end") {
     input.onAgentEnd();
   }
@@ -15828,8 +15981,16 @@ function forwardPiHarnessStreamLine(input, stream, message) {
     message: trimmed
   }));
 }
-function forwardPiStderrLine(input, line, sanitizer) {
-  forwardPiHarnessStreamLine(input, "stderr", sanitizer.redactText(line));
+function forwardPiStderrLine(input, line, sanitizer, trace) {
+  const message = sanitizer.redactText(line);
+  trace.write({
+    kind: "stderr.line",
+    stream: "stderr",
+    payload: {
+      message
+    }
+  });
+  forwardPiHarnessStreamLine(input, "stderr", message);
 }
 function writePiRpcCommand(child, command) {
   child.stdin.write(`${JSON.stringify(command)}
@@ -15868,6 +16029,17 @@ function formatPiRpcError(parsed, redactText) {
   }
   return "unknown error";
 }
+function formatTraceError(error48) {
+  if (error48 instanceof Error) {
+    return {
+      name: error48.name,
+      message: error48.message
+    };
+  }
+  return {
+    message: String(error48)
+  };
+}
 
 // src/prompt.ts
 import { existsSync, readFileSync } from "node:fs";