@narumitw/pi-subagents 2.1.4 → 3.0.0

package/dist/chunks/chunk-UKTWUQRM.js

@@ -0,0 +1,667 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated entries use .ts extensions for Pi's Jiti loader.
+
+// src/message-broker.ts
+import { randomBytes, randomUUID } from "node:crypto";
+import net from "node:net";
+var BROKER_HOST = "127.0.0.1";
+var MAX_MESSAGE_BYTES = 48 * 1024;
+var MAX_MESSAGE_LINES = 1992;
+var MAX_FRAME_BYTES = 384 * 1024;
+var MAX_ERROR_BYTES = 8 * 1024;
+var MAX_OUTSTANDING_REQUESTS = 4;
+var MAX_IDENTIFIER_LENGTH = 128;
+var MAX_CONNECTIONS = 32;
+var REQUEST_FRAME_TIMEOUT_MS = 2e3;
+var MAX_TIMEOUT_MS = 2147483647;
+var MAX_RETAINED_CONSUMED_REQUESTS = 4;
+var CHILD_WAIT_INTERRUPTED_ERROR = "Subagent wait was interrupted by an incoming main-agent request. The original request remains active.";
+var MessageBroker = class {
+  constructor(options) {
+    this.options = options;
+    this.createServer = options.createServer ?? ((listener) => net.createServer(listener));
+    this.now = options.now ?? Date.now;
+    this.requestFrameTimeoutMs = options.requestFrameTimeoutMs ?? REQUEST_FRAME_TIMEOUT_MS;
+    if (!Number.isFinite(this.requestFrameTimeoutMs) || this.requestFrameTimeoutMs <= 0) {
+      throw new Error("Subagent broker frame timeout must be positive.");
+    }
+  }
+  options;
+  server;
+  starting;
+  address;
+  failure;
+  generation = 0;
+  sockets = /* @__PURE__ */ new Set();
+  jobsByToken = /* @__PURE__ */ new Map();
+  tokenByJob = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  inboundMessageListeners = /* @__PURE__ */ new Set();
+  pendingInboundResponse = false;
+  createServer;
+  now;
+  requestFrameTimeoutMs;
+  async start() {
+    if (this.server && this.address && !this.failure) return;
+    if (this.starting) return this.starting;
+    const ownerGeneration = ++this.generation;
+    this.failure = void 0;
+    this.starting = new Promise((resolve, reject) => {
+      const server = this.createServer((socket) => this.accept(socket));
+      server.maxConnections = MAX_CONNECTIONS;
+      const onStartError = (error) => {
+        server.close(() => void 0);
+        reject(error);
+      };
+      server.once("error", onStartError);
+      server.listen({ host: BROKER_HOST, port: 0 }, () => {
+        server.off("error", onStartError);
+        if (ownerGeneration !== this.generation) {
+          server.close(() => void 0);
+          reject(new Error("Subagent message broker start was superseded."));
+          return;
+        }
+        const address = server.address();
+        if (!isLoopbackAddress(address)) {
+          server.close(() => void 0);
+          reject(new Error("Subagent message broker did not bind to loopback."));
+          return;
+        }
+        this.server = server;
+        this.address = { host: BROKER_HOST, port: address.port };
+        server.on("error", (error) => this.fail(error));
+        server.unref();
+        resolve();
+      });
+    }).catch((error) => {
+      const message = truncateError(error instanceof Error ? error.message : String(error));
+      this.failure = message;
+      throw new Error(`Subagent message broker failed to start: ${message}`);
+    }).finally(() => {
+      this.starting = void 0;
+    });
+    return this.starting;
+  }
+  assertReady() {
+    if (this.server && this.address && !this.failure) return;
+    throw new Error(
+      this.failure ? `Subagent messaging is unavailable: ${this.failure}` : "Subagent messaging is unavailable because the session broker is not ready."
+    );
+  }
+  issueCredentials(input) {
+    this.assertReady();
+    if (this.tokenByJob.has(input.jobId)) {
+      throw new Error(`Subagent messaging credentials already exist for ${input.jobId}.`);
+    }
+    const token = randomBytes(32).toString("hex");
+    const record = { ...input, token };
+    this.jobsByToken.set(token, record);
+    this.tokenByJob.set(input.jobId, token);
+    return { host: BROKER_HOST, port: this.address?.port ?? 0, token };
+  }
+  createMainRequest(jobId, message) {
+    this.assertReady();
+    const job = this.requireJob(jobId);
+    return this.createRequest(job, "main", message);
+  }
+  replyFromMain(requestId, message) {
+    this.assertReady();
+    return this.acceptResponse("main", void 0, requestId, message);
+  }
+  rollbackMainRequest(requestId) {
+    const request = this.requests.get(requestId);
+    if (request?.origin === "main" && request.response === void 0) {
+      this.clearWaiter(request);
+      this.requests.delete(requestId);
+    }
+  }
+  revokeJob(jobId, reason = "Subagent job is no longer active.") {
+    const token = this.tokenByJob.get(jobId);
+    if (token) {
+      this.tokenByJob.delete(jobId);
+      this.jobsByToken.delete(token);
+    }
+    for (const request of [...this.requests.values()]) {
+      if (request.jobId !== jobId) continue;
+      if (request.waiter) this.respondError(request.waiter.socket, reason);
+      this.clearWaiter(request);
+      this.requests.delete(request.requestId);
+    }
+  }
+  hasPendingMainRequest() {
+    return [...this.requests.values()].some(
+      (request) => request.origin === "child" && request.response === void 0
+    );
+  }
+  takePendingInboundResponse() {
+    const pending = this.pendingInboundResponse;
+    this.pendingInboundResponse = false;
+    return pending;
+  }
+  markMainRequestQueued(requestId) {
+    const request = this.requests.get(requestId);
+    if (request?.origin !== "main") {
+      throw new Error("Unknown or expired main-agent subagent request.");
+    }
+    request.deliveryQueued = true;
+    return request.response === void 0;
+  }
+  interruptChildWaits(jobId) {
+    let interrupted = 0;
+    for (const request of this.requests.values()) {
+      if (request.jobId !== jobId || request.origin !== "child" || !request.waiter) continue;
+      const socket = request.waiter.socket;
+      this.clearWaiter(request);
+      this.respondError(socket, CHILD_WAIT_INTERRUPTED_ERROR);
+      interrupted++;
+    }
+    return interrupted;
+  }
+  subscribeInboundMessage(listener) {
+    this.inboundMessageListeners.add(listener);
+    if (this.hasPendingMainRequest()) listener();
+    return () => this.inboundMessageListeners.delete(listener);
+  }
+  async shutdown() {
+    ++this.generation;
+    const starting = this.starting;
+    if (starting) await starting.catch(() => void 0);
+    for (const jobId of [...this.tokenByJob.keys()]) {
+      this.revokeJob(jobId, "Subagent session shut down.");
+    }
+    this.requests.clear();
+    this.inboundMessageListeners.clear();
+    this.pendingInboundResponse = false;
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    const server = this.server;
+    this.server = void 0;
+    this.address = void 0;
+    this.failure = void 0;
+    if (!server?.listening) return;
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+  requireJob(jobId) {
+    const token = this.tokenByJob.get(jobId);
+    const job = token ? this.jobsByToken.get(token) : void 0;
+    if (!job) throw new Error("Unknown or inactive subagent job.");
+    return job;
+  }
+  hasQueuedRequestForChild(jobId) {
+    return [...this.requests.values()].some(
+      (request) => request.jobId === jobId && request.origin === "main" && request.deliveryQueued === true && request.response === void 0
+    );
+  }
+  createRequest(job, origin, message) {
+    validateMessage(message, "Subagent request");
+    const outstanding = [...this.requests.values()].filter(
+      (request2) => request2.jobId === job.jobId && request2.consumedAt === void 0
+    ).length;
+    if (outstanding >= MAX_OUTSTANDING_REQUESTS) {
+      throw new Error(
+        `Subagent job may have at most ${MAX_OUTSTANDING_REQUESTS} outstanding requests.`
+      );
+    }
+    const request = {
+      requestId: `req_${randomUUID()}`,
+      jobId: job.jobId,
+      generation: job.generation,
+      origin,
+      expectedResponder: origin === "main" ? "child" : "main",
+      message,
+      createdAt: this.now()
+    };
+    this.requests.set(request.requestId, request);
+    if (origin === "child") {
+      try {
+        this.deliverInbound({
+          kind: "request",
+          requestId: request.requestId,
+          jobId: request.jobId,
+          message: request.message
+        });
+      } catch (error) {
+        this.requests.delete(request.requestId);
+        throw error;
+      }
+    }
+    return { requestId: request.requestId, accepted: true, duplicate: false };
+  }
+  acceptResponse(responder, job, requestId, message) {
+    validateRequestId(requestId);
+    validateMessage(message, "Subagent response");
+    const request = this.requests.get(requestId);
+    if (!request || request.expectedResponder !== responder || job && (request.jobId !== job.jobId || request.generation !== job.generation)) {
+      throw new Error("Unknown, expired, or unauthorized subagent request.");
+    }
+    if (request.response !== void 0) {
+      return { requestId, accepted: false, duplicate: true };
+    }
+    request.response = message;
+    if (responder === "child") {
+      try {
+        this.deliverInbound({
+          kind: "response",
+          requestId,
+          jobId: request.jobId,
+          message
+        });
+        this.markConsumed(request);
+      } catch (error) {
+        request.response = void 0;
+        throw error;
+      }
+    } else if (request.waiter) {
+      const socket = request.waiter.socket;
+      this.clearWaiter(request);
+      this.respond(socket, { ok: true, response: message }, () => this.markConsumed(request));
+    }
+    return { requestId, accepted: true, duplicate: false };
+  }
+  deliverInbound(message) {
+    this.options.onMessage(message);
+    if (message.kind === "response" && this.inboundMessageListeners.size === 0) {
+      this.pendingInboundResponse = true;
+    }
+    for (const listener of [...this.inboundMessageListeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  accept(socket) {
+    if (!this.server || this.failure || this.sockets.size >= MAX_CONNECTIONS) {
+      socket.destroy();
+      return;
+    }
+    this.sockets.add(socket);
+    socket.setNoDelay(true);
+    let frame = Buffer.alloc(0);
+    let handled = false;
+    const frameTimer = setTimeout(() => {
+      if (handled) return;
+      handled = true;
+      this.respondError(socket, "Subagent broker request frame timed out.");
+    }, this.requestFrameTimeoutMs);
+    frameTimer.unref();
+    const cleanup = () => {
+      clearTimeout(frameTimer);
+      this.sockets.delete(socket);
+      for (const request of this.requests.values()) {
+        if (request.waiter?.socket === socket) this.clearWaiter(request);
+      }
+    };
+    socket.on("data", (chunk) => {
+      if (handled) return;
+      frame = Buffer.concat([frame, chunk]);
+      if (frame.byteLength > MAX_FRAME_BYTES) {
+        handled = true;
+        clearTimeout(frameTimer);
+        this.respondError(socket, "Subagent broker request exceeded its size limit.");
+        return;
+      }
+      const newline = frame.indexOf(10);
+      if (newline < 0) return;
+      handled = true;
+      clearTimeout(frameTimer);
+      socket.removeAllListeners("data");
+      const trailing = frame.subarray(newline + 1).toString("utf8").trim();
+      if (trailing) {
+        this.respondError(socket, "Subagent broker accepts one request per connection.");
+        return;
+      }
+      this.handleFrame(socket, frame.subarray(0, newline).toString("utf8"));
+    });
+    socket.once("close", cleanup);
+    socket.once("error", cleanup);
+  }
+  handleFrame(socket, frame) {
+    let request;
+    try {
+      const parsed = JSON.parse(frame);
+      if (!isRecord(parsed)) throw new Error();
+      request = parsed;
+    } catch {
+      this.respondError(socket, "Malformed subagent broker request.");
+      return;
+    }
+    const job = typeof request.token === "string" ? this.jobsByToken.get(request.token) : void 0;
+    if (!job) {
+      this.respondError(socket, "Unauthenticated subagent broker request.");
+      return;
+    }
+    try {
+      if (request.type === "send") {
+        this.handleSend(socket, job, request);
+        return;
+      }
+      if (request.type === "wait") {
+        this.handleWait(socket, job, request);
+        return;
+      }
+      throw new Error("Unsupported subagent broker request.");
+    } catch (error) {
+      this.respondError(socket, error instanceof Error ? error.message : String(error));
+    }
+  }
+  handleSend(socket, job, request) {
+    if (typeof request.message !== "string") {
+      throw new Error("subagent_send requires a message string.");
+    }
+    const hasRecipient = typeof request.recipient === "string";
+    const hasRequestId = typeof request.requestId === "string";
+    if (hasRecipient === hasRequestId) {
+      throw new Error("subagent_send requires exactly one of recipient or requestId.");
+    }
+    const acknowledgement = hasRecipient ? request.recipient === "main" ? this.createRequest(job, "child", request.message) : (() => {
+      throw new Error('A subagent may send new requests only to recipient "main".');
+    })() : this.acceptResponse("child", job, request.requestId ?? "", request.message);
+    this.respond(socket, { ok: true, ...acknowledgement });
+  }
+  handleWait(socket, job, request) {
+    if (typeof request.requestId !== "string") {
+      throw new Error("Subagent wait requires a request ID.");
+    }
+    validateRequestId(request.requestId);
+    if (request.timeoutMs !== void 0) validateTimeout(request.timeoutMs);
+    const record = this.requests.get(request.requestId);
+    if (record?.origin !== "child" || record.jobId !== job.jobId || record.generation !== job.generation) {
+      throw new Error("Unknown or expired subagent request.");
+    }
+    if (record.consumedAt !== void 0 && record.response !== void 0) {
+      this.respond(socket, { ok: true, response: record.response });
+      return;
+    }
+    if (record.response !== void 0) {
+      this.respond(
+        socket,
+        { ok: true, response: record.response },
+        () => this.markConsumed(record)
+      );
+      return;
+    }
+    if (this.hasQueuedRequestForChild(job.jobId)) {
+      this.respondError(socket, CHILD_WAIT_INTERRUPTED_ERROR);
+      return;
+    }
+    if (record.waiter) {
+      throw new Error(`A wait is already active for subagent request ${request.requestId}.`);
+    }
+    const waiter = { socket };
+    record.waiter = waiter;
+    if (request.timeoutMs !== void 0) {
+      waiter.timer = setTimeout(() => {
+        if (record.waiter !== waiter) return;
+        this.clearWaiter(record);
+        this.respondError(socket, "Subagent response wait timed out.");
+      }, request.timeoutMs);
+      waiter.timer.unref();
+    }
+  }
+  markConsumed(request) {
+    if (this.requests.get(request.requestId) !== request || request.response === void 0) return;
+    request.consumedAt ??= this.now();
+    const consumed = [...this.requests.values()].filter(
+      (candidate) => candidate.jobId === request.jobId && candidate.consumedAt !== void 0
+    ).sort((left, right) => (left.consumedAt ?? 0) - (right.consumedAt ?? 0));
+    for (const expired of consumed.slice(
+      0,
+      Math.max(0, consumed.length - MAX_RETAINED_CONSUMED_REQUESTS)
+    )) {
+      this.requests.delete(expired.requestId);
+    }
+  }
+  clearWaiter(request) {
+    if (request.waiter?.timer) clearTimeout(request.waiter.timer);
+    request.waiter = void 0;
+  }
+  respondError(socket, error) {
+    this.respond(socket, { ok: false, error: truncateError(error) });
+  }
+  respond(socket, value, onFlushed) {
+    if (socket.destroyed) return;
+    let content = `${JSON.stringify(value)}
+`;
+    if (Buffer.byteLength(content, "utf8") > MAX_FRAME_BYTES) {
+      content = `${JSON.stringify({ ok: false, error: "Subagent broker response exceeded its size limit." })}
+`;
+    }
+    socket.end(content, onFlushed);
+  }
+  fail(error) {
+    this.failure = truncateError(error.message);
+    for (const jobId of [...this.tokenByJob.keys()]) {
+      this.revokeJob(jobId, "Subagent message broker failed.");
+    }
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    this.address = void 0;
+  }
+};
+function validateMessage(message, label) {
+  if (!message.trim()) throw new Error(`${label} is required.`);
+  if (message.includes("\0")) throw new Error(`${label} must not contain NUL bytes.`);
+  if (Buffer.byteLength(message, "utf8") > MAX_MESSAGE_BYTES) {
+    throw new Error(`${label} must be at most ${MAX_MESSAGE_BYTES} UTF-8 bytes.`);
+  }
+  if (lineCount(message) > MAX_MESSAGE_LINES) {
+    throw new Error(`${label} must contain at most ${MAX_MESSAGE_LINES} lines.`);
+  }
+}
+function sanitizeTerminalText(value) {
+  return [...value].filter((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (character === "\n" || character === "	") return true;
+    if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) return false;
+    return !(codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297);
+  }).join("");
+}
+function validateRequestId(requestId) {
+  if (requestId.length > MAX_IDENTIFIER_LENGTH || !/^req_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(requestId)) {
+    throw new Error("Invalid subagent request ID.");
+  }
+}
+function validateTimeout(timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMEOUT_MS) {
+    throw new Error("Subagent wait timeout is outside the supported range.");
+  }
+}
+function lineCount(value) {
+  let count = 1;
+  for (const character of value) if (character === "\n") count++;
+  return count;
+}
+function truncateError(error) {
+  const bytes = Buffer.from(error, "utf8");
+  if (bytes.length <= MAX_ERROR_BYTES) return error;
+  return `${bytes.subarray(0, Math.max(0, MAX_ERROR_BYTES - 18)).toString("utf8").replace(/�+$/gu, "")}
+\u2026 [truncated]`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLoopbackAddress(address) {
+  return Boolean(address && typeof address !== "string" && address.address === BROKER_HOST);
+}
+
+// src/broker-credentials.ts
+import * as fs from "node:fs";
+var BROKER_CREDENTIAL_FD = 3;
+var BROKER_CREDENTIAL_FD_ENV = "PI_SUBAGENT_BROKER_FD";
+var MAX_CREDENTIAL_BYTES = 1024;
+function brokerCredentialEnvironment() {
+  return { [BROKER_CREDENTIAL_FD_ENV]: String(BROKER_CREDENTIAL_FD) };
+}
+function serializeBrokerCredentials(credentials) {
+  return JSON.stringify(credentials);
+}
+function captureBrokerCredentials(readCredentials = readCredentialPipe) {
+  const descriptor = process.env[BROKER_CREDENTIAL_FD_ENV];
+  delete process.env[BROKER_CREDENTIAL_FD_ENV];
+  if (descriptor === void 0) return void 0;
+  if (descriptor !== String(BROKER_CREDENTIAL_FD)) {
+    throw new Error("Invalid pi-subagents broker credential descriptor.");
+  }
+  let serialized;
+  try {
+    serialized = readCredentials();
+  } catch {
+    throw new Error("Unable to read pi-subagents broker credentials.");
+  }
+  if (Buffer.byteLength(serialized, "utf8") > MAX_CREDENTIAL_BYTES) {
+    throw new Error("Invalid pi-subagents broker credentials.");
+  }
+  let value;
+  try {
+    value = JSON.parse(serialized);
+  } catch {
+    throw new Error("Invalid pi-subagents broker credentials.");
+  }
+  if (!isBrokerCredentials(value)) {
+    throw new Error("Invalid pi-subagents broker credentials.");
+  }
+  return value;
+}
+function readCredentialPipe() {
+  try {
+    return fs.readFileSync(BROKER_CREDENTIAL_FD, "utf8");
+  } finally {
+    try {
+      fs.closeSync(BROKER_CREDENTIAL_FD);
+    } catch {
+    }
+  }
+}
+function isBrokerCredentials(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return Object.keys(candidate).length === 3 && candidate.host === "127.0.0.1" && Number.isSafeInteger(candidate.port) && candidate.port >= 1 && candidate.port <= 65535 && typeof candidate.token === "string" && /^[a-f0-9]{64}$/u.test(candidate.token);
+}
+
+// src/child-communication-tools.ts
+import { Type } from "typebox";
+var CHILD_COMMUNICATION_TOOL_NAMES = ["subagent_send", "subagent_wait"];
+var MAX_TIMEOUT_MS2 = 2147483647;
+var MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS2 / 1e3;
+var SendParameters = Type.Object(
+  {
+    requestId: Type.Optional(
+      Type.String({
+        description: "Pending main-agent request to answer. Omit when starting a new request.",
+        minLength: 1,
+        maxLength: MAX_IDENTIFIER_LENGTH
+      })
+    ),
+    message: Type.String({
+      description: "Plain-text request or response. Maximum 48 KiB of UTF-8 text and 1,992 lines.",
+      minLength: 1,
+      maxLength: MAX_MESSAGE_BYTES
+    })
+  },
+  { additionalProperties: false }
+);
+var WaitParameters = Type.Object(
+  {
+    requestId: Type.String({
+      description: "Request ID returned by subagent_send.",
+      minLength: 1,
+      maxLength: MAX_IDENTIFIER_LENGTH
+    }),
+    timeout: Type.Optional(
+      Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })
+    )
+  },
+  { additionalProperties: false }
+);
+function createChildCommunicationExtension(client) {
+  return (pi) => {
+    pi.registerTool({
+      name: "subagent_send",
+      label: "Subagent \xB7 Send to Main",
+      description: "Use subagent_send to send one request to the main agent or answer one pending main-agent request. Omit requestId to start a request. Provide requestId to answer that request.",
+      promptSnippet: "Use subagent_send to send or answer one main-agent message",
+      parameters: SendParameters,
+      async execute(_toolCallId, params, signal) {
+        validateMessage(params.message, "Subagent message");
+        const requestId = optionalIdentifier(params.requestId, "requestId");
+        const acknowledgement = await client.send(
+          requestId === void 0 ? { recipient: "main", message: params.message } : { requestId, message: params.message },
+          signal
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(acknowledgement) }],
+          details: acknowledgement
+        };
+      }
+    });
+    pi.registerTool({
+      name: "subagent_wait",
+      label: "Subagent \xB7 Wait for Main Agent",
+      description: "Use subagent_wait with a request ID from subagent_send to wait for the main agent's plain-text response. A timeout, caller cancellation, or incoming main-agent request stops only this wait and does not cancel the original request. Retry the wait when its response is still needed.",
+      promptSnippet: "Use subagent_wait to receive a requested main-agent response",
+      parameters: WaitParameters,
+      prepareArguments: prepareWaitArguments,
+      async execute(_toolCallId, params, signal) {
+        const requestId = requiredIdentifier(params.requestId, "requestId");
+        const response = await client.wait(requestId, resolveTimeoutMs(params.timeout), signal);
+        return {
+          content: [{ type: "text", text: sanitizeTerminalText(response) }],
+          details: { requestId }
+        };
+      }
+    });
+  };
+}
+function resolveTimeoutMs(timeout) {
+  if (timeout === void 0) return void 0;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new Error("Invalid timeout: must be a finite number of seconds");
+  }
+  const timeoutMs = timeout * 1e3;
+  if (timeoutMs > MAX_TIMEOUT_MS2) {
+    throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+  }
+  return timeoutMs;
+}
+function prepareWaitArguments(args) {
+  if (!args || typeof args !== "object") return args;
+  if (!Object.hasOwn(args, "timeoutMs")) return args;
+  const record = args;
+  if (typeof record.timeoutMs !== "number") return record;
+  const { timeoutMs, ...prepared } = record;
+  if (prepared.timeout === void 0) {
+    return { ...prepared, timeout: timeoutMs / 1e3 };
+  }
+  return prepared;
+}
+function optionalIdentifier(value, field) {
+  return value === void 0 ? void 0 : requiredIdentifier(value, field);
+}
+function requiredIdentifier(value, field) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`Subagent ${field} is required.`);
+  const identifier = value.trim();
+  if (identifier.length > MAX_IDENTIFIER_LENGTH || [...identifier].some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+  })) {
+    throw new Error(`Subagent ${field} is invalid.`);
+  }
+  return identifier;
+}
+
+export {
+  MAX_MESSAGE_BYTES,
+  MAX_FRAME_BYTES,
+  MAX_IDENTIFIER_LENGTH,
+  MessageBroker,
+  validateMessage,
+  sanitizeTerminalText,
+  BROKER_CREDENTIAL_FD,
+  brokerCredentialEnvironment,
+  serializeBrokerCredentials,
+  captureBrokerCredentials,
+  CHILD_COMMUNICATION_TOOL_NAMES,
+  createChildCommunicationExtension
+};
+//# sourceMappingURL=chunk-UKTWUQRM.js.map