multiagents 0.1.0

package/orchestrator/monitor.ts

@@ -0,0 +1,285 @@
+// ============================================================================
+// multiagents — Process Monitor
+// ============================================================================
+// Monitors agent process lifecycle: stdout parsing, status updates, crash
+// detection.
+// ============================================================================
+
+import type { Subprocess } from "bun";
+import type { BrokerClient } from "../shared/broker-client.ts";
+import { log } from "../shared/utils.ts";
+
+const LOG_PREFIX = "monitor";
+
+// Track last-seen cumulative tokens per slot (Codex sends cumulative totals)
+const lastTokenTotals = new Map<number, { input: number; output: number; cacheRead: number }>();
+
+/** Update token usage for a slot — handles both delta and cumulative formats. */
+async function updateTokenUsage(
+  slotId: number,
+  tokens: { input: number; output: number; cacheRead: number },
+  brokerClient: BrokerClient,
+): Promise<void> {
+  // Codex sends cumulative totals; Claude sends per-result totals.
+  // For Codex, we compute the delta from the last seen value.
+  // For Claude, each "result" contains the full session usage, so we also delta.
+  const last = lastTokenTotals.get(slotId) ?? { input: 0, output: 0, cacheRead: 0 };
+  const deltaInput = Math.max(0, tokens.input - last.input);
+  const deltaOutput = Math.max(0, tokens.output - last.output);
+  const deltaCacheRead = Math.max(0, tokens.cacheRead - last.cacheRead);
+
+  lastTokenTotals.set(slotId, tokens);
+
+  if (deltaInput === 0 && deltaOutput === 0 && deltaCacheRead === 0) return;
+
+  try {
+    await brokerClient.updateSlot({
+      id: slotId,
+      input_tokens: deltaInput,
+      output_tokens: deltaOutput,
+      cache_read_tokens: deltaCacheRead,
+    });
+  } catch {
+    // Best-effort token tracking
+  }
+}
+
+/** Event emitted by the process monitor. */
+export interface AgentEvent {
+  type: string;
+  severity: "info" | "warning" | "critical";
+  slotId: number;
+  sessionId: string;
+  message: string;
+  data?: Record<string, unknown>;
+}
+
+/**
+ * Monitor an agent subprocess: read stdout for progress signals,
+ * update slot status in the broker, and fire events on exit.
+ *
+ * This function is non-blocking — it starts async readers and returns
+ * immediately.
+ */
+export function monitorProcess(
+  proc: Subprocess,
+  slotId: number,
+  sessionId: string,
+  brokerClient: BrokerClient,
+  onEvent: (event: AgentEvent) => void,
+): void {
+  // Read stdout for JSON progress lines
+  if (proc.stdout) {
+    readStream(proc.stdout, slotId, sessionId, brokerClient, onEvent);
+  }
+
+  // Read stderr for error output
+  if (proc.stderr) {
+    readStderr(proc.stderr, slotId, sessionId, onEvent);
+  }
+
+  // Monitor process exit
+  proc.exited.then((exitCode) => {
+    handleExit(exitCode, slotId, sessionId, brokerClient, onEvent);
+  });
+}
+
+/** Read stdout stream, parse JSON lines for progress signals. */
+async function readStream(
+  stdout: ReadableStream<Uint8Array>,
+  slotId: number,
+  sessionId: string,
+  brokerClient: BrokerClient,
+  onEvent: (event: AgentEvent) => void,
+): Promise<void> {
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    const reader = stdout.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        await processLine(trimmed, slotId, sessionId, brokerClient, onEvent);
+      }
+    }
+  } catch (err) {
+    log(LOG_PREFIX, `stdout reader error for slot ${slotId}: ${err}`);
+  }
+}
+
+/** Process a single stdout line, attempting JSON parse for structured signals. */
+async function processLine(
+  line: string,
+  slotId: number,
+  sessionId: string,
+  brokerClient: BrokerClient,
+  onEvent: (event: AgentEvent) => void,
+): Promise<void> {
+  // Try parsing as JSON (Claude stream-json format)
+  try {
+    const parsed = JSON.parse(line);
+
+    // Claude stream-json result message (includes final token usage)
+    if (parsed.type === "result" && parsed.result) {
+      onEvent({
+        type: "agent_output",
+        severity: "info",
+        slotId,
+        sessionId,
+        message: `Agent produced result`,
+        data: { result: parsed.result },
+      });
+
+      // Extract token usage from Claude result
+      const usage = parsed.result?.usage;
+      if (usage) {
+        await updateTokenUsage(slotId, {
+          input: usage.input_tokens ?? 0,
+          output: usage.output_tokens ?? 0,
+          cacheRead: usage.cache_read_input_tokens ?? usage.cache_creation_input_tokens ?? 0,
+        }, brokerClient);
+      }
+    }
+
+    // Codex token_count message
+    if (parsed.msg?.type === "token_count" && parsed.msg?.info?.total_token_usage) {
+      const tu = parsed.msg.info.total_token_usage;
+      await updateTokenUsage(slotId, {
+        input: tu.input_tokens ?? 0,
+        output: tu.output_tokens ?? 0,
+        cacheRead: tu.cached_input_tokens ?? 0,
+      }, brokerClient);
+    }
+
+    // Claude stream-json assistant message with content
+    if (parsed.type === "assistant" && parsed.message?.content) {
+      // Update the slot's context snapshot with latest output
+      try {
+        const contentText = Array.isArray(parsed.message.content)
+          ? parsed.message.content
+              .filter((c: any) => c.type === "text")
+              .map((c: any) => c.text)
+              .join("")
+          : String(parsed.message.content);
+
+        const summary = contentText.slice(0, 200);
+        await brokerClient.updateSlot({
+          id: slotId,
+          context_snapshot: JSON.stringify({
+            last_summary: summary,
+            last_status: "working",
+            updated_at: Date.now(),
+          }),
+        });
+      } catch {
+        // Best-effort snapshot update
+      }
+    }
+
+    // Tool use signals progress
+    if (parsed.type === "assistant" && parsed.message?.stop_reason === "tool_use") {
+      onEvent({
+        type: "agent_progress",
+        severity: "info",
+        slotId,
+        sessionId,
+        message: "Agent is using tools",
+      });
+    }
+
+    return;
+  } catch {
+    // Not JSON — treat as plain text output, ignore
+  }
+}
+
+/** Read stderr for error messages. */
+async function readStderr(
+  stderr: ReadableStream<Uint8Array>,
+  slotId: number,
+  sessionId: string,
+  onEvent: (event: AgentEvent) => void,
+): Promise<void> {
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    const reader = stderr.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // Check for error patterns
+        if (/error|fatal|panic|exception/i.test(trimmed)) {
+          onEvent({
+            type: "agent_error",
+            severity: "warning",
+            slotId,
+            sessionId,
+            message: `Agent stderr: ${trimmed.slice(0, 200)}`,
+          });
+        }
+      }
+    }
+  } catch (err) {
+    log(LOG_PREFIX, `stderr reader error for slot ${slotId}: ${err}`);
+  }
+}
+
+/** Handle process exit — update slot and emit event. */
+async function handleExit(
+  exitCode: number,
+  slotId: number,
+  sessionId: string,
+  brokerClient: BrokerClient,
+  onEvent: (event: AgentEvent) => void,
+): Promise<void> {
+  // Update slot status to disconnected
+  try {
+    await brokerClient.updateSlot({
+      id: slotId,
+      status: "disconnected",
+    });
+  } catch (err) {
+    log(LOG_PREFIX, `Failed to update slot ${slotId} on exit: ${err}`);
+  }
+
+  if (exitCode === 0) {
+    onEvent({
+      type: "agent_completed",
+      severity: "info",
+      slotId,
+      sessionId,
+      message: `Agent in slot ${slotId} completed successfully`,
+      data: { exit_code: exitCode },
+    });
+  } else {
+    onEvent({
+      type: "agent_crashed",
+      severity: "critical",
+      slotId,
+      sessionId,
+      message: `Agent in slot ${slotId} exited with code ${exitCode}`,
+      data: { exit_code: exitCode },
+    });
+  }
+
+  log(LOG_PREFIX, `Slot ${slotId} process exited with code ${exitCode}`);
+}