@liy/agent-runner 0.2.7 → 0.3.2

package/dist/bin/agent-runner.js

@@ -14964,7 +14964,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)) {
@@ -14999,8 +14999,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"]);
     });
   }
@@ -15456,6 +15456,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, join } from "node:path";
+var MAX_TRACE_LINE_BYTES = 16384;
+var MAX_TRACE_PREVIEW_CHARS = 8e3;
+function createPiRpcTrace(input) {
+  const filePath = join(input.workspaceDir, "debug", "pi-rpc.jsonl");
+  try {
+    mkdirSync(dirname(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",
@@ -15513,7 +15599,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"]
@@ -15521,6 +15608,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;
@@ -15537,6 +15637,7 @@ function startPiRpcHarness(input, spawnProcess) {
       input,
       line,
       sanitizer,
+      trace,
       onAgentEnd() {
         agentEndReached = true;
         resolveAgentEnd("agent-end");
@@ -15547,20 +15648,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") {
@@ -15569,6 +15686,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,
@@ -15577,6 +15700,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,
@@ -15604,20 +15733,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();
   }
@@ -15652,8 +15805,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)}
@@ -15692,6 +15853,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";
@@ -15741,14 +15913,14 @@ function renderHarnessPromptTemplate(input) {
 
 // src/runtime.ts
 import { mkdir, readFile as readFile2, stat, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname as dirname2, join as join2 } from "node:path";
 var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function createTaskAgentWorkspacePaths(workspaceDir) {
   const normalized = workspaceDir.replace(/\/+$/g, "");
   return {
     workspaceDir: normalized,
-    stateDir: join(normalized, "state"),
-    artifactsDir: join(normalized, "artifacts")
+    stateDir: join2(normalized, "state"),
+    artifactsDir: join2(normalized, "artifacts")
   };
 }
 async function ensureTaskAgentWorkspace(paths) {
@@ -15758,10 +15930,10 @@ async function ensureTaskAgentWorkspace(paths) {
   ]);
 }
 async function writeTaskCompletion(input) {
-  await writeJsonFile(join(input.paths.stateDir, "completion.json"), input.completion);
+  await writeJsonFile(join2(input.paths.stateDir, "completion.json"), input.completion);
 }
 async function readTaskCompletion(paths) {
-  const raw = await readFile2(join(paths.stateDir, "completion.json"), "utf8");
+  const raw = await readFile2(join2(paths.stateDir, "completion.json"), "utf8");
   const parsed = JSON.parse(raw);
   if (parsed.status !== "completed" && parsed.status !== "partial" && parsed.status !== "failed" && parsed.status !== "cancelled") {
     throw new Error("completion status must be completed, partial, failed, or cancelled");
@@ -15779,13 +15951,13 @@ async function readTaskCompletion(paths) {
 }
 async function validateTaskArtifactFiles(input) {
   for (const artifactId of input.completion.artifactIds) {
-    const artifactPath = join(createArtifactDir(input.paths, artifactId), "artifact.json");
+    const artifactPath = join2(createArtifactDir(input.paths, artifactId), "artifact.json");
     const artifact = taskArtifactDraftSchema.parse(JSON.parse(await readFile2(artifactPath, "utf8")));
     if (artifact.artifactId !== artifactId) {
       throw new Error(`artifact id mismatch for ${artifactId}`);
     }
     if ("dataset" in artifact) {
-      const dataPath = join(createArtifactDir(input.paths, artifactId), "data.csv");
+      const dataPath = join2(createArtifactDir(input.paths, artifactId), "data.csv");
       const dataStat = await stat(dataPath);
       if (dataStat.size <= 0) {
         throw new Error(`dataset artifact ${artifactId} data.csv must be non-empty`);
@@ -15800,10 +15972,10 @@ function assertTaskArtifactId(artifactId) {
 }
 function createArtifactDir(paths, artifactId) {
   assertTaskArtifactId(artifactId);
-  return join(paths.artifactsDir, artifactId);
+  return join2(paths.artifactsDir, artifactId);
 }
 async function writeJsonFile(path, value) {
-  await mkdir(dirname(path), { recursive: true });
+  await mkdir(dirname2(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}
 `);
 }