@narumitw/pi-subagents 2.0.1 → 2.0.3

package/dist/chunks/rpc-transport-Y6LA5BOP.ts

@@ -0,0 +1,1154 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  buildStatefulTurnPrompt,
+  resolveStatefulTurnTimeout
+} from "./chunk-SCZ33MYW.ts";
+import {
+  JsonLineDecoder,
+  terminateProcess
+} from "./chunk-DQMN4OYM.ts";
+import {
+  resolvePiInvocation
+} from "./chunk-IGAMVWFN.ts";
+import "./chunk-47SK2QYC.ts";
+import "./chunk-HKC4ES4B.ts";
+import "./chunk-DSOOH73Y.ts";
+import {
+  buildCurrentTurnPrompt,
+  validateInProcessTools
+} from "./chunk-UVFVHIOP.ts";
+import {
+  CHILD_PEER_TOOL_NAMES,
+  childPeerBridgePath,
+  formatPeerMessage,
+  peerBridgeEnvironment
+} from "./chunk-EWWXFU7N.ts";
+import {
+  resolvePiPromptResources
+} from "./chunk-G6VZTCFH.ts";
+import {
+  buildTimeoutFinalizationPrompt,
+  resolveTimeoutFinalizationMs
+} from "./chunk-G3RSMSXJ.ts";
+import "./chunk-AEUYS7JC.ts";
+import {
+  TURN_TERMINATION_VERSION,
+  TimeoutProgressJournal,
+  formatTimeoutCheckpoint,
+  formatTurnTerminationMessage,
+  journalMessages
+} from "./chunk-RTCVYIZA.ts";
+import {
+  TurnBudgetMonitor
+} from "./chunk-ONDTY4EL.ts";
+import {
+  discoverAgents
+} from "./chunk-PSK43Y6A.ts";
+import "./chunk-RSUXZD6S.ts";
+import "./chunk-7QPPBBXZ.ts";
+import {
+  readSubagentSettings
+} from "./chunk-QBORTI4W.ts";
+import "./chunk-7OBINKFM.ts";
+import "./chunk-DPPVEQAM.ts";
+import {
+  PI_SUBAGENTS_RPC_PROTOCOL,
+  emptyTransportUsage
+} from "./chunk-C4L6P266.ts";
+import {
+  boundedPrivateText,
+  safeTerminalText
+} from "./chunk-SWGQLFSD.ts";
+import "./chunk-I2FAK44T.ts";
+import {
+  DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_MAX_STDERR_BYTES,
+  appendBounded,
+  truncateUtf8
+} from "./chunk-H3FP6DLR.ts";
+import "./chunk-RRR66UWR.ts";
+
+// src/rpc-transport.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// src/rpc-timeout-finalization.ts
+async function finalizeTimedOutRpcTurn(options) {
+  options.resetCapture();
+  let settleResolve;
+  let settleReject;
+  const settled = new Promise((resolve, reject) => {
+    settleResolve = resolve;
+    settleReject = reject;
+  });
+  void settled.catch(() => void 0);
+  const unsubscribeEvent = options.client.onEvent((event) => {
+    if (eventType(event) === "agent_settled") settleResolve();
+  });
+  const unsubscribeClose = options.client.onClose(settleReject);
+  let error;
+  try {
+    const finalizationMs = resolveTimeoutFinalizationMs(
+      options.workTimeoutMs,
+      options.finalizationTimeoutMs
+    );
+    const deadline = Date.now() + finalizationMs;
+    await raceWithAbort(
+      () => options.client.prompt(
+        buildTimeoutFinalizationPrompt({
+          task: options.task,
+          partialOutput: options.partialOutput,
+          checkpoint: options.checkpoint,
+          terminationReason: options.terminationReason,
+          resultFormat: options.resultFormat
+        }),
+        remainingMs(deadline)
+      ),
+      options.signal,
+      remainingMs(deadline)
+    );
+    const settlement = await waitForSettlement(settled, options.signal, remainingMs(deadline));
+    if (settlement !== "settled") {
+      const [abortCompleted, stopped] = await Promise.all([
+        settlesWithin(options.client.abort(), options.abortGraceMs),
+        settlesWithin(settled, options.abortGraceMs)
+      ]);
+      if (!stopped) await boundedRelease(options);
+      error = [
+        `timeout summary ${settlement}`,
+        abortCompleted ? void 0 : "summary abort command did not settle"
+      ].filter(Boolean).join("; ");
+    }
+  } catch (caught) {
+    error = boundedError(caught);
+    await boundedRelease(options);
+  } finally {
+    unsubscribeEvent();
+    unsubscribeClose();
+  }
+  const capture = options.getCapture();
+  const output = truncateUtf8(capture.output || capture.partial, DEFAULT_MAX_OUTPUT_BYTES);
+  if (!error && (capture.stopReason === "error" || !output.text.trim())) {
+    error = capture.error || "Timeout summary produced no final text";
+  }
+  return {
+    output: output.text,
+    truncated: output.truncated,
+    status: error ? /timed out|timeout/iu.test(error) ? "timed_out" : "failed" : "completed",
+    error
+  };
+}
+function eventType(value) {
+  return value && typeof value === "object" && typeof value.type === "string" ? value.type ?? void 0 : void 0;
+}
+function remainingMs(deadline) {
+  return Math.max(1, deadline - Date.now());
+}
+async function raceWithAbort(start, signal, timeoutMs) {
+  if (signal.aborted) throw abortError();
+  let onAbort;
+  let timer;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+  });
+  const timedOut = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error("RPC timeout summary prompt timed out")), timeoutMs);
+  });
+  try {
+    return await Promise.race([start(), aborted, timedOut]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+async function waitForSettlement(settled, signal, timeoutMs) {
+  if (signal.aborted) return "aborted";
+  let timer;
+  let onAbort;
+  try {
+    return await Promise.race([
+      settled.then(() => "settled"),
+      new Promise((resolve) => {
+        onAbort = () => resolve("aborted");
+        signal.addEventListener("abort", onAbort, { once: true });
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+async function boundedRelease(options) {
+  return settlesWithin(options.release(), options.abortGraceMs + 1e3);
+}
+async function settlesWithin(settled, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      settled.then(
+        () => true,
+        () => true
+      ),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function abortError() {
+  const error = new Error("RPC timeout summary aborted");
+  error.name = "AbortError";
+  return error;
+}
+function boundedError(error) {
+  return truncateUtf8(error instanceof Error ? error.message : String(error), 16 * 1024).text;
+}
+
+// src/rpc-transport-metadata.ts
+function modelIdentity(value) {
+  if (!value || typeof value !== "object") return {};
+  const model = value;
+  return {
+    provider: typeof model.provider === "string" ? boundedPrivateText(model.provider, 256) : void 0,
+    model: typeof model.id === "string" ? boundedPrivateText(model.id, 256) : void 0
+  };
+}
+function normalizeThinking(value) {
+  return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value) ? value : void 0;
+}
+function rpcPolicy(config, agent) {
+  return {
+    inherited: ["environment", "cwdResources"],
+    overridden: [
+      "cwd",
+      "extensions",
+      ...config.model ? ["model"] : [],
+      ...agent.thinkingLevel || config.thinkingLevel ? ["thinkingLevel"] : [],
+      ...config.tools ? ["tools"] : []
+    ],
+    unsupported: ["approvalPolicy", "sandboxProfile", "providerHeaders", "extensionState"]
+  };
+}
+function interruptedRpcOutcome(output, telemetry, failurePhase) {
+  return {
+    output,
+    exitCode: 130,
+    aborted: true,
+    error: "RPC subagent was aborted",
+    telemetry: {
+      ...telemetry,
+      phase: "interrupted",
+      failurePhase,
+      updatedAt: Date.now()
+    }
+  };
+}
+function boundedError2(error) {
+  return boundedPrivateText(
+    error instanceof Error ? error.message : String(error),
+    DEFAULT_MAX_OUTPUT_BYTES
+  );
+}
+
+// src/rpc-turn-capture.ts
+function createRpcTurnCapture() {
+  return {
+    output: "",
+    partial: "",
+    usage: emptyTransportUsage(),
+    journal: new TimeoutProgressJournal()
+  };
+}
+function captureRpcEvent(event, capture) {
+  if (!isRecord(event)) return;
+  if (event.type === "tool_execution_start") {
+    capture.journal.recordToolCall(
+      typeof event.toolCallId === "string" ? event.toolCallId : "",
+      typeof event.toolName === "string" ? event.toolName : "tool",
+      isRecord(event.args) ? event.args : {}
+    );
+  }
+  if (event.type === "tool_execution_end") {
+    const result = isRecord(event.result) ? event.result : {};
+    capture.journal.recordToolResult(
+      typeof event.toolCallId === "string" ? event.toolCallId : "",
+      typeof event.toolName === "string" ? event.toolName : "tool",
+      { content: result.content, isError: event.isError }
+    );
+  }
+  if (event.type === "message_update") {
+    const delta = event.assistantMessageEvent;
+    if (isRecord(delta) && delta.type === "text_delta" && typeof delta.delta === "string") {
+      capture.partial = truncateUtf8(
+        `${capture.partial}${delta.delta}`,
+        DEFAULT_MAX_OUTPUT_BYTES
+      ).text;
+    }
+  }
+  if (event.type !== "message_end" || !isRecord(event.message)) return;
+  const candidate = event.message;
+  if (candidate.role !== "toolResult") journalMessages(capture.journal, [candidate]);
+  if (candidate.role !== "assistant") return;
+  capture.output = truncateUtf8(
+    assistantText(candidate.content) || capture.partial,
+    DEFAULT_MAX_OUTPUT_BYTES
+  ).text;
+  capture.partial = capture.output;
+  capture.stopReason = typeof candidate.stopReason === "string" ? candidate.stopReason : void 0;
+  capture.error = typeof candidate.errorMessage === "string" ? boundedPrivateText(candidate.errorMessage, 4 * 1024) : void 0;
+  capture.provider = typeof candidate.provider === "string" ? boundedPrivateText(candidate.provider, 256) : void 0;
+  const responseModel = typeof candidate.responseModel === "string" ? candidate.responseModel : typeof candidate.model === "string" ? candidate.model : void 0;
+  capture.model = responseModel ? boundedPrivateText(responseModel, 256) : void 0;
+  capture.usage.turns++;
+  addUsage(capture.usage, candidate.usage);
+}
+function observeRpcBudgetEvent(event, monitor) {
+  if (!isRecord(event)) return;
+  if (event.type === "tool_execution_end") monitor.recordActivity();
+  if (event.type !== "message_end" || !isRecord(event.message)) return;
+  const message = event.message;
+  if (message.role === "toolResult") {
+    monitor.recordActivity();
+    return;
+  }
+  if (message.role !== "assistant") return;
+  monitor.recordToolCalls(assistantToolCallCount(message.content));
+  monitor.recordAssistantTurn(
+    typeof message.stopReason === "string" ? message.stopReason : void 0
+  );
+}
+function assistantToolCallCount(content) {
+  if (!Array.isArray(content)) return 0;
+  return content.filter((part) => isRecord(part) && part.type === "toolCall").length;
+}
+function addUsage(target, value) {
+  if (!isRecord(value)) return;
+  target.input += safeNonNegative(value.input);
+  target.output += safeNonNegative(value.output);
+  target.cacheRead += safeNonNegative(value.cacheRead);
+  target.cacheWrite += safeNonNegative(value.cacheWrite);
+  const reportedTotal = safeNonNegative(value.totalTokens);
+  target.totalTokens += reportedTotal || safeNonNegative(value.input) + safeNonNegative(value.output) + safeNonNegative(value.cacheRead) + safeNonNegative(value.cacheWrite);
+  if (isRecord(value.cost)) target.cost += safeNonNegative(value.cost.total);
+}
+function safeNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER ? value : 0;
+}
+function assistantText(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.flatMap((part) => {
+    if (!isRecord(part)) return [];
+    return part.type === "text" && typeof part.text === "string" ? [part.text] : [];
+  }).join("\n");
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/rpc-transport.ts
+var COMMAND_TIMEOUT_MS = 3e4;
+var STARTUP_TIMEOUT_MS = 3e4;
+var ABORT_GRACE_MS = 5e3;
+var BUILT_IN_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
+var RpcProtocolClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  process;
+  processClosed = false;
+  decoder;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  nextRequestId = 0;
+  stderr = "";
+  malformedLines = 0;
+  oversizedLines = 0;
+  closedError;
+  closePromise;
+  cleanupTermination;
+  async start(signal) {
+    if (this.process) throw new Error("RPC subagent client already started");
+    if (signal?.aborted) throw abortError2("RPC subagent start aborted");
+    const invocation = this.options.invocation ? {
+      command: this.options.invocation.command,
+      args: [...this.options.invocation.args, ...this.options.args]
+    } : resolvePiInvocation(this.options.args);
+    const proc = spawn(invocation.command, invocation.args, {
+      cwd: this.options.cwd,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.options.env }
+    });
+    this.process = proc;
+    this.processClosed = false;
+    this.decoder = new JsonLineDecoder({
+      onValue: (value) => this.handleValue(value),
+      onMalformed: () => {
+        this.malformedLines++;
+        this.fail(new Error("RPC subagent emitted malformed JSONL"));
+      },
+      onOversized: () => {
+        this.oversizedLines++;
+        this.fail(new Error("RPC subagent emitted an oversized JSONL record"));
+      }
+    });
+    proc.stdout?.on("data", (chunk) => this.decoder?.push(chunk));
+    proc.stdin?.on("error", (error) => this.fail(errorMessage("RPC stdin failed", error)));
+    proc.stderr?.on("data", (chunk) => {
+      this.stderr = appendBounded(
+        this.stderr,
+        Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk),
+        DEFAULT_MAX_STDERR_BYTES
+      ).text;
+    });
+    proc.once("error", (error) => this.fail(errorMessage("RPC process failed", error)));
+    proc.once("close", (code, childSignal) => {
+      this.processClosed = true;
+      this.decoder?.finish();
+      this.fail(
+        new Error(
+          `RPC subagent exited (code=${code ?? "null"}, signal=${childSignal ?? "null"})${this.stderr ? `: ${safeTerminalText(this.stderr)}` : ""}`
+        )
+      );
+    });
+    try {
+      await waitForSpawn(proc, signal, this.options.startupTimeoutMs ?? STARTUP_TIMEOUT_MS);
+      if (signal?.aborted) throw abortError2("RPC subagent start aborted");
+      const state = await raceWithAbort2(
+        this.requestData(
+          { type: "get_state" },
+          this.options.startupTimeoutMs ?? STARTUP_TIMEOUT_MS
+        ),
+        signal,
+        "RPC subagent readiness aborted"
+      );
+      return {
+        state,
+        stderr: this.stderr,
+        malformedLines: this.malformedLines,
+        oversizedLines: this.oversizedLines
+      };
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  async prompt(message, timeoutMs) {
+    await this.request({ type: "prompt", message }, timeoutMs);
+  }
+  async steer(message, timeoutMs) {
+    await this.request({ type: "steer", message }, timeoutMs);
+  }
+  async abort() {
+    await this.request(
+      { type: "abort" },
+      this.options.abortTimeoutMs ?? Math.min(COMMAND_TIMEOUT_MS, ABORT_GRACE_MS)
+    );
+  }
+  async getState() {
+    return this.requestData({ type: "get_state" });
+  }
+  getStderr() {
+    return this.stderr;
+  }
+  async stop() {
+    if (this.closePromise) return this.closePromise;
+    const proc = this.process;
+    if (!proc) return;
+    if (this.processClosed) {
+      this.cleanupTermination?.();
+      this.cleanupTermination = void 0;
+      this.process = void 0;
+      this.rejectPending(this.closedError ?? new Error("RPC subagent process already exited"));
+      this.listeners.clear();
+      this.closeListeners.clear();
+      return;
+    }
+    this.closePromise = new Promise((resolve) => {
+      let settled = false;
+      let terminationDeadline;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        if (terminationDeadline) clearTimeout(terminationDeadline);
+        proc.off("close", finish);
+        this.cleanupTermination?.();
+        this.cleanupTermination = void 0;
+        resolve();
+      };
+      proc.once("close", finish);
+      try {
+        proc.stdin?.end();
+      } catch {
+      }
+      const graceMs = this.options.terminationGraceMs ?? ABORT_GRACE_MS;
+      this.cleanupTermination?.();
+      this.cleanupTermination = terminateProcess(proc, graceMs);
+      terminationDeadline = setTimeout(() => {
+        proc.stdin?.destroy();
+        proc.stdout?.destroy();
+        proc.stderr?.destroy();
+        finish();
+      }, graceMs + 1e3);
+    });
+    await this.closePromise;
+    this.process = void 0;
+    this.rejectPending(new Error("RPC subagent client stopped"));
+    this.listeners.clear();
+    this.closeListeners.clear();
+  }
+  async requestData(command, timeoutMs = this.options.commandTimeoutMs ?? COMMAND_TIMEOUT_MS) {
+    const response = await this.request(command, timeoutMs);
+    return response.data;
+  }
+  request(command, timeoutMs = this.options.commandTimeoutMs ?? COMMAND_TIMEOUT_MS) {
+    const proc = this.process;
+    if (!proc?.stdin || proc.stdin.destroyed || !proc.stdin.writable) {
+      return Promise.reject(this.closedError ?? new Error("RPC subagent stdin is unavailable"));
+    }
+    const id = `psa_${++this.nextRequestId}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(rpcTimeoutError(`RPC ${command.type} response timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      timer.unref();
+      this.pending.set(id, { command: command.type, resolve, reject, timer });
+      try {
+        proc.stdin?.write(`${JSON.stringify({ ...command, id })}
+`, (error) => {
+          if (!error) return;
+          this.fail(errorMessage("RPC stdin write failed", error));
+        });
+      } catch (error) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    }).then((response) => {
+      if (!response.success) throw new Error(response.error || `RPC ${command.type} failed`);
+      return response;
+    });
+  }
+  handleValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return;
+    const event = value;
+    if (event.type === "response" && typeof event.id === "string") {
+      const pending = this.pending.get(event.id);
+      if (!pending) return;
+      if (typeof event.command !== "string" || event.command !== pending.command) {
+        this.fail(
+          new Error(`RPC response command mismatch for ${event.id}: expected ${pending.command}`)
+        );
+        return;
+      }
+      this.pending.delete(event.id);
+      clearTimeout(pending.timer);
+      pending.resolve(event);
+      return;
+    }
+    if (event.type === "extension_ui_request" && typeof event.id === "string") {
+      this.writeFireAndForget({
+        type: "extension_ui_response",
+        id: event.id,
+        cancelled: true
+      });
+    }
+    for (const listener of this.listeners) listener(value);
+  }
+  writeFireAndForget(value) {
+    try {
+      this.process?.stdin?.write(`${JSON.stringify(value)}
+`);
+    } catch {
+    }
+  }
+  fail(error) {
+    if (this.closedError) return;
+    this.closedError = error;
+    this.rejectPending(error);
+    for (const listener of this.closeListeners) listener(error);
+    if (this.process && !this.closePromise) {
+      this.cleanupTermination = terminateProcess(
+        this.process,
+        this.options.terminationGraceMs ?? ABORT_GRACE_MS
+      );
+    }
+  }
+  rejectPending(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+};
+var RpcTransport = class {
+  constructor(options) {
+    this.options = options;
+    this.createClient = options.createClient ?? ((clientOptions) => new RpcProtocolClient(clientOptions));
+  }
+  options;
+  kind = "rpc";
+  children = /* @__PURE__ */ new Map();
+  createClient;
+  async runTurn(agent, task, signal, onProgress) {
+    const startedAt = Date.now();
+    let telemetry = {
+      transport: "rpc",
+      protocol: PI_SUBAGENTS_RPC_PROTOCOL,
+      phase: "starting",
+      updatedAt: startedAt,
+      timing: { startedAt, transportStartedAt: startedAt }
+    };
+    const publish = (patch) => {
+      telemetry = {
+        ...telemetry,
+        ...patch,
+        timing: { ...telemetry.timing, ...patch.timing },
+        usage: patch.usage ? { ...patch.usage } : telemetry.usage,
+        updatedAt: Date.now()
+      };
+      onProgress?.({
+        ...telemetry,
+        timing: { ...telemetry.timing },
+        usage: telemetry.usage ? { ...telemetry.usage } : void 0
+      });
+    };
+    publish({});
+    if (signal.aborted) return interruptedRpcOutcome("", telemetry, "starting");
+    const settings = this.options.getSettings ? this.options.getSettings() : readSubagentSettings();
+    const agentConfig = discoverAgents(agent.cwd, agent.agentScope ?? "user", settings).agents.find(
+      (candidate) => candidate.name === agent.agent
+    );
+    if (!agentConfig) {
+      publish({ phase: "failed", failurePhase: "starting" });
+      return { output: "", exitCode: 1, error: `Unknown subagent: ${agent.agent}`, telemetry };
+    }
+    const effectiveAgentConfig = {
+      ...agentConfig,
+      tools: agent.executionPlan?.effectiveTools ?? agentConfig.tools
+    };
+    try {
+      validateRpcTools(effectiveAgentConfig.tools);
+    } catch (error) {
+      publish({ phase: "failed", failurePhase: "starting" });
+      return { output: "", exitCode: 1, error: boundedError2(error), telemetry };
+    }
+    let child;
+    try {
+      child = await this.getOrCreate(agent, effectiveAgentConfig, signal);
+    } catch (error) {
+      publish({ phase: signal.aborted ? "interrupted" : "failed", failurePhase: "starting" });
+      return {
+        output: "",
+        exitCode: signal.aborted ? 130 : 1,
+        aborted: signal.aborted,
+        error: boundedError2(error),
+        telemetry
+      };
+    }
+    const stateModel = modelIdentity(child.state.model);
+    publish({
+      phase: "ready",
+      provider: stateModel.provider,
+      model: stateModel.model,
+      thinkingLevel: normalizeThinking(child.state.thinkingLevel),
+      timing: { readyAt: Date.now() }
+    });
+    if (signal.aborted) {
+      await this.releaseById(agent.id).catch(() => void 0);
+      return interruptedRpcOutcome("", telemetry, "ready");
+    }
+    const timeoutMs = agent.currentTimeoutMs ?? agent.timeoutMs ?? agentConfig.timeoutMs ?? this.options.defaultTimeoutMs ?? resolveStatefulTurnTimeout(agentConfig);
+    const capture = createRpcTurnCapture();
+    let resolveBudget;
+    let resolvePreAcceptanceIdle;
+    const budgetExceeded = new Promise((resolve) => {
+      resolveBudget = resolve;
+    });
+    const preAcceptanceIdleExceeded = new Promise((resolve) => {
+      resolvePreAcceptanceIdle = resolve;
+    });
+    const budgetMonitor = new TurnBudgetMonitor({
+      idleTimeoutMs: agent.currentIdleTimeoutMs ?? agent.idleTimeoutMs,
+      maxTurns: agent.currentMaxTurns ?? agent.maxTurns,
+      maxToolCalls: agent.currentMaxToolCalls ?? agent.maxToolCalls,
+      onExceeded(stop) {
+        resolveBudget(stop);
+        if (stop.reason === "idle_timeout") resolvePreAcceptanceIdle(stop);
+      }
+    });
+    let settledResolve;
+    let settledReject;
+    const settled = new Promise((resolve, reject) => {
+      settledResolve = resolve;
+      settledReject = reject;
+    });
+    void settled.catch(() => void 0);
+    const unsubscribeEvent = child.client.onEvent((event) => {
+      captureRpcEvent(event, capture);
+      observeRpcBudgetEvent(event, budgetMonitor);
+      if (!capture.firstActivityAt && isActivityEvent(event)) {
+        capture.firstActivityAt = Date.now();
+        publish({ phase: "running", timing: { firstActivityAt: capture.firstActivityAt } });
+      }
+      const type = eventType2(event);
+      if (type === "auto_retry_start") publish({ phase: "retrying" });
+      if (type === "compaction_start" || type === "summarization_retry_attempt_start") {
+        publish({ phase: "compacting" });
+      }
+      if (type === "agent_settled") settledResolve();
+    });
+    const unsubscribeClose = child.client.onClose(settledReject);
+    const prompt = child.started ? buildCurrentTurnPrompt(agent, task) : buildStatefulTurnPrompt(agent, task).text;
+    let accepted = false;
+    let preAcceptanceStop;
+    const deadline = Date.now() + timeoutMs;
+    try {
+      await Promise.race([
+        raceWithAbort2(
+          child.client.prompt(prompt, remainingMs2(deadline)),
+          signal,
+          "RPC subagent prompt acceptance aborted"
+        ),
+        preAcceptanceIdleExceeded.then((stop) => {
+          preAcceptanceStop = stop;
+          throw new Error(formatTurnTerminationMessage(stop.reason, stop.limit, "RPC subagent"));
+        })
+      ]);
+      accepted = true;
+      child.started = true;
+      publish({ phase: "accepted", timing: { promptAcceptedAt: Date.now() } });
+      const settlement = await Promise.race([
+        waitForTurnSettlement(settled, signal, remainingMs2(deadline)).then((kind) => ({
+          kind
+        })),
+        budgetExceeded.then((stop) => ({ kind: "limit", stop }))
+      ]);
+      if (settlement.kind !== "settled") {
+        const [, stopped] = await Promise.all([
+          child.client.abort().catch(() => void 0),
+          settlesWithin2(settled, this.options.abortGraceMs ?? ABORT_GRACE_MS)
+        ]);
+        const partial = truncateUtf8(capture.output || capture.partial, DEFAULT_MAX_OUTPUT_BYTES);
+        const stop = settlement.kind === "limit" ? settlement.stop : { reason: "work_timeout", limit: timeoutMs };
+        const explicitAbort = settlement.kind === "aborted" || signal.aborted;
+        const termination = explicitAbort ? void 0 : {
+          version: TURN_TERMINATION_VERSION,
+          reason: stop.reason,
+          limit: stop.limit,
+          checkpoint: capture.journal.checkpoint(task, partial.text),
+          finalization: {
+            attempted: false,
+            status: "skipped",
+            durationMs: 0
+          }
+        };
+        if (explicitAbort || !stopped) {
+          if (!stopped) await this.releaseById(agent.id);
+          publish({
+            phase: explicitAbort ? "interrupted" : "failed",
+            failurePhase: "running",
+            timing: { settledAt: Date.now() },
+            usage: capture.usage
+          });
+          const checkpointOutput2 = termination ? formatTimeoutCheckpoint(termination.checkpoint) : partial.text;
+          return {
+            output: partial.text || checkpointOutput2,
+            exitCode: explicitAbort ? 130 : 124,
+            aborted: explicitAbort,
+            truncated: partial.truncated || agent.contextTruncated,
+            error: explicitAbort ? "RPC subagent was aborted" : `${formatTurnTerminationMessage(stop.reason, stop.limit, "RPC subagent")}; abort did not settle`,
+            policy: rpcPolicy(agentConfig, agent),
+            termination,
+            telemetry
+          };
+        }
+        publish({ phase: "finalizing", failurePhase: "running" });
+        const finalizationStartedAt = Date.now();
+        const summary = await finalizeTimedOutRpcTurn({
+          client: child.client,
+          task,
+          partialOutput: partial.text,
+          checkpoint: termination?.checkpoint,
+          terminationReason: stop.reason,
+          resultFormat: agent.resultFormat,
+          signal,
+          workTimeoutMs: timeoutMs,
+          finalizationTimeoutMs: this.options.timeoutFinalizationMs,
+          abortGraceMs: this.options.abortGraceMs ?? ABORT_GRACE_MS,
+          resetCapture() {
+            capture.output = "";
+            capture.partial = "";
+            capture.stopReason = void 0;
+            capture.error = void 0;
+          },
+          getCapture: () => capture,
+          release: () => this.releaseById(agent.id)
+        });
+        if (termination) {
+          termination.finalization = {
+            attempted: true,
+            status: summary.status,
+            durationMs: Date.now() - finalizationStartedAt,
+            error: summary.error
+          };
+        }
+        publish({
+          phase: "failed",
+          failurePhase: "running",
+          timing: { settledAt: Date.now() },
+          usage: capture.usage
+        });
+        const checkpointOutput = termination ? formatTimeoutCheckpoint(termination.checkpoint) : "";
+        return {
+          output: summary.error ? partial.text || checkpointOutput : summary.output,
+          exitCode: 124,
+          truncated: partial.truncated || summary.truncated || agent.contextTruncated,
+          error: [
+            formatTurnTerminationMessage(stop.reason, stop.limit, "RPC subagent"),
+            summary.error
+          ].filter(Boolean).join("; "),
+          policy: rpcPolicy(agentConfig, agent),
+          termination,
+          telemetry
+        };
+      }
+      const output = truncateUtf8(capture.output || capture.partial, DEFAULT_MAX_OUTPUT_BYTES);
+      const failed = capture.stopReason === "error" || !output.text.trim();
+      publish({
+        phase: failed ? "failed" : "settled",
+        failurePhase: failed ? "running" : void 0,
+        timing: { settledAt: Date.now() },
+        provider: capture.provider ?? telemetry.provider,
+        model: capture.model ?? telemetry.model,
+        usage: capture.usage
+      });
+      return {
+        output: output.text,
+        exitCode: failed ? 1 : 0,
+        truncated: output.truncated || agent.contextTruncated,
+        error: failed ? capture.error || "RPC subagent completed without final text" : void 0,
+        policy: rpcPolicy(agentConfig, agent),
+        telemetry
+      };
+    } catch (error) {
+      await this.releaseById(agent.id).catch(() => void 0);
+      const timedOut = isTimeoutError(error);
+      const stop = preAcceptanceStop ?? (timedOut ? { reason: "work_timeout", limit: timeoutMs } : void 0);
+      const partial = truncateUtf8(capture.output || capture.partial, DEFAULT_MAX_OUTPUT_BYTES);
+      const termination = stop && !signal.aborted ? {
+        version: TURN_TERMINATION_VERSION,
+        reason: stop.reason,
+        limit: stop.limit,
+        checkpoint: capture.journal.checkpoint(task, partial.text),
+        finalization: {
+          attempted: false,
+          status: "skipped",
+          durationMs: 0
+        }
+      } : void 0;
+      publish({
+        phase: signal.aborted ? "interrupted" : "failed",
+        failurePhase: accepted ? "running" : "ready",
+        timing: { settledAt: Date.now() }
+      });
+      return {
+        output: partial.text || (termination ? formatTimeoutCheckpoint(termination.checkpoint) : ""),
+        exitCode: signal.aborted ? 130 : stop ? 124 : 1,
+        aborted: signal.aborted,
+        error: stop ? formatTurnTerminationMessage(stop.reason, stop.limit, "RPC subagent") : boundedError2(error),
+        policy: rpcPolicy(agentConfig, agent),
+        termination,
+        telemetry
+      };
+    } finally {
+      budgetMonitor.dispose();
+      unsubscribeEvent();
+      unsubscribeClose();
+    }
+  }
+  async deliverMessage(agent, message) {
+    const child = this.children.get(agent.id);
+    if (!child) return false;
+    await child.client.steer(formatPeerMessage(message));
+    return true;
+  }
+  async release(agent) {
+    await this.releaseById(agent.id);
+  }
+  async shutdown() {
+    const results = await Promise.allSettled(
+      [...this.children.keys()].map((agentId) => this.releaseById(agentId))
+    );
+    const failures = results.flatMap(
+      (result) => result.status === "rejected" ? [result.reason] : []
+    );
+    if (failures.length > 0) {
+      throw new AggregateError(failures, `Failed to release ${failures.length} RPC subagent(s)`);
+    }
+  }
+  async getOrCreate(agent, agentConfig, signal) {
+    const existing = this.children.get(agent.id);
+    if (existing) return existing;
+    const hasRolePrompt = agentConfig.systemPrompt.trim().length > 0;
+    const resources = hasRolePrompt ? await (this.options.resolvePromptResources ?? resolvePiPromptResources)(
+      agent.cwd,
+      agent.target?.trust.projectTrusted ?? false
+    ) : { appendSystemPromptPaths: [] };
+    if (signal.aborted) throw abortError2("RPC subagent start aborted");
+    const temporaryPrompt = hasRolePrompt ? await writeRolePrompt(agentConfig.name, agentConfig.systemPrompt) : void 0;
+    if (signal.aborted) {
+      cleanupRolePrompt(temporaryPrompt);
+      throw abortError2("RPC subagent start aborted");
+    }
+    let client;
+    try {
+      const credentials = this.options.peerRuntime ? await this.options.peerRuntime.issueCredentials(
+        agent.id,
+        agent.currentTurnGeneration ?? agent.turnGeneration ?? 1
+      ) : void 0;
+      if (signal.aborted) throw abortError2("RPC subagent start aborted");
+      client = this.createClient({
+        cwd: agent.cwd,
+        abortTimeoutMs: this.options.abortGraceMs ?? ABORT_GRACE_MS,
+        terminationGraceMs: this.options.abortGraceMs ?? ABORT_GRACE_MS,
+        args: buildRpcArgs(
+          agent,
+          agentConfig,
+          this.options.getParentRuntime(),
+          temporaryPrompt?.filePath,
+          resources.appendSystemPromptPaths,
+          credentials !== void 0
+        ),
+        env: {
+          PI_SUBAGENT_DEPTH: String(
+            (Number.parseInt(process.env.PI_SUBAGENT_DEPTH ?? "0", 10) || 0) + 1
+          ),
+          PI_SUBAGENT_RPC_PROTOCOL: PI_SUBAGENTS_RPC_PROTOCOL,
+          ...credentials ? peerBridgeEnvironment(credentials) : {}
+        }
+      });
+      const snapshot = await client.start(signal);
+      if (signal.aborted) throw abortError2("RPC subagent start aborted");
+      const record = {
+        client,
+        state: snapshot.state,
+        started: false,
+        temporaryPrompt
+      };
+      this.children.set(agent.id, record);
+      return record;
+    } catch (error) {
+      await client?.stop().catch(() => void 0);
+      this.options.peerRuntime?.revoke(agent.id);
+      cleanupRolePrompt(temporaryPrompt);
+      throw error;
+    }
+  }
+  async releaseById(agentId) {
+    const child = this.children.get(agentId);
+    if (!child) return;
+    this.children.delete(agentId);
+    this.options.peerRuntime?.revoke(agentId);
+    try {
+      await child.client.abort().catch(() => void 0);
+      await child.client.stop();
+    } finally {
+      cleanupRolePrompt(child.temporaryPrompt);
+    }
+  }
+};
+function validateRpcTools(tools) {
+  const validated = validateInProcessTools(tools);
+  if (validated?.some((tool) => !BUILT_IN_TOOL_NAMES.has(tool))) {
+    throw new Error("RPC subagents support only built-in Pi tools in pi-subagents:v1");
+  }
+  return validated;
+}
+function buildRpcArgs(agent, agentConfig, parentRuntime, rolePromptPath, appendSystemPromptPaths = [], peerBridge = false) {
+  const args = ["--mode", "rpc", "--no-session", "--no-extensions"];
+  if (peerBridge) args.push("-e", childPeerBridgePath());
+  const model = agentConfig.model ?? (parentRuntime.model ? `${parentRuntime.model.provider}/${parentRuntime.model.id}` : void 0);
+  if (model) args.push("--model", model);
+  const modelSelectsThinking = agentConfig.model ? /:(?:off|minimal|low|medium|high|xhigh|max)$/u.test(agentConfig.model.trim()) : false;
+  const thinking = agent.thinkingLevel ?? agentConfig.thinkingLevel ?? (modelSelectsThinking ? void 0 : parentRuntime.thinkingLevel);
+  if (thinking) args.push("--thinking", thinking);
+  if (agent.target?.trust.projectTrusted ?? false) args.push("--approve");
+  else args.push("--no-approve");
+  if (Array.isArray(agentConfig.tools)) {
+    const tools = [...agentConfig.tools, ...peerBridge ? CHILD_PEER_TOOL_NAMES : []];
+    if (tools.length > 0) args.push("--tools", [...new Set(tools)].join(","));
+    else args.push("--no-tools");
+  }
+  for (const promptPath of appendSystemPromptPaths) {
+    args.push("--append-system-prompt", promptPath);
+  }
+  if (rolePromptPath) args.push("--append-system-prompt", rolePromptPath);
+  return args;
+}
+function eventType2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const type = value.type;
+  return typeof type === "string" ? type : void 0;
+}
+function isActivityEvent(value) {
+  return [
+    "message_start",
+    "message_update",
+    "message_end",
+    "tool_execution_start",
+    "tool_execution_update",
+    "auto_retry_start",
+    "compaction_start"
+  ].includes(eventType2(value) ?? "");
+}
+async function writeRolePrompt(agentName, prompt) {
+  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-subagent-rpc-"));
+  const safeName = agentName.replace(/[^\w.-]+/gu, "_");
+  const filePath = path.join(dir, `prompt-${safeName}.md`);
+  await fs.promises.writeFile(filePath, prompt, {
+    encoding: "utf8",
+    mode: 384
+  });
+  return { dir, filePath };
+}
+function cleanupRolePrompt(value) {
+  if (!value) return;
+  try {
+    fs.rmSync(value.dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function waitForSpawn(proc, signal, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      proc.off("spawn", onSpawn);
+      proc.off("error", onError);
+      signal?.removeEventListener("abort", onAbort);
+      if (error) reject(error);
+      else resolve();
+    };
+    const onSpawn = () => finish();
+    const onError = (error) => finish(error);
+    const onAbort = () => finish(abortError2("RPC subagent start aborted"));
+    const timer = setTimeout(
+      () => finish(new Error(`RPC subagent start timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    timer.unref();
+    proc.once("spawn", onSpawn);
+    proc.once("error", onError);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+  });
+}
+async function raceWithAbort2(promise, signal, message) {
+  if (!signal) return promise;
+  if (signal.aborted) throw abortError2(message);
+  let onAbort;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        onAbort = () => reject(abortError2(message));
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) onAbort();
+      })
+    ]);
+  } finally {
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+function waitForTurnSettlement(settled, signal, timeoutMs) {
+  if (signal.aborted) return Promise.resolve("aborted");
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const finish = (value, error) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onAbort = () => finish("aborted");
+    const timer = setTimeout(() => finish("timeout"), timeoutMs);
+    timer.unref();
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    settled.then(
+      () => finish("settled"),
+      (error) => finish("settled", error)
+    );
+  });
+}
+async function settlesWithin2(settled, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      settled.then(
+        () => true,
+        () => true
+      ),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function remainingMs2(deadline) {
+  return Math.max(1, deadline - Date.now());
+}
+function rpcTimeoutError(message) {
+  const error = new Error(message);
+  error.name = "RpcTimeoutError";
+  return error;
+}
+function isTimeoutError(error) {
+  return error instanceof Error && error.name === "RpcTimeoutError";
+}
+function abortError2(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+function errorMessage(prefix, error) {
+  return new Error(`${prefix}: ${error.message}`);
+}
+export {
+  RpcProtocolClient,
+  RpcTransport,
+  buildRpcArgs,
+  validateRpcTools
+};
+//# sourceMappingURL=rpc-transport-Y6LA5BOP.ts.map