@liy/agent-runner 0.3.2 → 0.3.3

package/dist/bin/agent-runner.js

@@ -14011,40 +14011,7 @@ var visualComposerInputSchema = external_exports.object({
   assetGraph: assetGraphSchema.optional()
 }).strict();
 
-// ../mote-core/dist/debug/log-event.js
-var defaultMoteLogRedactPaths = [
-  "attributes.auth.token",
-  "attributes.http.request.header.authorization",
-  "attributes.http.request.header.cookie",
-  "body.headers.authorization",
-  "body.headers.cookie",
-  "body.apiKey",
-  "body.context",
-  "body.password",
-  "body.token",
-  "body.error.stack"
-];
-var moteLogPolicyPresets = {
-  localDebug: {
-    bodyMode: "full",
-    redactionMode: "censor",
-    maxBodyBytes: 256 * 1024,
-    redactPaths: defaultMoteLogRedactPaths
-  },
-  production: {
-    bodyMode: "summary",
-    redactionMode: "remove",
-    maxBodyBytes: 4 * 1024,
-    redactPaths: defaultMoteLogRedactPaths
-  },
-  thirdParty: {
-    bodyMode: "drop",
-    redactionMode: "remove",
-    redactPaths: defaultMoteLogRedactPaths
-  }
-};
-
-// ../mote-core/dist/debug/planner-artifact-pool-snapshot.js
+// ../mote-core/dist/planner-artifact-pool-observability.js
 var DEFAULT_PLANNER_ARTIFACT_POOL_SNAPSHOT_MAX_BYTES = 64 * 1024;
 
 // ../mote-core/dist/contracts/data-result.js
@@ -14964,7 +14931,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((join3) => join3.surface)];
+  const surfaces = [query.from.surface, ...query.joins.map((join2) => join2.surface)];
   const knownSurfaces = /* @__PURE__ */ new Set();
   for (const [index, surface] of surfaces.entries()) {
     if (knownSurfaces.has(surface)) {
@@ -14999,8 +14966,8 @@ var QuerySchema = external_exports.object({
       path: ["time", "bucket", "fn"]
     });
   }
-  for (const [index, join3] of query.joins.entries()) {
-    visitConditionFields(join3.on, (field) => {
+  for (const [index, join2] of query.joins.entries()) {
+    visitConditionFields(join2.on, (field) => {
       validateFieldRef(field, ["joins", index, "on"]);
     });
   }
@@ -15456,92 +15423,6 @@ 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",
@@ -15599,8 +15480,7 @@ function buildPiRpcArgs(harness) {
 }
 function startPiRpcHarness(input, spawnProcess) {
   const harness = input.harness;
-  const args = buildPiRpcArgs(harness);
-  const child = spawnProcess(harness.command, args, {
+  const child = spawnProcess(harness.command, buildPiRpcArgs(harness), {
     cwd: input.spec.workspaceDir,
     env: input.env,
     stdio: ["pipe", "pipe", "pipe"]
@@ -15608,19 +15488,6 @@ 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;
@@ -15637,7 +15504,6 @@ function startPiRpcHarness(input, spawnProcess) {
       input,
       line,
       sanitizer,
-      trace,
       onAgentEnd() {
         agentEndReached = true;
         resolveAgentEnd("agent-end");
@@ -15648,36 +15514,20 @@ function startPiRpcHarness(input, spawnProcess) {
     });
   });
   const stderrDone = forwardJsonlByteStream(child.stderr, (line) => {
-    forwardPiStderrLine(input, line, sanitizer, trace);
+    forwardPiStderrLine(input, line, sanitizer);
   });
-  const promptCommand = {
+  writePiRpcCommand(child, {
     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") {
@@ -15686,12 +15536,6 @@ 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,
@@ -15700,12 +15544,6 @@ 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,
@@ -15733,44 +15571,20 @@ function handlePiRpcStdoutLine(input) {
   try {
     parsed = JSON.parse(trimmed);
   } catch {
-    const message = input.sanitizer.redactText(trimmed);
-    input.trace.write({
-      kind: "stdout.text",
-      stream: "stdout",
-      payload: {
-        message
-      }
-    });
-    forwardPiHarnessStreamLine(input.input, "stdout", message);
+    forwardPiHarnessStreamLine(input.input, "stdout", input.sanitizer.redactText(trimmed));
     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)) {
-    input.trace.write({
-      kind: "stdout.extension_ui_request",
-      stream: "stdout",
-      payload: redacted
-    });
-    forwardPiExtensionUiRequest(input.input, redacted);
+    forwardPiExtensionUiRequest(input.input, input.sanitizer.redactJson(parsed));
     return;
   }
-  input.trace.write({
-    kind: "stdout.event",
-    stream: "stdout",
-    payload: redacted
-  });
-  forwardPiEvent(input.input, redacted);
+  forwardPiEvent(input.input, input.sanitizer.redactJson(parsed));
   if (parsed.type === "agent_end") {
     input.onAgentEnd();
   }
@@ -15805,16 +15619,8 @@ function forwardPiHarnessStreamLine(input, stream, message) {
     message: trimmed
   }));
 }
-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 forwardPiStderrLine(input, line, sanitizer) {
+  forwardPiHarnessStreamLine(input, "stderr", sanitizer.redactText(line));
 }
 function writePiRpcCommand(child, command) {
   child.stdin.write(`${JSON.stringify(command)}
@@ -15853,17 +15659,6 @@ 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";
@@ -15913,14 +15708,14 @@ function renderHarnessPromptTemplate(input) {
 
 // src/runtime.ts
 import { mkdir, readFile as readFile2, stat, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname, join } 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: join2(normalized, "state"),
-    artifactsDir: join2(normalized, "artifacts")
+    stateDir: join(normalized, "state"),
+    artifactsDir: join(normalized, "artifacts")
   };
 }
 async function ensureTaskAgentWorkspace(paths) {
@@ -15930,10 +15725,10 @@ async function ensureTaskAgentWorkspace(paths) {
   ]);
 }
 async function writeTaskCompletion(input) {
-  await writeJsonFile(join2(input.paths.stateDir, "completion.json"), input.completion);
+  await writeJsonFile(join(input.paths.stateDir, "completion.json"), input.completion);
 }
 async function readTaskCompletion(paths) {
-  const raw = await readFile2(join2(paths.stateDir, "completion.json"), "utf8");
+  const raw = await readFile2(join(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");
@@ -15951,13 +15746,13 @@ async function readTaskCompletion(paths) {
 }
 async function validateTaskArtifactFiles(input) {
   for (const artifactId of input.completion.artifactIds) {
-    const artifactPath = join2(createArtifactDir(input.paths, artifactId), "artifact.json");
+    const artifactPath = join(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 = join2(createArtifactDir(input.paths, artifactId), "data.csv");
+      const dataPath = join(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`);
@@ -15972,10 +15767,10 @@ function assertTaskArtifactId(artifactId) {
 }
 function createArtifactDir(paths, artifactId) {
   assertTaskArtifactId(artifactId);
-  return join2(paths.artifactsDir, artifactId);
+  return join(paths.artifactsDir, artifactId);
 }
 async function writeJsonFile(path, value) {
-  await mkdir(dirname2(path), { recursive: true });
+  await mkdir(dirname(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}
 `);
 }