@itsaplan/runner 0.4.0 → 0.5.1

package/README.md

@@ -7,8 +7,8 @@ This package runs such agents on your own machine — one, or several at once.
 
 - Polls your instance for the agent's queued runs. Runs each one with a coding agent CLI.
   Reports the result.
-- Has presets for Claude Code, Codex, opencode, Antigravity CLI and GitHub Copilot CLI.
-  Each preset sets the unattended flags and the session resume.
+- Has presets for Claude Code, Codex, opencode, Antigravity CLI, GitHub Copilot CLI,
+  Pi, and Oh My Pi (`omp`). Each preset sets the unattended flags and the session resume.
 - Runs your own `command` instead, if you prefer. The command takes the task on stdin.
 - Answers the agent's chat. Sends the text and the tool calls while the CLI prints them.
 
@@ -20,8 +20,9 @@ of kind External. The key appears one time only, at creation.
 **2. Enable MCP** for the project, in Settings, MCP Server. MCP is off by default. The
 agent reads the issue and writes its result through it.
 
-**3. Give the coding agent the address of that server.** Claude Code reads `.mcp.json`
-from the folder it runs in. For the other four CLIs, see
+**3. Give the coding agent the address of that server.** Claude Code, Oh My Pi, and Pi
+(through `pi-mcp-adapter`) read `.mcp.json` from the folder they run in. For the other
+CLIs, see
 [Coding agent setup](https://github.com/croffasia/itsaplan/blob/main/docs/runner.md).
 
 ```json
@@ -70,6 +71,8 @@ flags for an unattended run, and the session resume. Every preset keeps a chat s
 | `opencode`    | opencode           |
 | `antigravity` | Antigravity CLI    |
 | `copilot`     | GitHub Copilot CLI |
+| `pi`          | Pi                 |
+| `omp`         | Oh My Pi           |
 
 Each preset needs the CLI's own MCP config.
 [Coding agent setup](https://github.com/croffasia/itsaplan/blob/main/docs/runner.md) holds
@@ -188,7 +191,7 @@ npx -y @itsaplan/runner --agent claude
 The server writes the task text. The text states what occurred, what to do, and to post
 the result as a comment on the issue. Your own `command` receives the text on **stdin**. A
 preset gives it to its CLI in the way that CLI accepts it: on stdin for `claude` and
-`codex`, as an argument for `antigravity`, `copilot` and `opencode`.
+`codex`, as an argument for `antigravity`, `copilot`, `opencode`, `pi` and `omp`.
 
 The agent reads all other data through the MCP server at `$ITSAPLAN_URL/mcp`. The agent
 sends `$ITSAPLAN_API_KEY` as a bearer token, and acts as its own user with its role.
@@ -235,7 +238,8 @@ calls with the answer. `outputFormat` tells the runner how to read the output:
 
 - `text` — all the output is the answer.
 - `claude-stream-json`, `codex-jsonl`, `opencode-json`, `antigravity-stream-json`,
-  `copilot-json` — the event stream of that CLI.
+  `copilot-json`, `pi-json` — the event stream of that CLI. `pi` and `omp` both use
+  `pi-json`.
 
 A preset sets `outputFormat` for you. Set it yourself only with your own `command`. If the
 output does not agree with the format, the runner sends the output as plain text.

package/dist/cli.js

@@ -25,11 +25,13 @@ class AnswerStream {
   sawPartialText = false;
   sawAnyText = false;
   sending = Promise.resolve();
+  usage;
   constructor(format, threadId, runId, send) {
     this.format = format;
     this.threadId = threadId;
     this.runId = runId;
     this.send = send;
+    this.usage = new UsageReader(format);
     this.messageId = `msg-${runId}`;
     this.queued.push({ type: "RUN_STARTED", threadId, runId });
   }
@@ -48,6 +50,9 @@ class AnswerStream {
   startedSession() {
     return this.sessionId;
   }
+  contextUsage() {
+    return this.usage.value();
+  }
   async flush() {
     const sending = this.sending.catch(() => {}).then(() => this.sendQueued());
     this.sending = sending.catch(() => {});
@@ -127,6 +132,7 @@ class AnswerStream {
     }
     if (!parsed || typeof parsed !== "object")
       return;
+    this.usage.readLine(parsed);
     switch (this.format) {
       case "claude-stream-json":
         this.readClaudeLine(parsed);
@@ -143,6 +149,43 @@ class AnswerStream {
       case "copilot-json":
         this.readCopilotLine(parsed);
         break;
+      case "pi-json":
+        this.readPiLine(parsed);
+        break;
+    }
+  }
+  readPiLine(message) {
+    if (message.type === "session" && message.id)
+      this.sessionId ??= message.id;
+    switch (message.type) {
+      case "message_update": {
+        const event = message.assistantMessageEvent;
+        if (event?.type === "text_delta" && event.delta) {
+          this.sawPartialText = true;
+          this.appendText(event.delta);
+        }
+        return;
+      }
+      case "tool_execution_start":
+        if (message.toolCallId && !this.openToolCalls.has(message.toolCallId)) {
+          this.openToolCalls.add(message.toolCallId);
+          this.pushToolCall(message.toolCallId, message.toolName ?? "tool", JSON.stringify(message.args ?? {}));
+        }
+        return;
+      case "tool_execution_end": {
+        if (!message.toolCallId || this.closedToolCalls.has(message.toolCallId))
+          return;
+        this.closedToolCalls.add(message.toolCallId);
+        this.pushToolResult(message.toolCallId, piResultText(message.result));
+        return;
+      }
+      case "message_end":
+        if (message.message?.role === "assistant" && !this.sawAnyText && message.message.content) {
+          const body = textOfResult(message.message.content);
+          if (body)
+            this.appendText(body);
+        }
+        return;
     }
   }
   readCopilotLine(message) {
@@ -275,7 +318,9 @@ class AnswerStream {
     }
   }
   readPartial(event) {
-    if (event?.type !== "content_block_delta")
+    if (!event)
+      return;
+    if (event.type !== "content_block_delta")
       return;
     if (event.delta?.type === "text_delta" && event.delta.text) {
       this.sawPartialText = true;
@@ -313,6 +358,120 @@ class AnswerStream {
     });
   }
 }
+
+class UsageReader {
+  format;
+  last = null;
+  buffered = "";
+  constructor(format) {
+    this.format = format;
+  }
+  write(chunk) {
+    if (this.format === "text")
+      return;
+    this.buffered += chunk;
+    const lines = this.buffered.split(`
+`);
+    this.buffered = lines.pop() ?? "";
+    for (const line of lines)
+      this.readText(line);
+  }
+  end() {
+    if (!this.buffered)
+      return;
+    this.readText(this.buffered);
+    this.buffered = "";
+  }
+  value() {
+    if (this.format === "copilot-json")
+      return null;
+    return this.last ?? undefined;
+  }
+  readText(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object")
+        this.readLine(parsed);
+    } catch {}
+  }
+  readLine(parsed) {
+    switch (this.format) {
+      case "claude-stream-json":
+        this.readClaude(parsed);
+        return;
+      case "codex-jsonl":
+        this.readCodex(parsed);
+        return;
+      case "opencode-json":
+        this.readOpencode(parsed);
+        return;
+      case "antigravity-stream-json":
+        this.readAntigravity(parsed);
+        return;
+      case "pi-json":
+        this.readPi(parsed);
+        return;
+    }
+  }
+  readClaude(message) {
+    const event = message.type === "stream_event" ? message.event : undefined;
+    if (!event)
+      return;
+    const usage = event.type === "message_start" ? event.message?.usage : event.usage;
+    if (!usage)
+      return;
+    const read = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    const written = usage.output_tokens ?? 0;
+    if (event.type === "message_start") {
+      this.last = { inputTokens: read, outputTokens: written };
+      return;
+    }
+    if (event.type !== "message_delta")
+      return;
+    this.last = { inputTokens: read || (this.last?.inputTokens ?? 0), outputTokens: written };
+  }
+  readCodex(message) {
+    if (message.type !== "turn.completed" || !message.usage)
+      return;
+    this.last = {
+      inputTokens: message.usage.input_tokens ?? 0,
+      outputTokens: message.usage.output_tokens ?? 0
+    };
+  }
+  readOpencode(message) {
+    const tokens = message.part?.type === "step-finish" ? message.part.tokens : undefined;
+    if (!tokens)
+      return;
+    this.last = {
+      inputTokens: (tokens.input ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0),
+      outputTokens: (tokens.output ?? 0) + (tokens.reasoning ?? 0)
+    };
+  }
+  readAntigravity(message) {
+    const step = message.step_update;
+    if (!step)
+      return;
+    const usage = step.usage ?? message.usage;
+    if (!usage)
+      return;
+    this.last = {
+      inputTokens: (usage.input_tokens ?? 0) + (usage.cache_read_tokens ?? 0),
+      outputTokens: (usage.output_tokens ?? 0) + (usage.thinking_tokens ?? 0)
+    };
+  }
+  readPi(message) {
+    const usage = message.usage;
+    if (!usage)
+      return;
+    this.last = {
+      inputTokens: (usage.input ?? usage.input_tokens ?? 0) + (usage.cacheRead ?? 0),
+      outputTokens: usage.output ?? usage.output_tokens ?? 0
+    };
+  }
+}
 function tail(text, limit) {
   return text.length <= limit ? text : `…${text.slice(-limit)}`;
 }
@@ -324,6 +483,13 @@ function textOfResult(content) {
   }
   return "";
 }
+function piResultText(result) {
+  if (result && typeof result === "object" && !Array.isArray(result) && "content" in result) {
+    return textOfResult(result.content);
+  }
+  const text = textOfResult(result);
+  return text || (result == null ? "" : JSON.stringify(result));
+}
 
 // src/execute.ts
 import { spawn } from "node:child_process";
@@ -400,6 +566,33 @@ var PRESETS = {
       ...sessionId ? ["--session-id", sessionId] : []
     ],
     tail: ["-p"]
+  },
+  pi: {
+    bin: "pi",
+    outputFormat: "pi-json",
+    promptVia: "arg",
+    systemPromptFlag: "--append-system-prompt",
+    head: (sessionId) => [
+      "-p",
+      "--mode",
+      "json",
+      ...sessionId ? ["--session-id", sessionId] : []
+    ],
+    tail: []
+  },
+  omp: {
+    bin: "omp",
+    outputFormat: "pi-json",
+    promptVia: "arg",
+    systemPromptFlag: "--append-system-prompt",
+    head: (sessionId) => [
+      "-p",
+      "--mode",
+      "json",
+      "--auto-approve",
+      ...sessionId ? ["--resume", sessionId] : []
+    ],
+    tail: []
   }
 };
 var PRESET_NAMES = Object.keys(PRESETS);
@@ -430,7 +623,8 @@ var OUTPUT_FORMATS = [
   "codex-jsonl",
   "opencode-json",
   "antigravity-stream-json",
-  "copilot-json"
+  "copilot-json",
+  "pi-json"
 ];
 function presetOf(config) {
   if (config.command || !config.agent)
@@ -705,12 +899,12 @@ async function answer(config, client, message, stop) {
     return;
   if (outcome.status === "success") {
     await stream.finish(outcome.output);
-    await client.chatResult(message.id, { status: "success" });
+    await client.chatResult(message.id, { status: "success", usage: stream.contextUsage() });
     return;
   }
   const error = outcome.error ?? "The command failed";
   await stream.fail(error, outcome.output);
-  await client.chatResult(message.id, { status: "failed", error });
+  await client.chatResult(message.id, { status: "failed", error, usage: stream.contextUsage() });
 }
 
 // src/client.ts
@@ -816,8 +1010,10 @@ async function handle(config, client, log2, run) {
   const label = run.issueIdentifier ?? `run ${run.id}`;
   log2(`${label}: started (${run.trigger})`);
   try {
-    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run)));
-    await client.report(run.id, outcome);
+    const usage = new UsageReader(config.outputFormat);
+    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run), { onData: (chunk) => usage.write(chunk) }));
+    usage.end();
+    await client.report(run.id, { ...outcome, usage: usage.value() });
     log2(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsaplan/runner",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Runs an Itsaplan external agent's queued tasks and answers its chat on your own machine",
   "keywords": [
     "itsaplan",
@@ -18,7 +18,9 @@
     "claude-code",
     "codex",
     "antigravity",
-    "opencode"
+    "opencode",
+    "pi",
+    "omp"
   ],
   "homepage": "https://github.com/croffasia/itsaplan/tree/main/packages/runner#readme",
   "repository": {