@parall/claude-agent 1.30.0 → 1.32.0

package/src/index.ts

@@ -1,8 +1,24 @@
 #!/usr/bin/env node
 
-import * as os from "node:os";
-import { ParallAgentGateway, createPlatformConfigManager, createLogger, childLogger, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
-import { ApiError, ParallClient, ParallWs } from "@parall/sdk";
+import * as os from 'node:os';
+import {
+  ParallAgentGateway,
+  createPlatformConfigManager,
+  createLogger,
+  createOtelLogger,
+  childLogger,
+  isPlatformManagedProfile,
+  isPlatformModelOverride,
+  resolveRuntimeModel,
+  parseShutdownDeadlineMs,
+  parseForkDeadlineMs,
+  parseDispatchDeadlineMs,
+  parseProviderConfig,
+  clearAllProviderCreds,
+  llmSource,
+  initAgentTelemetry,
+} from '@parall/agent-core';
+import { ApiError, ParallClient, ParallWs } from '@parall/sdk';
 import {
   buildClaudeRuntimeKey,
   contextFilePathForSession,
@@ -10,12 +26,12 @@ import {
   resolveWsUrl,
   sessionStateFilePathForRuntime,
   stepIdFilePathForSession,
-} from "./config.js";
-import { ClaudeCodeAdapter } from "./dispatch.js";
-import { ClaudeSessionManager } from "./session-manager.js";
-import { ensureClaudeWorkspace } from "./workspace.js";
+} from './config.js';
+import { ClaudeCodeAdapter } from './dispatch.js';
+import { ClaudeSessionManager } from './session-manager.js';
+import { ensureClaudeWorkspace } from './workspace.js';
 
-const log = createLogger("claude-agent");
+const log = createLogger('claude-agent');
 let activeLog = log;
 
 async function getAgentMeWithLegacyFallback(client: ParallClient, orgId: string) {
@@ -30,151 +46,207 @@ async function getAgentMeWithLegacyFallback(client: ParallClient, orgId: string)
   }
 }
 
+function resolveProviderEnv(): void {
+  const pc = parseProviderConfig(process.env);
+  if (!pc) return;
+  clearAllProviderCreds(process.env);
+  const source = llmSource(pc);
+  if (source === 'parall') {
+    process.env.ANTHROPIC_AUTH_TOKEN = process.env.PRLL_API_KEY;
+    process.env.ANTHROPIC_BASE_URL = `${process.env.PRLL_API_URL}/api/llm`;
+    process.env.PRLL_CLAUDE_ALLOW_API_KEY = '1';
+  } else if (source === 'custom') {
+    if (pc.anthropic_auth_token) {
+      process.env.ANTHROPIC_AUTH_TOKEN = pc.anthropic_auth_token;
+      process.env.PRLL_CLAUDE_ALLOW_API_KEY = '1';
+    }
+    if (pc.anthropic_base_url) process.env.ANTHROPIC_BASE_URL = pc.anthropic_base_url;
+  }
+}
+
 async function main() {
-  const config = resolveClaudeAgentConfig(process.env);
+  const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code');
+  activeLog = createOtelLogger('agent', 'claude-agent');
+  try {
+    resolveProviderEnv();
+    const config = resolveClaudeAgentConfig(process.env);
 
-  if (
-    config.allowApiKey &&
-    (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)
-  ) {
-    // Surface the billing path: default is OAuth (Claude.ai subscription); this
-    // branch means the operator opted into Anthropic API pay-per-use, and the
-    // whole point of the strip default is that "silent" is the bad state.
-    log.warn(
-      "PRLL_CLAUDE_ALLOW_API_KEY=1 — ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN will reach the Claude CLI; billing routes through Anthropic API pay-per-use instead of Claude.ai OAuth.",
-    );
-  }
+    if (config.allowApiKey && (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)) {
+      // Surface the billing path: default is OAuth (Claude.ai subscription); this
+      // branch means the operator opted into Anthropic API pay-per-use, and the
+      // whole point of the strip default is that "silent" is the bad state.
+      activeLog.warn(
+        'PRLL_CLAUDE_ALLOW_API_KEY=1 — ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN will reach the Claude CLI; billing routes through Anthropic API pay-per-use instead of Claude.ai OAuth.',
+      );
+    }
 
-  const client = new ParallClient({
-    baseUrl: config.apiUrl,
-    token: config.apiKey,
-    swimlaneName: config.swimlaneName,
-  });
+    const client = new ParallClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      swimlaneName: config.swimlaneName,
+    });
 
-  const me = await getAgentMeWithLegacyFallback(client, config.orgId);
-  const agentUserId = me.id;
-  const agentLog = childLogger(log, agentUserId);
-  activeLog = agentLog;
-  ensureClaudeWorkspace(config.workspaceDir, agentLog, {
-    userId: agentUserId,
-    displayName: me.display_name,
-    description: me.agent_profile?.description ?? undefined,
-  });
-  const runtimeKey = config.runtimeKey || buildClaudeRuntimeKey(agentUserId);
-  const sessionStateFilePath = sessionStateFilePathForRuntime(config.stateDir, runtimeKey);
-  const sessionManager = new ClaudeSessionManager(
-    runtimeKey,
-    sessionStateFilePath,
-    agentLog,
-  );
+    const me = await getAgentMeWithLegacyFallback(client, config.orgId);
+    const agentUserId = me.id;
+    const agentLog = childLogger(activeLog, agentUserId);
+    activeLog = agentLog;
+    ensureClaudeWorkspace(config.workspaceDir, agentLog, {
+      userId: agentUserId,
+      displayName: me.display_name,
+      description: me.agent_profile?.description ?? undefined,
+    });
+    const runtimeKey = config.runtimeKey || buildClaudeRuntimeKey(agentUserId);
+    const sessionStateFilePath = sessionStateFilePathForRuntime(config.stateDir, runtimeKey);
+    const sessionManager = new ClaudeSessionManager(runtimeKey, sessionStateFilePath, agentLog);
 
-  const resolvedWsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
-  const ws = new ParallWs({
-    getTicket: () => client.getWsTicket(),
-    wsUrl: resolvedWsUrl,
-  });
+    const resolvedWsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
+    const ws = new ParallWs({
+      getTicket: () => client.getWsTicket(),
+      wsUrl: resolvedWsUrl,
+    });
 
-  const configMgr = createPlatformConfigManager({ client, stateDir: config.stateDir, runtimeType: "claude-code", log: agentLog });
-  const platformDefaults = await configMgr.fetch();
-  let platformManaged = isPlatformManagedProfile(me.agent_profile);
-  const resolvedModel = platformManaged ? (platformDefaults.model ?? config.model) : config.model;
-  const resolvedEffort = platformManaged
-    ? (platformDefaults.thinkingEffort ?? (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined))
-    : (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined);
-  if (platformDefaults.model) agentLog.info(`platform config: model=${platformDefaults.model} (${platformManaged ? "applied" : "ignored, model_management=self"})`);
-  if (platformDefaults.thinkingEffort) agentLog.info(`platform config: thinking_effort=${platformDefaults.thinkingEffort} (${platformManaged ? "applied" : "ignored, model_management=self"})`);
+    const configMgr = createPlatformConfigManager({
+      client,
+      stateDir: config.stateDir,
+      runtimeType: 'claude-code',
+      log: agentLog,
+    });
+    const platformDefaults = await configMgr.fetch();
+    let platformManaged = isPlatformManagedProfile(me.agent_profile);
+    // Model precedence: operator override (platform-managed) > env > server floor.
+    // The server delivers a model floor for Parall-proxy routes even when
+    // model_management=self, so the CLI never falls back to a built-in default
+    // the catalog might reject — but that floor must lose to an explicit env
+    // override (env > floor). A profile is an operator-override only when it is
+    // platform-managed AND not explicitly self-managed: this treats legacy hosted
+    // agents (model_management=null, resolved to platform server-side) as
+    // overrides, while excluding local self agents whose delivered model is a
+    // floor. effort stays an operator override (platform).
+    let platformModelOverride = isPlatformModelOverride(me.agent_profile);
+    const resolvedModel = resolveRuntimeModel(
+      platformModelOverride,
+      platformDefaults.model,
+      config.model,
+    );
+    const resolvedEffort = platformManaged
+      ? (platformDefaults.thinkingEffort ??
+        (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined))
+      : process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined;
+    if (platformDefaults.model)
+      agentLog.info(
+        `platform config: model=${platformDefaults.model} → resolved=${resolvedModel ?? 'cli-default'} (${platformModelOverride ? 'platform-managed' : 'floor/self'})`,
+      );
+    if (platformDefaults.thinkingEffort)
+      agentLog.info(
+        `platform config: thinking_effort=${platformDefaults.thinkingEffort} (${platformModelOverride ? 'applied' : 'ignored, model_management=self'})`,
+      );
 
-  const adapter = new ClaudeCodeAdapter({
-    claudeBin: config.claudeBin,
-    claudeHome: config.claudeHome,
-    workspaceDir: config.workspaceDir,
-    model: resolvedModel,
-    permissionMode: config.permissionMode,
-    allowedTools: config.allowedTools,
-    disallowedTools: config.disallowedTools,
-    additionalDirs: config.additionalDirs,
-    appendSystemPrompt: config.appendSystemPrompt,
-    allowApiKey: config.allowApiKey,
-    sessionManager,
-    // Static Parall credentials. The long-lived subprocess must authenticate
-    // against Parall's API across many dispatches, so these cannot come from
-    // a per-dispatch DispatchContext.
-    apiUrl: config.apiUrl,
-    apiKey: config.apiKey,
-    orgId: config.orgId,
-    contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
-    stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
-  });
-  if (resolvedEffort) {
-    adapter.updateConfig({ effort: resolvedEffort });
-  }
+    const adapter = new ClaudeCodeAdapter({
+      claudeBin: config.claudeBin,
+      claudeHome: config.claudeHome,
+      workspaceDir: config.workspaceDir,
+      model: resolvedModel,
+      permissionMode: config.permissionMode,
+      allowedTools: config.allowedTools,
+      disallowedTools: config.disallowedTools,
+      additionalDirs: config.additionalDirs,
+      appendSystemPrompt: config.appendSystemPrompt,
+      allowApiKey: config.allowApiKey,
+      sessionManager,
+      // Static Parall credentials. The long-lived subprocess must authenticate
+      // against Parall's API across many dispatches, so these cannot come from
+      // a per-dispatch DispatchContext.
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      contextFilePathForSession: (sessionKey) =>
+        contextFilePathForSession(config.stateDir, sessionKey),
+      stepIdFilePathForSession: (sessionKey) =>
+        stepIdFilePathForSession(config.stateDir, sessionKey),
+    });
+    if (resolvedEffort) {
+      adapter.updateConfig({ effort: resolvedEffort });
+    }
 
-  const gateway = new ParallAgentGateway({
-    accountId: agentUserId,
-    client,
-    ws,
-    connectionLabel: resolvedWsUrl,
-    config: {
-      parall_url: config.apiUrl,
-      api_key: config.apiKey,
-      org_id: config.orgId,
-    },
-    agentUserId,
-    runtimeType: "claude-code",
-    runtimeKey,
-    runtimeRef: {
-      hostname: os.hostname(),
-      pid: process.pid,
-      workspace_dir: config.workspaceDir,
-      claude_home: config.claudeHome,
-    },
-    dispatchAdapter: adapter,
-    log: agentLog,
-    shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
-    contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
-    stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
-    onConfigUpdate: async () => {
-      const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-      platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-      const updated = await configMgr.fetch();
-      const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-      adapter.updateConfig({
-        model: platformManaged ? (updated.model ?? config.model) : (config.model ?? null),
-        effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
-      });
-    },
-    onSessionReady: async () => {
-      const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-      platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-      const updated = await configMgr.fetch();
-      const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-      adapter.updateConfig({
-        model: platformManaged ? (updated.model ?? config.model) : (config.model ?? null),
-        effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
-      });
-    },
-    // Long-lived `claude` subprocesses outlive a single dispatch, so the
-    // gateway's shuttingDown flag alone does not tear them down. Piggyback on
-    // onBeforeDisconnect to close stdin and SIGTERM any survivors after
-    // in-flight drains finish.
-    onBeforeDisconnect: () => adapter.shutdown(),
-    onNewSession: async () => {
-      sessionManager.clearMainSession();
-      await adapter.shutdown();
-    },
-  });
+    const gateway = new ParallAgentGateway({
+      accountId: agentUserId,
+      client,
+      ws,
+      connectionLabel: resolvedWsUrl,
+      config: {
+        parall_url: config.apiUrl,
+        api_key: config.apiKey,
+        org_id: config.orgId,
+      },
+      agentUserId,
+      runtimeType: 'claude-code',
+      runtimeKey,
+      runtimeRef: {
+        hostname: os.hostname(),
+        pid: process.pid,
+        workspace_dir: config.workspaceDir,
+        claude_home: config.claudeHome,
+      },
+      dispatchAdapter: adapter,
+      log: agentLog,
+      shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
+      forkDeadlineMs: parseForkDeadlineMs(process.env.PRLL_FORK_DEADLINE_MS),
+      dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
+      contextFilePathForSession: (sessionKey) =>
+        contextFilePathForSession(config.stateDir, sessionKey),
+      stepIdFilePathForSession: (sessionKey) =>
+        stepIdFilePathForSession(config.stateDir, sessionKey),
+      onConfigUpdate: async () => {
+        const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
+        platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
+        platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
+        const updated = await configMgr.fetch();
+        const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
+        adapter.updateConfig({
+          model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
+          effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
+        });
+      },
+      onSessionReady: async () => {
+        const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
+        platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
+        platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
+        const updated = await configMgr.fetch();
+        const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
+        adapter.updateConfig({
+          model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
+          effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
+        });
+      },
+      // Long-lived `claude` subprocesses outlive a single dispatch, so the
+      // gateway's shuttingDown flag alone does not tear them down. Piggyback on
+      // onBeforeDisconnect to close stdin and SIGTERM any survivors after
+      // in-flight drains finish.
+      onBeforeDisconnect: () => adapter.shutdown(),
+      onNewSession: async () => {
+        sessionManager.clearMainSession();
+        adapter.resetProcesses();
+      },
+      onSessionStale: () => {
+        sessionManager.clearMainSession();
+        adapter.resetProcesses();
+      },
+    });
 
-  const abortController = new AbortController();
-  const abort = () => abortController.abort();
-  process.on("SIGINT", abort);
-  process.on("SIGTERM", abort);
+    const abortController = new AbortController();
+    const abort = () => abortController.abort();
+    process.on('SIGINT', abort);
+    process.on('SIGTERM', abort);
 
-  try {
-    agentLog.info(`starting self-hosted Claude runtime for ${me.display_name} (${agentUserId})`);
-    await gateway.run(abortController.signal);
+    try {
+      agentLog.info(`starting self-hosted Claude runtime for ${me.display_name} (${agentUserId})`);
+      await gateway.run(abortController.signal);
+    } finally {
+      process.off('SIGINT', abort);
+      process.off('SIGTERM', abort);
+    }
   } finally {
-    process.off("SIGINT", abort);
-    process.off("SIGTERM", abort);
+    await telemetry.shutdown();
   }
 }
 

package/src/output-parser.ts

@@ -1,9 +1,9 @@
-import type { Readable } from "node:stream";
-import type { RuntimeEvent } from "@parall/agent-core";
+import type { Readable } from 'node:stream';
+import type { RuntimeEvent } from '@parall/agent-core';
 
 export type ClaudeParsedEvent =
   | RuntimeEvent
-  | { type: "session_id"; sessionId: string }
+  | { type: 'session_id'; sessionId: string }
   // turn_end is emitted for every `result` frame (both `is_error: true` and
   // `is_error: false`); `isError` carries the frame's status so the consumer
   // can tell a clean turn boundary from a failed one without inspecting the
@@ -14,7 +14,7 @@ export type ClaudeParsedEvent =
   // stream. For a short-lived `--print <prompt>` invocation the final
   // `result` frame arrives right before stdout EOF, so this event is
   // redundant there — safe to ignore.
-  | { type: "turn_end"; sessionId?: string; isError: boolean };
+  | { type: 'turn_end'; sessionId?: string; isError: boolean };
 
 type ToolUseMeta = {
   toolName: string;
@@ -22,26 +22,26 @@ type ToolUseMeta = {
 };
 
 function asTrimmedString(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
+  if (typeof value !== 'string') return undefined;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : undefined;
 }
 
 function parseEventTimestampMs(event: unknown): number | undefined {
-  if (!event || typeof event !== "object") return undefined;
+  if (!event || typeof event !== 'object') return undefined;
   const timestamp = (event as { timestamp?: unknown }).timestamp;
-  if (typeof timestamp !== "string") return undefined;
+  if (typeof timestamp !== 'string') return undefined;
   const ms = Date.parse(timestamp);
   return Number.isFinite(ms) ? ms : undefined;
 }
 
 function stringifyContent(value: unknown): string {
-  if (typeof value === "string") return value;
+  if (typeof value === 'string') return value;
   if (Array.isArray(value)) {
     return value
       .map((item) => {
-        if (typeof item === "string") return item;
-        if (!item || typeof item !== "object") return "";
+        if (typeof item === 'string') return item;
+        if (!item || typeof item !== 'object') return '';
         const text = asTrimmedString((item as { text?: unknown }).text);
         if (text) return text;
         const thinking = asTrimmedString((item as { thinking?: unknown }).thinking);
@@ -49,19 +49,19 @@ function stringifyContent(value: unknown): string {
         return JSON.stringify(item);
       })
       .filter(Boolean)
-      .join("\n");
+      .join('\n');
   }
-  if (value && typeof value === "object") {
+  if (value && typeof value === 'object') {
     return JSON.stringify(value);
   }
-  return "";
+  return '';
 }
 
 function normalizeToolResultContent(content: unknown, fallback: unknown): string {
   const direct = stringifyContent(content).trim();
   if (direct) return direct;
 
-  if (fallback && typeof fallback === "object") {
+  if (fallback && typeof fallback === 'object') {
     const stdout = asTrimmedString((fallback as { stdout?: unknown }).stdout);
     const stderr = asTrimmedString((fallback as { stderr?: unknown }).stderr);
     if (stdout && stderr) return `${stdout}\n${stderr}`;
@@ -69,20 +69,20 @@ function normalizeToolResultContent(content: unknown, fallback: unknown): string
     if (stderr) return stderr;
   }
 
-  return "";
+  return '';
 }
 
 async function* readJsonLines(readable: Readable): AsyncGenerator<string> {
-  let buffer = "";
-  readable.setEncoding("utf8");
+  let buffer = '';
+  readable.setEncoding('utf8');
   for await (const chunk of readable) {
     buffer += chunk;
-    let newlineIndex = buffer.indexOf("\n");
+    let newlineIndex = buffer.indexOf('\n');
     while (newlineIndex >= 0) {
       const line = buffer.slice(0, newlineIndex).trim();
       buffer = buffer.slice(newlineIndex + 1);
       if (line) yield line;
-      newlineIndex = buffer.indexOf("\n");
+      newlineIndex = buffer.indexOf('\n');
     }
   }
 
@@ -90,7 +90,9 @@ async function* readJsonLines(readable: Readable): AsyncGenerator<string> {
   if (tail) yield tail;
 }
 
-export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator<ClaudeParsedEvent> {
+export async function* parseClaudeStreamJson(
+  readable: Readable,
+): AsyncGenerator<ClaudeParsedEvent> {
   const toolUses = new Map<string, ToolUseMeta>();
 
   for await (const line of readJsonLines(readable)) {
@@ -101,46 +103,47 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
       continue;
     }
 
-    if (!event || typeof event !== "object") continue;
+    if (!event || typeof event !== 'object') continue;
     const now = Date.now();
     const eventTimestampMs = parseEventTimestampMs(event) ?? now;
     const eventRecord = event as Record<string, unknown>;
 
-    if (eventRecord.type === "system" && eventRecord.subtype === "init") {
+    if (eventRecord.type === 'system' && eventRecord.subtype === 'init') {
       const sessionId = asTrimmedString(eventRecord.session_id);
       if (sessionId) {
-        yield { type: "session_id", sessionId };
+        yield { type: 'session_id', sessionId };
       }
       continue;
     }
 
-    if (eventRecord.type === "assistant") {
+    if (eventRecord.type === 'assistant') {
       if (eventRecord.error) continue;
 
       const message = eventRecord.message;
-      const content = message && typeof message === "object"
-        ? (message as { content?: unknown }).content
-        : undefined;
+      const content =
+        message && typeof message === 'object'
+          ? (message as { content?: unknown }).content
+          : undefined;
       if (!Array.isArray(content)) continue;
 
       for (const block of content) {
-        if (!block || typeof block !== "object") continue;
+        if (!block || typeof block !== 'object') continue;
         const blockRecord = block as Record<string, unknown>;
 
         switch (blockRecord.type) {
-          case "thinking": {
+          case 'thinking': {
             const text = asTrimmedString(blockRecord.thinking);
-            if (text) yield { type: "thinking", text };
+            if (text) yield { type: 'thinking', text };
             break;
           }
 
-          case "text": {
+          case 'text': {
             const text = asTrimmedString(blockRecord.text);
-            if (text) yield { type: "text", text, project: true };
+            if (text) yield { type: 'text', text, project: true };
             break;
           }
 
-          case "tool_use": {
+          case 'tool_use': {
             const callId = asTrimmedString(blockRecord.id);
             const toolName = asTrimmedString(blockRecord.name);
             if (!callId || !toolName) break;
@@ -151,7 +154,7 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
             });
 
             yield {
-              type: "tool_call",
+              type: 'tool_call',
               callId,
               toolName,
               input: blockRecord.input ?? {},
@@ -164,17 +167,18 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
       continue;
     }
 
-    if (eventRecord.type === "user") {
+    if (eventRecord.type === 'user') {
       const message = eventRecord.message;
-      const content = message && typeof message === "object"
-        ? (message as { content?: unknown }).content
-        : undefined;
+      const content =
+        message && typeof message === 'object'
+          ? (message as { content?: unknown }).content
+          : undefined;
       if (!Array.isArray(content)) continue;
 
       for (const block of content) {
-        if (!block || typeof block !== "object") continue;
+        if (!block || typeof block !== 'object') continue;
         const blockRecord = block as Record<string, unknown>;
-        if (blockRecord.type !== "tool_result") continue;
+        if (blockRecord.type !== 'tool_result') continue;
 
         const callId = asTrimmedString(blockRecord.tool_use_id);
         if (!callId) continue;
@@ -183,11 +187,11 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
         const output = normalizeToolResultContent(blockRecord.content, eventRecord.tool_use_result);
 
         yield {
-          type: "tool_result",
+          type: 'tool_result',
           callId,
-          toolName: meta?.toolName ?? "unknown",
+          toolName: meta?.toolName ?? 'unknown',
           output,
-          ...(blockRecord.is_error === true ? { error: output || "Tool call failed" } : {}),
+          ...(blockRecord.is_error === true ? { error: output || 'Tool call failed' } : {}),
           ...(meta ? { durationMs: Math.max(0, eventTimestampMs - meta.startedAtMs) } : {}),
         };
         toolUses.delete(callId);
@@ -195,13 +199,14 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
       continue;
     }
 
-    if (eventRecord.type === "result") {
+    if (eventRecord.type === 'result') {
       const isError = eventRecord.is_error === true;
       if (isError) {
-        const message = asTrimmedString(eventRecord.result)
-          || asTrimmedString(eventRecord.error)
-          || "Claude dispatch failed";
-        yield { type: "error", message };
+        const message =
+          asTrimmedString(eventRecord.result) ||
+          asTrimmedString(eventRecord.error) ||
+          'Claude dispatch failed';
+        yield { type: 'error', message };
       }
       // Turn boundary: the subprocess lives across many turns, so any
       // tool_use entries that never matched a tool_result this turn
@@ -210,7 +215,7 @@ export async function* parseClaudeStreamJson(readable: Readable): AsyncGenerator
       // the map grow unbounded or mislabel durations on id collisions.
       toolUses.clear();
       yield {
-        type: "turn_end",
+        type: 'turn_end',
         sessionId: asTrimmedString(eventRecord.session_id),
         isError,
       };