plumb-bridge 0.1.2 → 0.1.3

package/src/core/executor.ts

@@ -4,10 +4,13 @@
 
 import { randomUUID } from 'node:crypto';
 import type { AgentExecutor, RequestContext, ExecutionEventBus } from '@a2a-js/sdk/server';
-import type { AgentAdapter, AgentTask, PlumbConfig } from '../types.ts';
+import type { AgentAdapter, AgentTask, AdapterEvent, PlumbConfig } from '../types.ts';
 import { ProcessManager, PersistentProcess } from './process.ts';
 import { Ledger } from './ledger.ts';
 
+/** Fang Post-Parse hook: transforms events after parseLine, before executor processes them. */
+export type FangPostParse = (events: AdapterEvent[], ctx: { taskId: string; adapterId: string }) => AdapterEvent[];
+
 export class PlumbExecutor implements AgentExecutor {
   private pm = new ProcessManager();
   private persistent: PersistentProcess | null = null;
@@ -16,18 +19,23 @@ export class PlumbExecutor implements AgentExecutor {
   private ledger: Ledger;
   private contextByTaskId = new Map<string, string>();
 
-  constructor(adapter: AgentAdapter, config: PlumbConfig, ledger: Ledger) {
+  private fangHook?: FangPostParse;
+
+  constructor(adapter: AgentAdapter, config: PlumbConfig, ledger: Ledger, fangHook?: FangPostParse) {
     this.adapter = adapter;
     this.config = config;
     this.ledger = ledger;
+    this.fangHook = fangHook;
   }
 
   async execute(ctx: RequestContext, bus: ExecutionEventBus): Promise<void> {
     const { taskId, contextId } = ctx;
 
-    const parts = (ctx.userMessage.parts ?? []) as Array<{ kind?: string; text?: string }>;
+    // Normalize A2A part boundary: accept both `type` (A2A standard) and `kind` (Plumb internal)
+    type PartEntry = { kind?: string; type?: string; text?: string };
+    const parts = (ctx.userMessage.parts ?? []) as PartEntry[];
     const text = parts
-      .filter(p => p.kind === 'text' && typeof p.text === 'string')
+      .filter(p => (p.kind === 'text' || p.type === 'text') && typeof p.text === 'string')
       .map(p => p.text!)
       .join('\n').trim();
 
@@ -55,6 +63,68 @@ export class PlumbExecutor implements AgentExecutor {
     }
   }
 
+  /** Unified event processor — shared by both oneshot and persistent loops.
+   *  Applies Fang post-parse hook first, then handles each event type. */
+  private handleEvents(
+    rawEvents: AdapterEvent[],
+    accumulated: { text: string },
+    settled: { value: boolean },
+    taskId: string,
+    contextId: string,
+    ledger: Ledger,
+    bus: ExecutionEventBus,
+    timer: ReturnType<typeof setTimeout>,
+    resolve: () => void,
+    cleanup: () => void,
+  ): void {
+    // Fang Post-Parse: transform events before processing
+    const events = this.fangHook
+      ? this.fangHook(rawEvents, { taskId, adapterId: this.adapter.id })
+      : rawEvents;
+
+    for (const ev of events) {
+      if (ev.type === 'text-delta' && ev.text) {
+        accumulated.text += ev.text;
+        ledger.append({ type: 'progress', taskId, text: ev.text, timestamp: new Date().toISOString() });
+        bus.publish({
+          kind: 'artifact-update', taskId, contextId,
+          artifact: { artifactId: 'stdout', name: 'output', parts: [{ kind: 'text', text: ev.text }] },
+          append: true, lastChunk: false,
+        });
+      }
+      if (ev.type === 'tool-call' && ev.tool) {
+        const label = `[${ev.tool}]${ev.input ? ' ' + JSON.stringify(ev.input) : ''}\n`;
+        accumulated.text += label;
+        ledger.append({ type: 'progress', taskId, text: label, timestamp: new Date().toISOString() });
+        bus.publish({ kind: 'artifact-update', taskId, contextId, artifact: { artifactId: 'stdout', name: 'output', parts: [{ kind: 'text', text: label }] }, append: true, lastChunk: false });
+      }
+      if (ev.type === 'tool-result' && ev.output) {
+        const label = `→ ${ev.isError ? '✗' : '✓'} ${ev.output}\n`;
+        accumulated.text += label;
+        ledger.append({ type: 'progress', taskId, text: label, timestamp: new Date().toISOString() });
+        bus.publish({ kind: 'artifact-update', taskId, contextId, artifact: { artifactId: 'stdout', name: 'output', parts: [{ kind: 'text', text: label }] }, append: true, lastChunk: false });
+      }
+      if (ev.type === 'status' && ev.state === 'completed') {
+        settled.value = true;
+        clearTimeout(timer);
+        cleanup();
+        ledger.append({ type: 'task_completed', taskId, timestamp: new Date().toISOString() });
+        bus.publish({ kind: 'message', messageId: randomUUID(), role: 'agent', parts: [{ kind: 'text', text: accumulated.text || 'Done' }] });
+        bus.finished();
+        resolve();
+      }
+      if (ev.type === 'error') {
+        settled.value = true;
+        clearTimeout(timer);
+        cleanup();
+        ledger.append({ type: 'task_failed', taskId, error: ev.message, timestamp: new Date().toISOString() });
+        this.fail(bus, taskId, contextId, ev.message);
+        bus.finished();
+        resolve();
+      }
+    }
+  }
+
   private async executeOneshot(
     ctx: RequestContext,
     bus: ExecutionEventBus,
@@ -76,13 +146,13 @@ export class PlumbExecutor implements AgentExecutor {
 
     const [cmd, ...cliArgs] = this.splitCli(config.cli);
     const extraArgs = adapter.buildArgs(task, config);
-    let accumulated = '';
-    let settled = false;
+    const accumulated = { text: '' };
+    const settled = { value: false };
 
     return new Promise<void>((resolve) => {
       const timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
+        if (settled.value) return;
+        settled.value = true;
         this.pm.kill(taskId);
         ledger.append({ type: 'task_failed', taskId, error: `timed out after ${timeout}s`, timestamp: new Date().toISOString() });
         this.fail(bus, taskId, contextId, `Task timed out after ${timeout}s`);
@@ -95,37 +165,11 @@ export class PlumbExecutor implements AgentExecutor {
         { cwd: config.workdir, env: config.env },
         {
           onLine: (line) => {
-            if (settled) return;
+            if (settled.value) return;
             const events = adapter.parseLine(line);
-            for (const ev of events) {
-              if (ev.type === 'text-delta' && ev.text) {
-                accumulated += ev.text;
-                ledger.append({ type: 'progress', taskId, text: ev.text, timestamp: new Date().toISOString() });
-                bus.publish({
-                  kind: 'artifact-update', taskId, contextId,
-                  artifact: { artifactId: 'stdout', name: 'output', parts: [{ kind: 'text', text: ev.text }] },
-                  append: true, lastChunk: false,
-                });
-              }
-              if (ev.type === 'status' && ev.state === 'completed') {
-                settled = true;
-                clearTimeout(timer);
-                this.contextByTaskId.delete(taskId);
-                ledger.append({ type: 'task_completed', taskId, timestamp: new Date().toISOString() });
-                bus.publish({ kind: 'message', messageId: randomUUID(), role: 'agent', parts: [{ kind: 'text', text: accumulated || 'Done' }] });
-                bus.finished();
-                resolve();
-              }
-              if (ev.type === 'error') {
-                settled = true;
-                clearTimeout(timer);
-                this.contextByTaskId.delete(taskId);
-                ledger.append({ type: 'task_failed', taskId, error: ev.message, timestamp: new Date().toISOString() });
-                this.fail(bus, taskId, contextId, ev.message);
-                bus.finished();
-                resolve();
-              }
-            }
+            this.handleEvents(events, accumulated, settled, taskId, contextId, ledger, bus, timer, resolve, () => {
+              this.contextByTaskId.delete(taskId);
+            });
           },
           onError: (text) => {
             ledger.append({ type: 'log', taskId, level: 'error', text, timestamp: new Date().toISOString() });
@@ -136,12 +180,12 @@ export class PlumbExecutor implements AgentExecutor {
           },
           onExit: (code) => {
             clearTimeout(timer);
-            if (settled) { resolve(); return; }
-            settled = true;
+            if (settled.value) { resolve(); return; }
+            settled.value = true;
             this.contextByTaskId.delete(taskId);
             if (code === 0) {
               ledger.append({ type: 'task_completed', taskId, timestamp: new Date().toISOString() });
-              bus.publish({ kind: 'message', messageId: randomUUID(), role: 'agent', parts: [{ kind: 'text', text: accumulated || '(no output)' }] });
+              bus.publish({ kind: 'message', messageId: randomUUID(), role: 'agent', parts: [{ kind: 'text', text: accumulated.text || '(no output)' }] });
             } else {
               const errMsg = `Process exited with code ${code}`;
               ledger.append({ type: 'task_failed', taskId, error: errMsg, timestamp: new Date().toISOString() });
@@ -153,6 +197,11 @@ export class PlumbExecutor implements AgentExecutor {
         },
       );
 
+      // Notify adapter of user message (Cursor session tracking)
+      const adapterAny = adapter as unknown as Record<string, unknown>;
+      if (typeof adapterAny.setUserMessage === 'function') {
+        (adapterAny as { setUserMessage(msg: string): void }).setUserMessage(task.message);
+      }
       this.pm.stdin(taskId, adapter.formatInput(task), true);
     });
   }
@@ -176,6 +225,8 @@ export class PlumbExecutor implements AgentExecutor {
       });
     }
     await this.persistent.ensure();
+    // Short ready-wait (30s). If agent never emits ready frame but is alive, proceed.
+    await this.persistent.waitUntilReady(30_000);
 
     bus.publish({
       kind: 'task',
@@ -187,13 +238,13 @@ export class PlumbExecutor implements AgentExecutor {
 
     ledger.append({ type: 'task_running', taskId, timestamp: new Date().toISOString() });
 
-    let accumulated = '';
-    let settled = false;
+    const accumulated = { text: '' };
+    const settled = { value: false };
 
     return new Promise<void>((resolve) => {
       const timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
+        if (settled.value) return;
+        settled.value = true;
         this.persistent?.removeLineHandler(taskId);
         ledger.append({ type: 'task_failed', taskId, error: `timed out after ${timeout}s`, timestamp: new Date().toISOString() });
         this.fail(bus, taskId, contextId, `Task timed out after ${timeout}s`);
@@ -202,41 +253,20 @@ export class PlumbExecutor implements AgentExecutor {
       }, timeout * 1000);
 
       this.persistent!.setLineHandler(taskId, (line) => {
-        if (settled) return;
+        if (settled.value) return;
         const events = adapter.parseLine(line);
-        for (const ev of events) {
-          if (ev.type === 'text-delta' && ev.text) {
-            accumulated += ev.text;
-            ledger.append({ type: 'progress', taskId, text: ev.text, timestamp: new Date().toISOString() });
-            bus.publish({
-              kind: 'artifact-update', taskId, contextId,
-              artifact: { artifactId: 'stdout', name: 'output', parts: [{ kind: 'text', text: ev.text }] },
-              append: true, lastChunk: false,
-            });
-          }
-          if (ev.type === 'status' && ev.state === 'completed') {
-            settled = true;
-            clearTimeout(timer);
-            this.contextByTaskId.delete(taskId);
-            this.persistent?.removeLineHandler(taskId);
-            ledger.append({ type: 'task_completed', taskId, timestamp: new Date().toISOString() });
-            bus.publish({ kind: 'message', messageId: randomUUID(), role: 'agent', parts: [{ kind: 'text', text: accumulated || 'Done' }] });
-            bus.finished();
-            resolve();
-          }
-          if (ev.type === 'error') {
-            settled = true;
-            clearTimeout(timer);
-            this.contextByTaskId.delete(taskId);
-            this.persistent?.removeLineHandler(taskId);
-            ledger.append({ type: 'task_failed', taskId, error: ev.message, timestamp: new Date().toISOString() });
-            this.fail(bus, taskId, contextId, ev.message);
-            bus.finished();
-            resolve();
-          }
-        }
+        this.handleEvents(events, accumulated, settled, taskId, contextId, ledger, bus, timer, resolve, () => {
+          this.contextByTaskId.delete(taskId);
+          this.persistent?.removeLineHandler(taskId);
+        });
+
       });
 
+      // Notify adapter of user message (Cursor session tracking)
+      const adapterAny = adapter as unknown as Record<string, unknown>;
+      if (typeof adapterAny.setUserMessage === 'function') {
+        (adapterAny as { setUserMessage(msg: string): void }).setUserMessage(task.message);
+      }
       // Send task input to the persistent process
       this.persistent!.writeWhenActive(taskId, adapter.formatInput(task));
     });
@@ -273,6 +303,12 @@ export class PlumbExecutor implements AgentExecutor {
     }
   }
 
+  /** Persistent agent liveness. null for oneshot, true/false for persistent. */
+  isPersistentAlive(): boolean | null {
+    if (this.adapter.mode !== 'persistent') return null;
+    return this.persistent?.isAlive ?? false;
+  }
+
   private fail(
     bus: ExecutionEventBus,
     taskId: string,

package/src/core/ledger.ts

@@ -1,39 +1,44 @@
 // PLUMB — Ledger
 // Append-only JSONL. Every task event is one line. Crash-survivable. Query with jq.
-// Stolen from pi's append-only tree storage, simplified to linear per-day files.
 
 import { appendFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import type { LedgerEvent } from '../types.ts';
+import { log } from './log.ts';
 
 const LEDGER_DIR = '.plumb/ledger';
 
 export class Ledger {
+  private currentDate: string;
   private path: string;
 
   constructor() {
     if (!existsSync(LEDGER_DIR)) {
       mkdirSync(LEDGER_DIR, { recursive: true });
     }
-    const date = new Date().toISOString().slice(0, 10);
-    this.path = join(LEDGER_DIR, `${date}.jsonl`);
+    this.currentDate = new Date().toISOString().slice(0, 10);
+    this.path = join(LEDGER_DIR, `${this.currentDate}.jsonl`);
   }
 
   append(event: LedgerEvent): void {
     try {
+      this.rollIfNeeded();
       appendFileSync(this.path, JSON.stringify(event) + '\n');
     } catch {
-      // Ledger failure is non-fatal. Log to stderr and continue.
-      process.stderr.write(JSON.stringify({
-        ts: new Date().toISOString(),
-        l: 'error',
-        m: 'ledger_write_failed',
-        event_type: event.type,
-      }) + '\n');
+      log('error', 'ledger_write_failed', { event_type: event.type });
     }
   }
 
   getPath(): string {
+    this.rollIfNeeded();
     return this.path;
   }
+
+  private rollIfNeeded(): void {
+    const today = new Date().toISOString().slice(0, 10);
+    if (today !== this.currentDate) {
+      this.currentDate = today;
+      this.path = join(LEDGER_DIR, `${today}.jsonl`);
+    }
+  }
 }

package/src/core/log.ts

@@ -0,0 +1,12 @@
+// PLUMB — Shared JSONL logger
+// Structured stderr output used by process manager, CLI, and ledger fallback.
+
+export function log(level: string, msg: string, data?: Record<string, unknown>): void {
+  const entry: Record<string, unknown> = {
+    ts: new Date().toISOString(),
+    l: level,
+    m: msg,
+    ...(data ?? {}),
+  };
+  process.stderr.write(JSON.stringify(entry) + '\n');
+}

package/src/core/process.ts

@@ -5,16 +5,9 @@
 // breaking Pi's JSONL protocol where those codepoints are valid inside strings).
 
 import { spawn, type ChildProcess } from 'node:child_process';
-
-function log(level: string, msg: string, data?: Record<string, unknown>): void {
-  const entry: Record<string, unknown> = {
-    ts: new Date().toISOString(),
-    l: level,
-    m: msg,
-    ...(data ?? {}),
-  };
-  process.stderr.write(JSON.stringify(entry) + '\n');
-}
+import { randomUUID } from 'node:crypto';
+import type { RpcHostToolExecutor, RpcParsedResponse } from '../types.ts';
+import { log } from './log.ts';
 
 export function attachJsonlReader(
   stream: NodeJS.ReadableStream,
@@ -161,6 +154,19 @@ export class PersistentProcess {
   private activeTaskId: string | null = null;
   private writeBuffer = new Map<string, string[]>();
 
+  /** Ready-frame detection — resolves waitUntilReady on { "type": "ready" }. */
+  private readyEmitted = false;
+  private readyWaiters: Array<{ resolve: () => void; reject: (e: Error) => void }> = [];
+
+  /** RPC correlated request/response. */
+  private pendingResponses = new Map<string, {
+    settle: (r: RpcParsedResponse | null) => void;
+    timer: NodeJS.Timeout;
+  }>();
+  private rpcDefaultTimeoutMs = 120_000;
+  private rpcHostExecutor: RpcHostToolExecutor | undefined;
+  private hostAbortByRequestId = new Map<string, AbortController>();
+
   readonly onCrash?: (crashedTaskId: string, remainingCount: number) => void;
 
   constructor(
@@ -175,6 +181,85 @@ export class PersistentProcess {
     this.onCrash = callbacks?.onCrash;
   }
 
+  /**
+   * Resolves once the child emits { "type": "ready" } over stdout,
+   * or rejects on timeout after ensure() spawned the process.
+   * Returns immediately if already ready.
+   */
+  async waitUntilReady(timeoutMs = 30_000): Promise<void> {
+    if (this.readyEmitted) return;
+    await new Promise<void>((resolve, reject) => {
+      const t = setTimeout(() => {
+        // If process is alive but never emitted the ready frame, proceed anyway.
+        // Some persistent agents (e.g. Pi in RPC mode) don't output {"type":"ready"}.
+        if (this.isAlive) {
+          resolve();
+        } else {
+          reject(new Error('Timed out waiting for persistent agent ready frame'));
+        }
+      }, timeoutMs);
+      this.readyWaiters.push({
+        resolve: () => { clearTimeout(t); resolve(); },
+        reject: (e: Error) => { clearTimeout(t); reject(e); },
+      });
+    });
+  }
+
+  private signalReady(): void {
+    if (this.readyEmitted) return;
+    this.readyEmitted = true;
+    for (const w of this.readyWaiters) {
+      try { w.resolve(); } catch { /* noop */ }
+    }
+    this.readyWaiters.length = 0;
+  }
+
+  /** Replace / clear custom host tool execution (wired by adapters). */
+  setHostToolExecutor(exec: RpcHostToolExecutor | undefined): void {
+    this.rpcHostExecutor = exec;
+  }
+
+  /** Default timeout for correlated RPC awaits (milliseconds). */
+  setRpcTimeoutMs(ms: number): void {
+    this.rpcDefaultTimeoutMs = Math.max(1000, ms);
+  }
+
+  /**
+   * Send a correlated RPC command payload (stdin JSON line).
+   * Automatically assigns `id` if omitted.
+   * Resolves only on matching { type: "response", id } stdout line (consumed internally).
+   */
+  async sendRpcCommand(
+    command: Record<string, unknown>,
+    opts?: { timeoutMs?: number; correlationId?: string },
+  ): Promise<RpcParsedResponse> {
+    if (!this.isAlive || !this.proc?.stdin) {
+      throw new Error('Persistent process is not alive');
+    }
+    const cid = opts?.correlationId ?? (command.id !== undefined ? String(command.id) : randomUUID());
+    const body: Record<string, unknown> = { ...command, id: cid };
+    const timeoutMs = opts?.timeoutMs ?? this.rpcDefaultTimeoutMs;
+    const cmdHint = typeof body.type === 'string' ? body.type : 'rpc';
+
+    const responsePromise = new Promise<RpcParsedResponse>((resolve) => {
+      const timer = setTimeout(() => {
+        this.pendingResponses.delete(cid);
+        log('warn', 'rpc_timeout', { correlationId: cid, command: cmdHint, timeoutMs });
+        resolve({
+          success: false,
+          error: `RPC correlation timeout (${timeoutMs}ms) for command ${cmdHint}`,
+        });
+      }, timeoutMs);
+      this.pendingResponses.set(cid, {
+        settle: (r) => { clearTimeout(timer); resolve(r ?? { success: false, error: 'Empty RPC response' }); },
+        timer,
+      });
+    });
+
+    this.proc.stdin.write(JSON.stringify(body) + '\n');
+    return responsePromise;
+  }
+
   async ensure(): Promise<void> {
     if (this.proc && this.proc.exitCode === null) return;
 
@@ -198,6 +283,23 @@ export class PersistentProcess {
       log('warn', 'persistent_exited', { activeTaskId: this.activeTaskId, queuedCount: this.taskQueue.length });
       if (this.detachReader) { this.detachReader(); this.detachReader = null; }
 
+      // Reject pending ready-waiters on crash
+      if (this.readyWaiters.length > 0) {
+        for (const w of this.readyWaiters) {
+          try { w.reject(new Error('Persistent process exited — ready wait aborted')); } catch { /* noop */ }
+        }
+        this.readyWaiters.length = 0;
+      }
+      this.readyEmitted = false;
+
+      // Reject pending RPC awaits on crash
+      for (const [, pend] of this.pendingResponses) {
+        try { pend.settle({ success: false, error: 'Persistent process exited — RPC await cleared' }); } catch { /* noop */ }
+        clearTimeout(pend.timer);
+      }
+      this.pendingResponses.clear();
+      this.hostAbortByRequestId.clear();
+
       if (this.activeTaskId && this.taskHandlers.size > 0) {
         const crashedId = this.activeTaskId;
         const remaining = this.taskHandlers.size;
@@ -219,11 +321,89 @@ export class PersistentProcess {
   }
 
   private routeLine(line: string): void {
+    // Intercept protocol frames before task routing
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === 'object') {
+        if (this.dispatchProtocolFrame(parsed)) return; // swallowed by protocol handler
+      }
+    } catch { /* not JSON — fall through to task routing */ }
+
     if (!this.activeTaskId) return;
     const handler = this.taskHandlers.get(this.activeTaskId);
     handler?.(line);
   }
 
+  /** Internal: handle protocol frames. Returns true if swallowed. */
+  private dispatchProtocolFrame(parsed: Record<string, unknown>): boolean {
+    if (parsed.type === 'ready') {
+      this.signalReady();
+      return true; // swallow
+    }
+
+    if (parsed.type === 'response') {
+      const rid = parsed.id !== undefined ? String(parsed.id) : '';
+      if (rid && this.pendingResponses.has(rid)) {
+        const slot = this.pendingResponses.get(rid)!;
+        this.pendingResponses.delete(rid);
+        const success = !!parsed.success;
+        const resp: RpcParsedResponse = success
+          ? { success: true, command: typeof parsed.command === 'string' ? parsed.command : undefined, data: parsed.data }
+          : { success: false, command: typeof parsed.command === 'string' ? parsed.command : undefined, error: typeof parsed.error === 'string' ? parsed.error : 'RPC failure' };
+        slot.settle(resp);
+        return true; // swallow
+      }
+      return false;
+    }
+
+    if (parsed.type === 'host_tool_call' && typeof parsed.id === 'string' && this.rpcHostExecutor) {
+      void this.invokeHostToolAndReply(parsed).catch(() => { /* reply sent inside */ });
+      return true; // swallow — protocol frame, not agent output
+    }
+
+    if (parsed.type === 'host_tool_cancel' && typeof parsed.targetId === 'string') {
+      const ac = this.hostAbortByRequestId.get(parsed.targetId);
+      ac?.abort();
+      return true; // swallow — control frame, not agent output
+    }
+
+    return false;
+  }
+
+  private async invokeHostToolAndReply(raw: Record<string, unknown>): Promise<void> {
+    const exec = this.rpcHostExecutor;
+    if (!exec || !this.proc?.stdin) return;
+
+    const id = typeof raw.id === 'string' ? raw.id : '';
+    const toolCallId = typeof raw.toolCallId === 'string' ? raw.toolCallId : '';
+    const toolName = typeof raw.toolName === 'string' ? raw.toolName : 'unknown_tool';
+    const args = typeof raw.arguments === 'object' && raw.arguments !== null ? raw.arguments as Record<string, unknown> : {};
+
+    const ac = new AbortController();
+    this.hostAbortByRequestId.set(id, ac);
+
+    const sendResult = (result: Array<Record<string, unknown>>, isError?: boolean): void => {
+      if (!this.proc?.stdin) return;
+      const frame: Record<string, unknown> = {
+        type: 'host_tool_result',
+        id,
+        result: { content: [...result] },
+      };
+      if (isError) frame.isError = true;
+      this.proc.stdin.write(JSON.stringify(frame) + '\n');
+    };
+
+    try {
+      const outcome = await exec({ requestId: id, toolCallId, toolName, args, abortSignal: ac.signal });
+      sendResult([...outcome.content], !!outcome.isError);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sendResult([{ type: 'text', text: `Host tool error: ${msg}` }], true);
+    } finally {
+      this.hostAbortByRequestId.delete(id);
+    }
+  }
+
   setLineHandler(taskId: string, handler: (line: string) => void): void {
     this.taskHandlers.set(taskId, handler);
     if (!this.activeTaskId && this.taskQueue.length === 0) {
@@ -289,6 +469,9 @@ export class PersistentProcess {
       this.proc = null;
       this.activeTaskId = null;
       this.writeBuffer.clear();
+      this.pendingResponses.clear();
+      this.hostAbortByRequestId.clear();
+      this.readyEmitted = false;
     }
   }