@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-3BJA27PY.js

@@ -0,0 +1,2321 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  createCallResult
+} from "./chunk-5QOSCSQB.js";
+import {
+  createRuntime
+} from "./chunk-NNOEGEUZ.js";
+
+// src/mcp-command-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function currentMcpCommandContext() {
+  return storage.getStore();
+}
+function runWithMcpCommandContext(context, task) {
+  return storage.run(context, task);
+}
+function installMcpCommandIoRouting() {
+  const stdoutWrite = process.stdout.write.bind(process.stdout);
+  const stderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk, ...args) => {
+    const target = currentMcpCommandContext()?.stdout;
+    return target ? target.write(chunk) : stdoutWrite(chunk, ...args);
+  });
+  process.stderr.write = ((chunk, ...args) => {
+    const target = currentMcpCommandContext()?.stderr;
+    return target ? target.write(chunk) : stderrWrite(chunk, ...args);
+  });
+  return () => {
+    process.stdout.write = stdoutWrite;
+    process.stderr.write = stderrWrite;
+  };
+}
+
+// src/mcp-daemon-protocol.ts
+var MCP_DAEMON_SOCKET_ENV = "PI_RECIPES_MCP_DAEMON_SOCKET";
+var MCP_DAEMON_TOKEN_ENV = "PI_RECIPES_MCP_DAEMON_TOKEN";
+var MCP_DAEMON_FINGERPRINT_ENV = "PI_RECIPES_MCP_DAEMON_FINGERPRINT";
+var MCP_DAEMON_PARENT_PID_ENV = "PI_RECIPES_MCP_DAEMON_PARENT_PID";
+var MCP_DAEMON_MAX_FRAME_BYTES = 10 * 1024 * 1024;
+function serializeMcpDaemonEnvelope(envelope, maxBytes = MCP_DAEMON_MAX_FRAME_BYTES) {
+  let estimatedBytes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const serialized = JSON.stringify(envelope, (key, value) => {
+    estimatedBytes += Buffer.byteLength(key, "utf8") + 4;
+    if (typeof value === "string") {
+      estimatedBytes += Buffer.byteLength(value, "utf8") + 2;
+    } else if (typeof value === "number" || typeof value === "boolean" || value === null) {
+      estimatedBytes += 16;
+    } else if (value && typeof value === "object") {
+      if (seen.has(value)) {
+        throw new Error("MCP daemon envelope contains a circular value.");
+      }
+      seen.add(value);
+    }
+    if (estimatedBytes > maxBytes) {
+      throw new Error("MCP daemon envelope exceeded the frame limit.");
+    }
+    return value;
+  });
+  if (Buffer.byteLength(serialized, "utf8") > maxBytes) {
+    throw new Error("MCP daemon envelope exceeded the frame limit.");
+  }
+  return `${serialized}
+`;
+}
+
+// src/mcp-cli-core.ts
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { stdin as input, stderr, stdout } from "node:process";
+import { isMainThread, Worker } from "node:worker_threads";
+
+// src/mcp-contract.ts
+var MAX_EXAMPLE_ARRAY_ITEMS = 3;
+var SAFE_CLI_KEY = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+var SAFE_SHELL_TOKEN = /^[A-Za-z0-9_./:@+-]+$/;
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function quoted(value) {
+  return JSON.stringify(value);
+}
+function renderSchema(value) {
+  const schema = record(value);
+  if (!schema || !Array.isArray(schema.allOf)) return schema;
+  const branches = schema.allOf.map(renderSchema).filter((branch) => Boolean(branch));
+  const baseProperties = record(schema.properties) ?? {};
+  const objectLike = branches.every(
+    (branch) => branch.type === "object" || Boolean(record(branch.properties))
+  );
+  if (!objectLike) return { ...schema, allOf: branches };
+  const properties = Object.assign(
+    {},
+    baseProperties,
+    ...branches.map((branch) => record(branch.properties) ?? {})
+  );
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : []
+  );
+  for (const branch of branches) {
+    if (!Array.isArray(branch.required)) continue;
+    for (const entry of branch.required) {
+      if (typeof entry === "string") required.add(entry);
+    }
+  }
+  const { allOf: _allOf, ...rest } = schema;
+  return {
+    ...rest,
+    type: "object",
+    properties,
+    ...required.size > 0 ? { required: [...required] } : {}
+  };
+}
+function constraintSuffix(schema) {
+  const constraints = [];
+  const minimum = number(schema.minimum);
+  const maximum = number(schema.maximum);
+  if (minimum !== void 0 || maximum !== void 0) {
+    constraints.push(`${minimum ?? ""}..${maximum ?? ""}`);
+  }
+  const minLength = number(schema.minLength);
+  const maxLength = number(schema.maxLength);
+  if (minLength !== void 0) constraints.push(`minLength=${minLength}`);
+  if (maxLength !== void 0) constraints.push(`maxLength=${maxLength}`);
+  const minItems = number(schema.minItems);
+  const maxItems = number(schema.maxItems);
+  if (minItems !== void 0) constraints.push(`minItems=${minItems}`);
+  if (maxItems !== void 0) constraints.push(`maxItems=${maxItems}`);
+  if (schema.default !== void 0) constraints.push(`default=${quoted(schema.default)}`);
+  return constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
+}
+function compactSchemaType(value) {
+  const schema = renderSchema(value);
+  if (!schema) return "unknown";
+  if (Array.isArray(schema.allOf)) {
+    return schema.allOf.map(compactSchemaType).join(" & ");
+  }
+  if (schema.const !== void 0) return quoted(schema.const);
+  if (Array.isArray(schema.enum)) return schema.enum.map(quoted).join(" | ");
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : void 0;
+  if (union) return union.map(compactSchemaType).join(" | ");
+  if (schema.type === "array") {
+    return `${compactSchemaType(schema.items)}[]${constraintSuffix(schema)}`;
+  }
+  if (schema.type === "object" || record(schema.properties)) {
+    const properties = record(schema.properties);
+    if (!properties || Object.keys(properties).length === 0) return "object";
+    const required = new Set(
+      Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : []
+    );
+    const fields = Object.entries(properties).map(
+      ([name, descriptor]) => `${name}${required.has(name) ? "" : "?"}: ${compactSchemaType(descriptor)}`
+    );
+    return `{${fields.join(", ")}}`;
+  }
+  const type = schema.type === "number" ? "number" : schema.type;
+  return `${typeof type === "string" ? type : "unknown"}${constraintSuffix(schema)}`;
+}
+function descriptionText(value, verbose) {
+  if (typeof value !== "string" || !value.trim()) return "";
+  const normalized = value.trim().replace(/\s+/g, " ");
+  if (verbose || normalized.length <= 160) return normalized;
+  return `${normalized.slice(0, 159).trimEnd()}\u2026`;
+}
+function hasLongDescription(value) {
+  if (Array.isArray(value)) return value.some(hasLongDescription);
+  const object = record(value);
+  if (!object) return false;
+  if (typeof object.description === "string" && object.description.trim().replace(/\s+/g, " ").length > 160) {
+    return true;
+  }
+  return Object.entries(object).some(
+    ([key, nested]) => key !== "description" && hasLongDescription(nested)
+  );
+}
+function schemaLines(value, indent, options = {}) {
+  const schema = renderSchema(value);
+  if (!schema) return [`${indent}unknown`];
+  const properties = record(schema.properties);
+  if (!properties) return [`${indent}${compactSchemaType(schema)}`];
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : []
+  );
+  const lines = [];
+  for (const [name, descriptorValue] of Object.entries(properties)) {
+    const descriptor = record(descriptorValue) ?? {};
+    const optional = required.has(name) ? "" : "?";
+    const compactDescription = descriptionText(
+      descriptor.description,
+      options.verboseDescriptions === true
+    );
+    const description = compactDescription ? ` \u2014 ${compactDescription}` : "";
+    const nested = record(descriptor.properties);
+    if (nested) {
+      lines.push(`${indent}${name}${optional}: {`);
+      lines.push(...schemaLines(descriptor, `${indent}  `, options));
+      lines.push(`${indent}}${description}`);
+    } else {
+      lines.push(`${indent}${name}${optional}: ${compactSchemaType(descriptor)}${description}`);
+    }
+  }
+  return lines.length > 0 ? lines : [`${indent}{}`];
+}
+function schemaObject(value) {
+  return record(value);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function shellToken(value) {
+  return SAFE_SHELL_TOKEN.test(value) ? value : shellQuote(value);
+}
+function toolSelector(server, tool) {
+  return shellToken(`${server}.${tool}`);
+}
+function exampleValue(value, name) {
+  const schema = renderSchema(value) ?? {};
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : void 0;
+  if (union?.length) return exampleValue(union[0], name);
+  if (schema.const !== void 0) return schema.const;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  if (schema.type === "boolean") return true;
+  if (schema.type === "number" || schema.type === "integer") {
+    return number(schema.minimum) ?? 1;
+  }
+  if (schema.type === "array") {
+    const count = Math.min(
+      MAX_EXAMPLE_ARRAY_ITEMS,
+      Math.max(1, number(schema.minItems) ?? 1)
+    );
+    return Array.from({ length: count }, () => exampleValue(schema.items, "value"));
+  }
+  if (schema.type === "object" || record(schema.properties)) {
+    const properties = record(schema.properties) ?? {};
+    const required = Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+    return Object.fromEntries(
+      required.map((field) => [field, exampleValue(properties[field], field)])
+    );
+  }
+  return `<${name}>`;
+}
+function callValue(value, name) {
+  const example = exampleValue(value, name);
+  return typeof example === "string" ? shellQuote(example) : typeof example === "object" ? shellQuote(JSON.stringify(example)) : String(example);
+}
+function callExample(server, tool) {
+  const schema = renderSchema(tool.inputSchema);
+  const properties = record(schema?.properties) ?? {};
+  const required = Array.isArray(schema?.required) ? schema.required.filter((entry) => typeof entry === "string") : [];
+  if (required.some(
+    (name) => !SAFE_CLI_KEY.test(name) || Boolean(
+      structuredBranch(properties[name], "object") ?? structuredBranch(properties[name], "array")
+    )
+  )) {
+    const json = JSON.stringify(
+      Object.fromEntries(required.map((name) => [name, exampleValue(properties[name], name)]))
+    );
+    return `mcp call ${toolSelector(server, tool.name)} --json ${shellQuote(json)}`;
+  }
+  const args = required.map((name) => {
+    const descriptor = record(properties[name]) ?? {};
+    return `${name}=${callValue(descriptor, name)}`;
+  });
+  return `mcp call ${toolSelector(server, tool.name)}${args.length > 0 ? ` ${args.join(" ")}` : ""}`;
+}
+function structuredBranch(value, kind) {
+  const schema = renderSchema(value);
+  if (!schema) return void 0;
+  if (kind === "array" && schema.type === "array" || kind === "object" && (schema.type === "object" || record(schema.properties))) {
+    return schema;
+  }
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : [];
+  return union.map((branch) => structuredBranch(branch, kind)).find(Boolean);
+}
+function structuredCallExample(server, tool) {
+  const schema = renderSchema(tool.inputSchema);
+  const properties = record(schema?.properties) ?? {};
+  const required = new Set(
+    Array.isArray(schema?.required) ? schema.required.filter((entry) => typeof entry === "string") : []
+  );
+  const requiredValues = Object.fromEntries(
+    [...required].map((name) => [name, exampleValue(properties[name], name)])
+  );
+  for (const kind of ["object", "array"]) {
+    for (const [name, descriptor] of Object.entries(properties)) {
+      const branch = structuredBranch(descriptor, kind);
+      if (!branch) continue;
+      const json = JSON.stringify({
+        ...requiredValues,
+        ...!required.has(name) ? { [name]: exampleValue(branch, name) } : {}
+      });
+      return `mcp call ${toolSelector(server, tool.name)} --json ${shellQuote(json)}`;
+    }
+  }
+  return void 0;
+}
+function renderToolContract(server, tool, options = {}) {
+  const lines = [`${server}.${tool.name}`];
+  const description = descriptionText(
+    tool.description,
+    options.verboseDescriptions === true
+  );
+  if (description) {
+    lines.push(description);
+  }
+  if (!options.verboseDescriptions && (descriptionText(tool.description, true).length > 160 || hasLongDescription(tool.inputSchema) || hasLongDescription(tool.outputSchema))) {
+    lines.push("Descriptions shortened; use --verbose for full text.");
+  }
+  lines.push("", "input", ...schemaLines(tool.inputSchema, "  ", options));
+  lines.push(
+    "",
+    "output",
+    ...schemaObject(tool.outputSchema) ? schemaLines(tool.outputSchema, "  ", options) : ["  unspecified"]
+  );
+  lines.push("", "call", `  ${callExample(server, tool)}`);
+  const structured = structuredCallExample(server, tool);
+  if (structured) lines.push(`  structured: ${structured}`);
+  return `${lines.join("\n")}
+`;
+}
+function renderToolSignature(server, tool, options = {}) {
+  const schema = renderSchema(tool.inputSchema);
+  const properties = record(schema?.properties) ?? {};
+  const required = new Set(
+    Array.isArray(schema?.required) ? schema.required.filter((entry) => typeof entry === "string") : []
+  );
+  const entries = Object.entries(properties);
+  const included = new Set(
+    entries.filter(([name]) => required.has(name)).map(([name]) => name)
+  );
+  if (!options.allParameters) {
+    for (const [name] of entries) {
+      if (included.size >= 5) break;
+      included.add(name);
+    }
+  }
+  const visible = options.allParameters ? entries : entries.filter(([name]) => included.has(name));
+  const parameters = visible.map(([name, descriptor]) => {
+    const optional = required.has(name) ? "" : "?";
+    return `${name}${optional}: ${compactSchemaType(descriptor)}`;
+  });
+  const hidden = entries.length - visible.length;
+  if (hidden > 0) parameters.push(`\u2026 +${hidden} optional`);
+  return `${server}.${tool.name}(${parameters.join(", ")})`;
+}
+function catalogOutputSchema(tool) {
+  return tool?.output_schema;
+}
+
+// src/mcp-cli-help.ts
+function mcpCliHelpText() {
+  return [
+    "mcp - use available MCP tools",
+    "Supported: search, list, call, and run.",
+    "Run `mcp <command> --help` for complete command syntax.",
+    "Use this session-local `mcp` command, not `mcporter` or `npx mcporter`; it enforces the materialized recipe capabilities.",
+    "",
+    "Recommended flow:",
+    '  mcp search "what you need"',
+    "  mcp list <server.tool> --schema",
+    "  mcp call <server>.<tool> key=value ...",
+    "  Search for a tool, inspect its compact contract, then call it.",
+    "  Metadata is compact text; actual structured tool results are JSON.",
+    "",
+    "Batch or compose multiple calls in JavaScript:",
+    "  mcp run <<'JS'",
+    '  const ids = ["id-1", "id-2", "id-3"]',
+    '  const results = await Promise.all(ids.map(id => tools["server"]["tool"]({ id })))',
+    "  console.log(JSON.stringify(results.map(result => ({ id: result.id, name: result.name })), null, 2))",
+    "  JS",
+    "  Keep the heredoc quoted (<<'JS'). Use run for batching, parallel calls, or dependent workflows\u2014not for a single call.",
+    "",
+    "Notes:",
+    "  Use mcp list or mcp list <server> only when you need to browse the available inventory.",
+    "  Run `mcp call --help` or `mcp run --help` for advanced argument, output, and workflow options.",
+    "  Tool commands are always headless. If authentication is required, ask the user to authenticate the MCP connection outside the agent session, then retry.",
+    "",
+    "Availability:",
+    "  Search and list expose only tools callable in this session.",
+    "  Only exact tool names returned by mcp list are callable.",
+    "  Descriptions may mention related tools that are not exposed; mentions do not grant access.",
+    "  If no listed tool supports an action, report that the connected capability is unavailable.",
+    "  MCP resources and administrative or ad-hoc connection commands are not exposed."
+  ].join("\n");
+}
+
+// src/mcp.ts
+import { delimiter, dirname, join, resolve } from "node:path";
+
+// src/recipe-package.ts
+var RESOURCE_KEYS = [
+  "agents",
+  "extensions",
+  "skills",
+  "prompts"
+];
+var PI_KEYS = /* @__PURE__ */ new Set([...RESOURCE_KEYS, "mcp"]);
+
+// src/mcp-policy.ts
+function mcpSelectionAllowsTool(selection, toolName) {
+  const included = selection.include?.some((selector) => {
+    const trimmed = selector.trim();
+    return trimmed === "*" || trimmed === toolName;
+  }) ?? false;
+  if (!included) return false;
+  return !(selection.exclude ?? []).some(
+    (selector) => selector.trim() === toolName
+  );
+}
+
+// src/mcp-daemon-client.ts
+var MAX_DAEMON_FRAME_BYTES = 10 * 1024 * 1024;
+
+// src/mcp.ts
+var RECIPE_ENV_PREFIX = "PI_RECIPES_";
+var MCP_SESSION_ENV = `${RECIPE_ENV_PREFIX}MCP_SESSION`;
+var MCP_LOCAL_CONFIG_ENV = `${RECIPE_ENV_PREFIX}MCP_LOCAL_CONFIG`;
+var MCP_BIN_DIR_ENV = `${RECIPE_ENV_PREFIX}MCP_BIN_DIR`;
+function defaultMcpSessionPath(cwd) {
+  return join(cwd, ".pi", "mcp-session.json");
+}
+function defaultMcporterConfigPath(cwd) {
+  return join(cwd, ".pi", "mcporter.json");
+}
+function mcpSessionAllowsTool(server, toolName) {
+  return mcpSelectionAllowsTool(server.package_tools, toolName) && server.agent_tools.some(
+    (selection) => mcpSelectionAllowsTool(selection, toolName)
+  );
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function filterMcpCatalog(server, catalog) {
+  const allowed = catalog.filter(
+    (tool) => mcpSessionAllowsTool(server, tool.name)
+  );
+  const hiddenNames = catalog.filter((tool) => !mcpSessionAllowsTool(server, tool.name)).map((tool) => tool.name).filter(Boolean).sort((left, right) => right.length - left.length);
+  if (hiddenNames.length === 0) return allowed;
+  return allowed.map((tool) => ({
+    ...tool,
+    ...tool.description ? {
+      description: hiddenNames.reduce(
+        (description, name) => description.replace(
+          new RegExp(
+            `(^|[^A-Za-z0-9_-])${escapeRegExp(name)}(?=$|[^A-Za-z0-9_-])`,
+            "g"
+          ),
+          "$1[unavailable MCP tool]"
+        ),
+        tool.description
+      )
+    } : {}
+  }));
+}
+
+// src/mcp-cli-policy.ts
+var FORBIDDEN_DELEGATED_FLAGS = /* @__PURE__ */ new Set([
+  "--config",
+  "--root",
+  "--log-level",
+  "--http-url",
+  "--sse",
+  "--stdio",
+  "--stdio-bin",
+  "--stdio-arg",
+  "--header",
+  "--env",
+  "--cwd",
+  "--name",
+  "--description",
+  "--persist",
+  "--allow-http",
+  "--insecure",
+  "--yes",
+  "--server",
+  "--tool",
+  "--tail-log",
+  "--brief",
+  "--signatures",
+  "--args",
+  "--no-oauth",
+  "--oauth-timeout",
+  "--raw-strings",
+  "--no-coerce"
+]);
+var LIST_OUTPUT_MODES = /* @__PURE__ */ new Map([
+  ["--schema", "schema"],
+  ["--all-parameters", "all-parameters"],
+  ["--status", "status"]
+]);
+function flagName(value) {
+  const equals = value.indexOf("=");
+  return equals === -1 ? value : value.slice(0, equals);
+}
+function toolSelector2(value) {
+  const ref = value.trim();
+  if (/[()]/.test(ref)) return null;
+  const dot = ref.indexOf(".");
+  if (dot < 1 || dot === ref.length - 1) return null;
+  return { server: ref.slice(0, dot), tool: ref.slice(dot + 1) };
+}
+function withNoOAuth(args) {
+  const literalSeparator = args.indexOf("--");
+  if (literalSeparator === -1) return [...args, "--no-oauth"];
+  return [
+    ...args.slice(0, literalSeparator),
+    "--no-oauth",
+    ...args.slice(literalSeparator)
+  ];
+}
+function forbiddenFlag(args) {
+  const literalSeparator = args.indexOf("--");
+  const options = literalSeparator === -1 ? args : args.slice(0, literalSeparator);
+  return options.map(flagName).find((flag) => FORBIDDEN_DELEGATED_FLAGS.has(flag));
+}
+function listOutputModeError(args) {
+  const literalSeparator = args.indexOf("--");
+  const options = literalSeparator === -1 ? args : args.slice(0, literalSeparator);
+  const modes = new Set(
+    options.map((arg) => LIST_OUTPUT_MODES.get(flagName(arg))).filter((mode) => Boolean(mode))
+  );
+  return modes.size > 1 ? "mcp list accepts only one output mode: --schema, --all-parameters, or --status." : void 0;
+}
+function closestName(input2, candidates) {
+  const normalize = (value) => value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  const source = normalize(input2);
+  const distance = (left, right) => {
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= left.length; i += 1) {
+      const current = [i];
+      for (let j = 1; j <= right.length; j += 1) {
+        current[j] = Math.min(
+          current[j - 1] + 1,
+          previous[j] + 1,
+          previous[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1)
+        );
+      }
+      previous = current;
+    }
+    return previous[right.length];
+  };
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const candidateDistance = distance(source, normalize(candidate));
+    if (candidateDistance < bestDistance) {
+      best = candidate;
+      bestDistance = candidateDistance;
+    }
+  }
+  if (!best) return void 0;
+  const baseline = Math.max(source.length, normalize(best).length, 1);
+  return bestDistance <= Math.max(2, Math.floor(baseline / 3)) ? best : void 0;
+}
+function validateExactTarget(policy, server, tool) {
+  const configured = policy.servers.get(server);
+  if (!configured) {
+    const available = [...policy.servers.keys()];
+    const suggestion = closestName(server, available);
+    return available.length > 0 ? `MCP server '${server}' is not available in this session.${suggestion ? ` Did you mean '${suggestion}'?` : ""} Available servers: ${available.join(", ")}.` : `MCP server '${server}' is not available in this session. No MCP servers are configured.`;
+  }
+  if (tool !== void 0 && !mcpSessionAllowsTool(configured, tool)) {
+    const known = configured.catalog?.map((entry) => entry.name) ?? [];
+    const suggestion = closestName(tool, known);
+    return `Tool '${tool}' is not available on server '${server}' in this session.${suggestion ? ` Did you mean '${suggestion}'?` : ""} Run \`mcp list ${server}\` to inspect the callable tools.`;
+  }
+  return null;
+}
+function validateList(args, policy) {
+  const blocked = forbiddenFlag(args.slice(1));
+  if (blocked) return { error: `mcp list option '${blocked}' is unavailable in recipe sessions.` };
+  const outputModeError = listOutputModeError(args.slice(1));
+  if (outputModeError) return { error: outputModeError };
+  const adHocTarget = args.slice(1).find((arg) => !arg.startsWith("-") && /^(?:https?:\/\/|[^/]+\/)/i.test(arg));
+  if (adHocTarget) {
+    return { error: "mcp list accepts only servers materialized for this recipe session; URLs and ad-hoc servers are unavailable." };
+  }
+  const target = args[1] && !args[1].startsWith("-") ? args[1] : void 0;
+  if (target !== void 0) {
+    const selector = toolSelector2(target);
+    const server = selector?.server ?? target;
+    const error = validateExactTarget(policy, server, selector?.tool);
+    if (error) return { error };
+  }
+  return {
+    command: {
+      args: withNoOAuth(args)
+    }
+  };
+}
+var CALL_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "--json",
+  "--output",
+  "--timeout"
+]);
+function callSyntaxError(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--") {
+      return "mcp call positional arguments are unavailable; use key=value or --json instead.";
+    }
+    if (arg.startsWith("--")) {
+      const flag = flagName(arg);
+      if (!CALL_FLAGS_WITH_VALUE.has(flag)) {
+        return `mcp call option '${flag}' is unavailable; use key=value or --json for tool arguments.`;
+      }
+      if (!arg.includes("=")) index += 1;
+      continue;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_.-]*=/.test(arg)) continue;
+    return `mcp call argument '${arg}' must use key=value syntax or be supplied through --json.`;
+  }
+  return void 0;
+}
+function validateCall(args, policy) {
+  const rawSelector = args[1];
+  const selector = rawSelector ? toolSelector2(rawSelector) : null;
+  if (!selector) {
+    const splitTool = rawSelector ? args[2] : void 0;
+    if (rawSelector && splitTool && policy.servers.has(rawSelector) && mcpSessionAllowsTool(policy.servers.get(rawSelector), splitTool)) {
+      return {
+        error: `mcp call requires a dotted tool selector. Use mcp call ${rawSelector}.${splitTool} key=value or --json for structured arguments.`
+      };
+    }
+    return {
+      error: "mcp call requires an exact session tool selector: mcp call <server>.<tool> key=value ..."
+    };
+  }
+  if (/^(?:https?:\/\/|[^/]+\/)/i.test(selector.server)) {
+    return { error: "mcp call accepts only tools materialized for this recipe session; URLs and ad-hoc servers are unavailable." };
+  }
+  const targetError = validateExactTarget(policy, selector.server, selector.tool);
+  if (targetError) return { error: targetError };
+  const blocked = forbiddenFlag(args.slice(2));
+  if (blocked === "--args") {
+    return {
+      error: "mcp call option '--args' was removed; use --json <object|-> for structured tool arguments."
+    };
+  }
+  if (blocked) return { error: `mcp call option '${blocked}' is unavailable in recipe sessions.` };
+  const syntaxError = callSyntaxError(args.slice(2));
+  if (syntaxError) return { error: syntaxError };
+  return {
+    command: {
+      args: withNoOAuth(args)
+    }
+  };
+}
+function createMcpCliSessionPolicy(session) {
+  return {
+    servers: new Map(
+      session.servers.map((server) => [server.id, server])
+    )
+  };
+}
+function validateDelegatedMcpCommand(args, policy) {
+  if (args[0] === "list") return validateList(args, policy);
+  if (args[0] === "call") return validateCall(args, policy);
+  return {
+    error: args[0] === "auth" ? "Interactive authentication is unavailable in the agent MCP CLI. Ask the user to authenticate this MCP connection outside the agent session, then retry." : `mcp command '${args[0] ?? ""}' is unavailable in recipe sessions. Use mcp search, list, call, or run.`
+  };
+}
+
+// src/mcp-cli-core.ts
+var DEFAULT_RUN_TIMEOUT_MS = 12e4;
+var DEFAULT_TOOL_CALL_TIMEOUT_MS = 6e4;
+var DEFAULT_LIST_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RUN_TOOL_CALLS = 100;
+var DEFAULT_MAX_CONCURRENT_TOOL_CALLS = 16;
+var MAX_SEARCH_DESCRIPTION_CHARS = 600;
+var CATALOG_LOCK_POLL_MS = 50;
+var CATALOG_LOCK_INCOMPLETE_GRACE_MS = 1e3;
+var MCP_SESSION_ENV2 = "PI_RECIPES_MCP_SESSION";
+async function acquireRuntime() {
+  const shared = currentMcpCommandContext()?.runtime;
+  return shared ? { runtime: shared, owned: false } : { runtime: await createRuntime(), owned: true };
+}
+async function closeOwnedRuntime(runtime, owned) {
+  if (owned) await runtime.close();
+}
+var McpRunUsageError = class extends Error {
+};
+var McpRunTimeoutError = class extends Error {
+  outcome = "unknown";
+  constructor(message) {
+    super(message);
+    this.name = "McpRunTimeoutError";
+  }
+};
+var McpRemoteToolResultError = class extends Error {
+  constructor(details) {
+    super(details.message);
+    this.details = details;
+    this.name = "McpRemoteToolResultError";
+  }
+  details;
+};
+var McpRunToolError = class extends Error {
+  constructor(server, tool, message, options) {
+    super(message, options);
+    this.server = server;
+    this.tool = tool;
+    this.name = "McpRunToolError";
+    this.details = options?.details;
+    this.code = options?.details?.code;
+    this.retryable = options?.details?.retryable;
+    this.action = options?.details?.action;
+    this.outcome = options?.details?.outcome;
+  }
+  server;
+  tool;
+  kind = "tool_execution";
+  details;
+  code;
+  retryable;
+  action;
+  outcome;
+};
+function mcpListHelpText() {
+  return [
+    "Usage: mcp list [server | server.tool] [flags]",
+    "",
+    "Shows a compact view of tools materialized in this recipe session.",
+    "",
+    "Flags:",
+    "  --all-parameters          Include every optional parameter.",
+    "  --schema                  Show a compact input/output contract for one exact tool.",
+    "  --verbose                 Include full tool and parameter descriptions.",
+    "  --status                  Show concise status for an exact server target.",
+    "  --quiet, --exit-code      Health checks for an exact server target.",
+    "  --timeout <ms>            Override discovery timeout for an exact target.",
+    "  JSON is reserved for actual tool results; metadata is compact text.",
+    "",
+    "URLs, ad-hoc transports, config overrides, and persistence are unavailable in recipe sessions."
+  ].join("\n");
+}
+function mcpCallHelpText() {
+  return [
+    "Usage: mcp call <server>.<tool> [arguments] [flags]",
+    "",
+    "Calls exact tools materialized in this recipe session.",
+    "",
+    "Arguments:",
+    "  key=value                 Named arguments with schema-aware coercion.",
+    "  key=@path                 Read an exact UTF-8 string; use @@ for a literal @.",
+    "  --json <json|->           Supply a structured JSON object directly or from stdin.",
+    `  Array example: mcp call server.tool --json '{"tags":["a","b"]}'.`,
+    "  Quote argument tokens containing shell operators such as |, <, >, &, or ;. JSON stdin avoids nested shell quoting.",
+    "",
+    "Output/runtime flags:",
+    "  --output text|markdown|json|raw",
+    "  --timeout <ms>",
+    "  Machine-readable output is forwarded unchanged.",
+    "  When parsing JSON, keep stderr separate and do not truncate stdout with head or sed.",
+    "",
+    "URLs, ad-hoc transports, config overrides, and persistence are unavailable in recipe sessions."
+  ].join("\n");
+}
+function mcpSearchHelpText() {
+  return [
+    'Usage: mcp search "what you need" [--limit N] [--regex]',
+    "",
+    "Searches only MCP tools available in this session.",
+    "Results include the exact tool ref, description, and required fields.",
+    "Try broader or alternate terms when no result matches.",
+    "Use `mcp list <server>` only to identify exact tool names, then inspect one candidate with `mcp list <server.tool> --schema`."
+  ].join("\n");
+}
+function mcpRunHelpText() {
+  return [
+    "Usage: mcp run [--var KEY=value] [--json-errors] [file]",
+    "",
+    'Runs a short JavaScript workflow with available MCP tools such as `tools["server"]["tool"]`.',
+    "With no file, code is read from stdin. Keep heredocs quoted and pass dynamic values with --var.",
+    "Scripts are killed after 120s by default (override with PI_RECIPES_MCP_RUN_TIMEOUT_MS).",
+    "Each tool call is capped at 60s; workflows allow at most 100 calls and run 16 at a time by default.",
+    "Extra calls wait in a FIFO queue and inherit the remaining workflow deadline.",
+    "Always await or return tool-call chains.",
+    "Detached .then/.catch calls fail if still pending when the script exits.",
+    "Structured MCP errors retain code, retryable, action, request_id, and outcome fields when supplied.",
+    "Calls return decoded JSON by default, so read response fields directly from the awaited value.",
+    "Only when a tool documents another response type, call the format on the tool itself: tool.text(args), tool.markdown(args), tool.images(args), tool.content(args), tool.structuredContent(args), or tool.raw(args).",
+    "Use Promise.all for independent reads. Await dependent calls and mutations in order.",
+    "Do not loop over mcp call in the shell. Use mcp run for repeated calls and print only the fields needed.",
+    "Use --var/vars for dynamic input; process.argv is intentionally unavailable inside workflows.",
+    "--json-errors emits a structured error object on stderr while preserving the nonzero exit code.",
+    "MCP calls are always headless. If authentication is required, ask the user to authenticate the connection outside the agent session, then retry.",
+    "A synchronous busy-loop is force-killed at the deadline.",
+    "Code runs with the same OS privileges as the active shell sandbox; mcp run is not a separate security boundary.",
+    "",
+    "Example \u2014 batch or compose multiple calls:",
+    "  mcp run <<'JS'",
+    '  const ids = ["id-1", "id-2", "id-3"]',
+    '  const results = await Promise.all(ids.map(id => tools["server"]["tool"]({ id })))',
+    "  console.log(JSON.stringify(results.map(result => ({ id: result.id, name: result.name })), null, 2))",
+    "  JS"
+  ].join("\n");
+}
+function isHelpArg(value) {
+  return value === "--help" || value === "-h" || value === "help";
+}
+function readStdin() {
+  const source = currentMcpCommandContext()?.stdin ?? input;
+  source.setEncoding("utf8");
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    source.on("data", (chunk) => {
+      data += chunk;
+    });
+    source.on("error", reject);
+    source.on("end", () => resolve2(data));
+  });
+}
+function checkedCallResult(callResult) {
+  if (asRecord(callResult.raw).isError === true) {
+    const parsed = callResult.json();
+    const parsedRecord = asRecord(parsed);
+    const parsedError = Object.prototype.hasOwnProperty.call(parsedRecord, "error") ? parsedRecord.error : parsedRecord;
+    const errorObject = asRecord(parsedError);
+    const message = typeof parsedError === "string" ? parsedError : typeof errorObject.message === "string" ? errorObject.message : callResult.text() ?? "MCP tool call failed.";
+    throw new McpRemoteToolResultError({ ...errorObject, message });
+  }
+  return callResult;
+}
+function decodeCallResult(callResult, format, ref) {
+  switch (format) {
+    case "json": {
+      const decoded = callResult.json();
+      if (decoded === null && callResult.structuredContent() == null && callResult.text() != null) {
+        throw new McpRunUsageError(
+          `${ref} did not return JSON. Its documentation should name the response type; for plain text call tools[${JSON.stringify(ref.split(".")[0])}][${JSON.stringify(ref.slice(ref.indexOf(".") + 1))}].text(args).`
+        );
+      }
+      return decoded;
+    }
+    case "text":
+      return callResult.text();
+    case "markdown":
+      return callResult.markdown();
+    case "images":
+      return callResult.images();
+    case "content":
+      return callResult.content();
+    case "structuredContent":
+      return callResult.structuredContent();
+    case "raw":
+      return callResult.raw;
+  }
+}
+function validateRunToolArgs(server, tool, args) {
+  const cliStyleKey = Object.keys(args).find((key) => key.includes(":=") || key.includes("="));
+  if (!cliStyleKey) return;
+  const suggestedKey = cliStyleKey.split(/:=|=/, 1)[0];
+  throw new McpRunUsageError(
+    `Invalid JavaScript argument key '${cliStyleKey}' for ${server}.${tool}. mcp run uses normal JavaScript objects: write { ${suggestedKey}: value }, not mcporter CLI key=value or key:=value syntax.`
+  );
+}
+var ToolCallQueue = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  active = 0;
+  waiting = [];
+  cancelled;
+  acquire() {
+    if (this.cancelled !== void 0) return Promise.reject(this.cancelled);
+    if (this.active < this.limit) {
+      this.active += 1;
+      return Promise.resolve(this.releaseHandle());
+    }
+    return new Promise((resolve2, reject) => this.waiting.push({ resolve: resolve2, reject }));
+  }
+  cancel(error) {
+    if (this.cancelled !== void 0) return;
+    this.cancelled = error;
+    for (const waiter of this.waiting.splice(0)) waiter.reject(error);
+  }
+  releaseHandle() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const next = this.waiting.shift();
+      if (next && this.cancelled === void 0) {
+        next.resolve(this.releaseHandle());
+        return;
+      }
+      this.active -= 1;
+    };
+  }
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function words(value) {
+  return value.toLowerCase().split(/[^a-z0-9_/-]+/g).map((token) => token.trim()).filter(Boolean);
+}
+function toolProperties(tool) {
+  const schema = asRecord(tool.input_schema);
+  const properties = asRecord(schema.properties);
+  return Object.entries(properties).map(([name, value]) => {
+    const property = asRecord(value);
+    const description = typeof property.description === "string" ? property.description : typeof property.title === "string" ? property.title : "";
+    return { name, description };
+  });
+}
+function toolRequired(tool) {
+  const schema = asRecord(tool.input_schema);
+  return Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+}
+function includesTerm(value, term) {
+  return value.toLowerCase().includes(term.toLowerCase());
+}
+function scoreTool(opts) {
+  const ref = `${opts.serverId}.${opts.tool.name}`;
+  const description = opts.tool.description ?? "";
+  const properties = toolProperties(opts.tool);
+  const propertyNames = properties.map((property) => property.name).join(" ");
+  const propertyDescriptions = properties.map((property) => property.description).join(" ");
+  const searchable = [
+    ref,
+    opts.serverId,
+    opts.serverName,
+    opts.tool.name,
+    description,
+    propertyNames,
+    propertyDescriptions
+  ].join("\n");
+  if (opts.regex) return opts.regex.test(searchable) ? 100 : 0;
+  const query = opts.query.toLowerCase();
+  const toolName = opts.tool.name.toLowerCase();
+  const refName = ref.toLowerCase();
+  let score = 0;
+  if (refName === query) score += 500;
+  if (toolName === query) score += 300;
+  if (refName.includes(query)) score += 120;
+  if (toolName.includes(query)) score += 100;
+  if (description.toLowerCase().includes(query)) score += 60;
+  const toolNameTokens = new Set(words(opts.tool.name));
+  const serverTokens = new Set(words(`${opts.serverId} ${opts.serverName}`));
+  const descriptionText2 = description.toLowerCase();
+  const propertyNameTokens = new Set(words(propertyNames));
+  const propertyDescriptionText = propertyDescriptions.toLowerCase();
+  for (const term of opts.queryTerms) {
+    if (toolNameTokens.has(term)) score += 40;
+    else if (includesTerm(opts.tool.name, term)) score += 20;
+    if (descriptionText2.includes(term)) score += 16;
+    if (propertyNameTokens.has(term)) score += 12;
+    else if (includesTerm(propertyNames, term)) score += 6;
+    if (propertyDescriptionText.includes(term)) score += 6;
+    if (serverTokens.has(term)) score += 4;
+  }
+  return score;
+}
+function exampleValue2(name) {
+  if (/^(q|query|search)$/i.test(name)) return `="example query"`;
+  if (/limit|count|max/i.test(name)) return "=10";
+  if (/^(id|.*Id)$/i.test(name)) return '="<id>"';
+  return '="<value>"';
+}
+function callExample2(serverId, tool) {
+  const required = toolRequired(tool);
+  const args = required.slice(0, 4).map((name) => `${name}${exampleValue2(name)}`);
+  return ["mcp call", `${serverId}.${tool.name}`, ...args].join(" ");
+}
+function searchMcpTools(session, query, opts = {}) {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+  const regex = opts.regex ? new RegExp(trimmed, "i") : void 0;
+  const queryTerms = words(trimmed);
+  const matches = [];
+  for (const server of session.servers) {
+    for (const tool of server.catalog ?? []) {
+      const score = scoreTool({
+        query: trimmed,
+        queryTerms,
+        regex,
+        serverId: server.id,
+        serverName: server.name ?? "",
+        tool
+      });
+      if (score <= 0) continue;
+      const ref = `${server.id}.${tool.name}`;
+      matches.push({
+        ref,
+        server: server.id,
+        tool: tool.name,
+        description: (tool.description ?? "").length > MAX_SEARCH_DESCRIPTION_CHARS ? `${(tool.description ?? "").slice(0, MAX_SEARCH_DESCRIPTION_CHARS - 14).trimEnd()}\u2026 [truncated]` : tool.description ?? "",
+        required: toolRequired(tool),
+        score,
+        inspect: `mcp list ${ref} --schema`,
+        call: callExample2(server.id, tool),
+        ...tool.annotations ? { annotations: tool.annotations } : {}
+      });
+    }
+  }
+  return matches.sort((a, b) => b.score - a.score || a.ref.localeCompare(b.ref)).slice(0, opts.limit ?? 8);
+}
+async function readSession() {
+  const path = sessionPolicyPath();
+  const data = await readFile(path, "utf8");
+  const parsed = JSON.parse(data);
+  if (parsed.version !== 1 || !Array.isArray(parsed.servers)) {
+    throw new Error(`Invalid MCP session policy at ${path}`);
+  }
+  return parsed;
+}
+function sessionPolicyPath() {
+  const workspacePath = defaultMcpSessionPath(sessionRoot());
+  return existsSync(workspacePath) ? workspacePath : process.env[MCP_SESSION_ENV2] || workspacePath;
+}
+function sessionMcporterConfigPath() {
+  const workspacePath = defaultMcporterConfigPath(sessionRoot());
+  return existsSync(workspacePath) ? workspacePath : process.env.MCPORTER_CONFIG || workspacePath;
+}
+function sessionRoot() {
+  return process.env.PI_RECIPES_MCP_SESSION_ROOT || process.cwd();
+}
+function pinSessionMcporterConfig() {
+  process.env.MCPORTER_CONFIG = sessionMcporterConfigPath();
+}
+async function sessionCliPolicy() {
+  return createMcpCliSessionPolicy(await readSession());
+}
+function catalogFingerprint(server) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      id: server.id,
+      baseUrl: server.base_url,
+      packageTools: server.package_tools,
+      agentTools: server.agent_tools
+    })
+  ).digest("hex").slice(0, 20);
+}
+function catalogCachePath(server) {
+  return join2(
+    sessionRoot(),
+    ".pi",
+    "mcp-catalogs",
+    `${server.id}-${catalogFingerprint(server)}.json`
+  );
+}
+async function readCachedCatalog(server) {
+  if (server.catalog) return server.catalog;
+  try {
+    const parsed = JSON.parse(
+      await readFile(catalogCachePath(server), "utf8")
+    );
+    return Array.isArray(parsed.tools) ? parsed.tools : null;
+  } catch {
+    return null;
+  }
+}
+async function writeCachedCatalog(server, tools) {
+  const directory = join2(sessionRoot(), ".pi", "mcp-catalogs");
+  await mkdir(directory, { recursive: true });
+  const path = catalogCachePath(server);
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify({ tools })}
+`, { mode: 384 });
+  await rename(temporary, path);
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function catalogLockIsStale(path, timeoutMs) {
+  try {
+    const owner = JSON.parse(await readFile(path, "utf8"));
+    if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0 && typeof owner.createdAt === "number" && Number.isFinite(owner.createdAt)) {
+      return !processExists(owner.pid) || Date.now() - owner.createdAt > timeoutMs + CATALOG_LOCK_INCOMPLETE_GRACE_MS;
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+  }
+  try {
+    const metadata = await stat(path);
+    return Date.now() - metadata.mtimeMs > CATALOG_LOCK_INCOMPLETE_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+async function acquireCatalogLock(path) {
+  let handle;
+  try {
+    handle = await open(path, "wx", 384);
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+  try {
+    await handle.writeFile(
+      `${JSON.stringify({ pid: process.pid, createdAt: Date.now() })}
+`
+    );
+  } catch (error) {
+    await handle.close();
+    await rm(path, { force: true });
+    throw error;
+  }
+  await handle.close();
+  return true;
+}
+function catalogEntry(tool) {
+  const annotations = asRecord(tool).annotations;
+  return {
+    name: tool.name,
+    ...tool.description ? { description: tool.description } : {},
+    ...tool.inputSchema && typeof tool.inputSchema === "object" ? { input_schema: tool.inputSchema } : {},
+    ...tool.outputSchema && typeof tool.outputSchema === "object" ? { output_schema: tool.outputSchema } : {},
+    ...annotations && typeof annotations === "object" ? { annotations } : {}
+  };
+}
+async function discoverServerCatalog(runtime, server, timeoutMs) {
+  const cached = await readCachedCatalog(server);
+  if (cached) return cached;
+  const lock = `${catalogCachePath(server)}.lock`;
+  await mkdir(dirname2(lock), { recursive: true });
+  let ownsLock = false;
+  const deadline = Date.now() + timeoutMs;
+  while (!ownsLock && Date.now() < deadline) {
+    ownsLock = await acquireCatalogLock(lock);
+    if (ownsLock) break;
+    const populated = await readCachedCatalog(server);
+    if (populated) return populated;
+    if (await catalogLockIsStale(lock, timeoutMs)) {
+      await rm(lock, { force: true });
+      continue;
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs > 0) {
+      await delay(Math.min(CATALOG_LOCK_POLL_MS, remainingMs));
+    }
+  }
+  if (!ownsLock) {
+    const populated = await readCachedCatalog(server);
+    if (populated) return populated;
+    throw new Error(
+      `timed out after ${timeoutMs}ms waiting for MCP catalog discovery for '${server.id}'`
+    );
+  }
+  try {
+    const populated = await readCachedCatalog(server);
+    if (populated) return populated;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(
+        `timed out after ${timeoutMs}ms before MCP catalog discovery for '${server.id}' started`
+      );
+    }
+    const discovered = await withListTimeout(
+      runtime.listTools(server.id, {
+        includeSchema: true,
+        autoAuthorize: false,
+        allowCachedAuth: true,
+        disableOAuth: true
+      }),
+      remainingMs
+    );
+    const tools = filterMcpCatalog(server, discovered.map(catalogEntry));
+    await writeCachedCatalog(server, tools);
+    return tools;
+  } finally {
+    if (ownsLock) await rm(lock, { recursive: true, force: true });
+  }
+}
+async function discoverMcpCatalogs(runtime, timeoutMs) {
+  const session = await readSession();
+  return await Promise.all(
+    session.servers.map(async (server) => {
+      try {
+        return {
+          id: server.id,
+          name: server.name,
+          tools: await discoverServerCatalog(runtime, server, timeoutMs)
+        };
+      } catch (error) {
+        return {
+          id: server.id,
+          name: server.name,
+          tools: [],
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    })
+  );
+}
+function parseSearchArgs(args) {
+  const queryParts = [];
+  let limit = 8;
+  let regex = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") return { error: "mcp search metadata is compact text; JSON is reserved for tool results." };
+    if (arg === "--regex") {
+      regex = true;
+      continue;
+    }
+    if (arg === "--limit" || arg.startsWith("--limit=")) {
+      const raw = arg === "--limit" ? args[++index] : arg.slice("--limit=".length);
+      const value = Number(raw);
+      if (!Number.isInteger(value) || value <= 0) {
+        return { error: `--limit expects a positive integer, got '${raw ?? ""}'.` };
+      }
+      limit = Math.floor(value);
+      continue;
+    }
+    if (arg.startsWith("-")) return { error: `Unknown mcp search option '${arg}'.` };
+    queryParts.push(arg);
+  }
+  return { query: queryParts.join(" "), limit, regex };
+}
+async function searchCatalog(args) {
+  const parsed = parseSearchArgs(args);
+  if (parsed.error !== void 0) {
+    stderr.write(`${parsed.error}
+`);
+    return 2;
+  }
+  const { query, limit, regex } = parsed;
+  if (!query.trim()) {
+    stderr.write('Usage: mcp search "what you need" [--limit N] [--regex]\n');
+    return 2;
+  }
+  let matches;
+  const { runtime, owned } = await acquireRuntime();
+  try {
+    const session = await readSession();
+    const results = await Promise.all(
+      session.servers.map(async (server) => {
+        try {
+          return {
+            catalog: await discoverServerCatalog(
+              runtime,
+              server,
+              DEFAULT_LIST_TIMEOUT_MS
+            )
+          };
+        } catch (error) {
+          return { error };
+        }
+      })
+    );
+    const failed = results.filter((result) => "error" in result).length;
+    if (failed > 0) {
+      stderr.write(
+        `mcp search: ${failed} of ${results.length} server(s) unavailable; searched the remaining catalogs.
+`
+      );
+    }
+    matches = searchMcpTools(
+      {
+        ...session,
+        servers: session.servers.map((server, index) => ({
+          ...server,
+          catalog: "catalog" in results[index] ? results[index].catalog : []
+        }))
+      },
+      query,
+      { limit, regex }
+    );
+  } catch (err) {
+    if (regex && err instanceof SyntaxError) {
+      stderr.write(`Invalid --regex pattern: ${query}
+`);
+      return 2;
+    }
+    throw err;
+  } finally {
+    await closeOwnedRuntime(runtime, owned);
+  }
+  if (matches.length === 0) {
+    stdout.write(`No matching tools found for "${query}".
+`);
+    stdout.write("Try broader or alternate terms.\n");
+    stdout.write(
+      "Use `mcp list <server>` only to identify exact tool names, then inspect one candidate with `mcp list <server.tool> --schema`.\n"
+    );
+    return 0;
+  }
+  for (const match of matches) {
+    stdout.write(`${match.ref}${match.description ? ` \u2014 ${match.description}` : ""}
+`);
+    if (match.required.length > 0) stdout.write(`  required: ${match.required.join(", ")}
+`);
+  }
+  return 0;
+}
+function exactToolTarget(value) {
+  if (!value) return null;
+  const dot = value.indexOf(".");
+  if (dot < 1 || dot === value.length - 1) return null;
+  return { server: value.slice(0, dot), tool: value.slice(dot + 1) };
+}
+function catalogTool(session, server, tool) {
+  return session.servers?.find((entry) => entry.id === server)?.catalog?.find((entry) => entry.name === tool);
+}
+function toolCount(count) {
+  return `${count} tool${count === 1 ? "" : "s"}`;
+}
+function parseListTimeoutMs(args) {
+  const configured = process.env.MCPORTER_LIST_TIMEOUT;
+  let raw = configured && /^[1-9]\d*$/.test(configured) ? configured : String(DEFAULT_LIST_TIMEOUT_MS);
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--timeout") {
+      const value = args[index + 1];
+      if (!value) return "mcp list: --timeout requires a value.";
+      raw = value;
+      break;
+    }
+    if (arg?.startsWith("--timeout=")) {
+      raw = arg.slice("--timeout=".length);
+      break;
+    }
+  }
+  if (!/^[1-9]\d*$/.test(raw)) {
+    return "mcp list: --timeout must be a positive integer (milliseconds).";
+  }
+  const timeout = Number(raw);
+  return Number.isSafeInteger(timeout) ? timeout : "mcp list: --timeout must be a positive integer (milliseconds).";
+}
+function withListTimeout(promise, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function aggregateListExitCode(hadFailure, args) {
+  return hadFailure && (args.includes("--quiet") || args.includes("--exit-code")) ? 1 : 0;
+}
+function writeCompactListError(error) {
+  const filter = createDelegatedErrorFilter((text) => stderr.write(text));
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  filter.push(`mcp list: ${message.endsWith("\n") ? message : `${message}
+`}`);
+  filter.flush();
+}
+function compactListArgumentError(args) {
+  const flags = /* @__PURE__ */ new Set([
+    "--all-parameters",
+    "--schema",
+    "--verbose",
+    "--status",
+    "--quiet",
+    "--exit-code",
+    "--no-oauth"
+  ]);
+  const start = args[1] && !args[1].startsWith("-") ? 2 : 1;
+  for (let index = start; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--timeout") {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--timeout=")) continue;
+    if (flags.has(arg)) continue;
+    return arg.startsWith("-") ? `Unknown mcp list option '${arg}'.` : `Unexpected mcp list argument '${arg}'.`;
+  }
+  return void 0;
+}
+async function compactList(args) {
+  if (args.includes("--json")) {
+    stderr.write("mcp list metadata is compact text; JSON is reserved for tool results.\n");
+    return 2;
+  }
+  const argumentError = compactListArgumentError(args);
+  if (argumentError) {
+    stderr.write(`${argumentError}
+`);
+    return 2;
+  }
+  const target = args[1] && !args[1].startsWith("-") ? args[1] : void 0;
+  const schema = args.includes("--schema");
+  const status = args.includes("--status");
+  const verbose = args.includes("--verbose");
+  const allParameters = args.includes("--all-parameters");
+  const quiet = args.includes("--quiet");
+  const timeout = parseListTimeoutMs(args);
+  if (typeof timeout === "string") {
+    stderr.write(`${timeout}
+`);
+    return 2;
+  }
+  if (schema && !target) {
+    stderr.write("mcp list --schema requires one exact tool: mcp list <server>.<tool> --schema\n");
+    return 2;
+  }
+  const session = await readSession();
+  if (!target) {
+    const { runtime: runtime2, owned: owned2 } = await acquireRuntime();
+    try {
+      const results = await Promise.all(
+        session.servers.map(async (server2) => {
+          try {
+            const tools = await discoverServerCatalog(runtime2, server2, timeout);
+            return { server: server2, tools };
+          } catch (error) {
+            return { server: server2, error };
+          }
+        })
+      );
+      let hadFailure = false;
+      for (const result of results) {
+        if ("error" in result) {
+          hadFailure = true;
+          if (!quiet) stdout.write(`${result.server.id} \u2014 unavailable
+`);
+        } else if (!quiet) {
+          stdout.write(
+            `${result.server.id} \u2014 ${toolCount(result.tools.length)}
+`
+          );
+        }
+      }
+      return aggregateListExitCode(hadFailure, args);
+    } finally {
+      await closeOwnedRuntime(runtime2, owned2);
+    }
+  }
+  const exact = exactToolTarget(target);
+  const server = exact?.server ?? target;
+  if (schema && !exact) {
+    stderr.write("mcp list --schema requires one exact tool: mcp list <server>.<tool> --schema\n");
+    return 2;
+  }
+  const { runtime, owned } = await acquireRuntime();
+  try {
+    const sessionServer = session.servers.find((entry) => entry.id === server);
+    if (!sessionServer) {
+      stderr.write(`MCP server '${server}' is not available in this session.
+`);
+      return 1;
+    }
+    const catalog = await discoverServerCatalog(runtime, sessionServer, timeout);
+    const tools = catalog.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.input_schema,
+      outputSchema: tool.output_schema,
+      annotations: tool.annotations
+    }));
+    if (quiet) return 0;
+    if (status) {
+      stdout.write(`${server} ok \u2014 ${toolCount(tools.length)}
+`);
+      return 0;
+    }
+    const selected = exact ? tools.filter((tool) => tool.name === exact.tool) : tools;
+    if (exact && selected.length === 0) {
+      stderr.write(`Tool '${exact.tool}' is not available on server '${server}'.
+`);
+      return 1;
+    }
+    if (schema && exact) {
+      const tool = selected[0];
+      if (!tool) return 1;
+      const outputSchema = tool.outputSchema ?? catalogOutputSchema(catalogTool(
+        { ...session, servers: session.servers.map(
+          (entry) => entry.id === server ? { ...entry, catalog } : entry
+        ) },
+        server,
+        exact.tool
+      ));
+      stdout.write(
+        renderToolContract(
+          server,
+          { ...tool, outputSchema },
+          { verboseDescriptions: verbose }
+        )
+      );
+      return 0;
+    }
+    for (const tool of selected) {
+      stdout.write(`${renderToolSignature(server, tool, { allParameters })}
+`);
+      if (verbose && tool.description?.trim()) {
+        stdout.write(`  ${tool.description.trim().replace(/\s+/g, " ")}
+`);
+      }
+    }
+    return 0;
+  } catch (error) {
+    if (!quiet) writeCompactListError(error);
+    return 1;
+  } finally {
+    await closeOwnedRuntime(runtime, owned);
+  }
+}
+var PROXY_PROBE_PROPS = /* @__PURE__ */ new Set(["then", "toJSON", "constructor", "inspect"]);
+function normalizeName(value) {
+  return value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j += 1) {
+      current[j] = Math.min(
+        current[j - 1] + 1,
+        previous[j] + 1,
+        previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+function closestName2(input2, candidates) {
+  const normalizedInput = normalizeName(input2);
+  let best;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const candidate of candidates) {
+    const score = levenshtein(normalizedInput, normalizeName(candidate));
+    if (score < bestScore) {
+      bestScore = score;
+      best = candidate;
+    }
+  }
+  if (best === void 0) return void 0;
+  const baseline = Math.max(normalizedInput.length, normalizeName(best).length, 1);
+  return bestScore <= Math.max(2, Math.floor(baseline / 3)) ? best : void 0;
+}
+function describeUnknownRunServer(server, servers) {
+  const suggestion = closestName2(server, servers);
+  const parts = [`Unknown MCP server '${server}'.`];
+  if (suggestion) parts.push(`Did you mean 'tools.${suggestion}'?`);
+  parts.push(
+    servers.length > 0 ? `Available servers: ${servers.join(", ")}.` : "No MCP servers are configured."
+  );
+  return parts.join(" ");
+}
+var RUN_TOOL_REJECTED_PATTERNS = [
+  /\btool\s+[\w.-]+\s+not found\b/i,
+  /\bunknown tool\b/i
+];
+var RUN_TOOL_BLOCKED_PATTERN = /is not accessible on server '[^']+' \(blocked by configuration\)/;
+var RUN_AUTH_REQUIRED_PATTERN = /\b(?:authentication required|unauthenticated|HTTP 401|missing (?:access )?token|invalid (?:access )?token|failed to resolve header ['"]Authorization)/i;
+function describeUnavailableRunTool(server, tool, knownTools) {
+  const suggestion = closestName2(tool, knownTools);
+  const parts = [`Tool '${tool}' is not available on server '${server}'.`];
+  if (suggestion) parts.push(`Did you mean '${suggestion}'?`);
+  parts.push(`Run \`mcp list ${server}\` to see available tools.`);
+  return parts.join(" ");
+}
+function improveRunToolError(error, server, tool, knownTools) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (RUN_AUTH_REQUIRED_PATTERN.test(message)) {
+    return new McpRemoteToolResultError({
+      code: "authentication_required",
+      message: `Authentication is required for MCP server '${server}'. Ask the user to authenticate this MCP connection outside the agent session, then retry.`,
+      retryable: false,
+      action: "ask_user_to_authenticate"
+    });
+  }
+  if (RUN_TOOL_BLOCKED_PATTERN.test(message)) {
+    return new Error(
+      `Tool '${tool}' is not enabled for server '${server}' in this session. Run \`mcp list ${server}\` to inspect the allowlist; if absent, the recipe configuration must grant it.`,
+      { cause: error }
+    );
+  }
+  if (!RUN_TOOL_REJECTED_PATTERNS.some((pattern) => pattern.test(message))) return error;
+  return new Error(describeUnavailableRunTool(server, tool, knownTools), { cause: error });
+}
+async function createTools(opts) {
+  const { runtime, owned } = await acquireRuntime();
+  const session = await readSession();
+  const knownTools = /* @__PURE__ */ new Map();
+  await Promise.all(
+    session.servers.map(async (server) => {
+      knownTools.set(
+        server.id,
+        (await readCachedCatalog(server))?.map((tool) => tool.name) ?? []
+      );
+    })
+  );
+  const configuredServers = new Set(runtime.listServers());
+  const servers = session.servers.filter(
+    (server) => configuredServers.has(server.id)
+  );
+  const calls = [];
+  let callCount = 0;
+  const queue = new ToolCallQueue(opts.maxConcurrentCalls);
+  const toolsByServer = /* @__PURE__ */ Object.create(null);
+  for (const serverPolicy of servers) {
+    const server = serverPolicy.id;
+    toolsByServer[server] = new Proxy(/* @__PURE__ */ Object.create(null), {
+      get(_target, property) {
+        if (typeof property !== "string" || PROXY_PROBE_PROPS.has(property)) return void 0;
+        const startCall = (args, format) => {
+          validateRunToolArgs(server, property, args);
+          const allowedToolNames = knownTools.get(server) ?? [];
+          if (!mcpSessionAllowsTool(serverPolicy, property)) {
+            throw new McpRunToolError(
+              server,
+              property,
+              describeUnavailableRunTool(server, property, allowedToolNames)
+            );
+          }
+          if (callCount >= opts.maxCalls) {
+            throw new McpRunUsageError(
+              `mcp run tool-call limit exceeded (${opts.maxCalls}). Split the workflow or raise PI_RECIPES_MCP_RUN_MAX_CALLS.`
+            );
+          }
+          callCount += 1;
+          const rawCall = (async () => {
+            let release;
+            try {
+              release = await queue.acquire();
+              const remainingMs = opts.deadlineMs - Date.now();
+              if (remainingMs <= 0) {
+                throw new McpRunTimeoutError(
+                  `mcp run deadline reached before ${server}.${property} started.`
+                );
+              }
+              const result = checkedCallResult(
+                createCallResult(
+                  await runtime.callTool(server, property, {
+                    args,
+                    // A queued call must never outlive the workflow that owns
+                    // it. mcporter forwards this timeout to the MCP SDK and
+                    // resets the transport when it fires.
+                    timeoutMs: Math.min(opts.callTimeoutMs, remainingMs),
+                    disableOAuth: true
+                  })
+                )
+              );
+              return decodeCallResult(result, format, `${server}.${property}`);
+            } catch (error) {
+              const improved = improveRunToolError(
+                error,
+                server,
+                property,
+                allowedToolNames ?? []
+              );
+              if (improved instanceof McpRunUsageError) throw improved;
+              const message = improved instanceof Error ? improved.message : String(improved);
+              const remoteDetails = improved instanceof McpRemoteToolResultError ? improved.details : error instanceof McpRemoteToolResultError ? error.details : void 0;
+              const timeoutDetails = !remoteDetails && (improved instanceof McpRunTimeoutError || /\b(?:timed?\s*out|timeout)\b/i.test(message)) ? {
+                code: "timeout",
+                message: improved instanceof McpRunTimeoutError ? message : `MCP tool call ${server}.${property} timed out.`,
+                retryable: true,
+                action: "inspect_state",
+                outcome: improved instanceof McpRunTimeoutError ? "not_started" : "unknown"
+              } : void 0;
+              throw new McpRunToolError(
+                server,
+                property,
+                remoteDetails?.message ?? timeoutDetails?.message ?? message,
+                { cause: improved, details: remoteDetails ?? timeoutDetails }
+              );
+            } finally {
+              release?.();
+            }
+          })();
+          const record2 = {
+            ref: `${server}.${property}`,
+            observed: false,
+            outcome: "pending",
+            promise: rawCall
+          };
+          calls.push(record2);
+          rawCall.then(
+            () => {
+              record2.outcome = "succeeded";
+            },
+            (error) => {
+              record2.outcome = "failed";
+              record2.error = error instanceof Error ? error.message : String(error);
+            }
+          );
+          return new Proxy(rawCall, {
+            get(target, key) {
+              if (key === "toJSON") {
+                return () => `[pending tool call ${server}.${property} \u2014 did you forget await?]`;
+              }
+              if (key === "then" || key === "catch" || key === "finally") {
+                record2.observed = true;
+              }
+              const value = Reflect.get(target, key, target);
+              return typeof value === "function" ? value.bind(target) : value;
+            }
+          });
+        };
+        const tool = ((args = {}) => startCall(args, "json"));
+        tool.text = (args = {}) => startCall(args, "text");
+        tool.markdown = (args = {}) => startCall(args, "markdown");
+        tool.images = (args = {}) => startCall(args, "images");
+        tool.content = (args = {}) => startCall(args, "content");
+        tool.structuredContent = (args = {}) => startCall(args, "structuredContent");
+        tool.raw = (args = {}) => startCall(args, "raw");
+        return tool;
+      }
+    });
+  }
+  const tools = new Proxy(toolsByServer, {
+    get(target, property) {
+      if (typeof property !== "string" || PROXY_PROBE_PROPS.has(property)) return void 0;
+      if (property in target) return target[property];
+      throw new Error(
+        describeUnknownRunServer(
+          property,
+          servers.map((server) => server.id)
+        )
+      );
+    }
+  });
+  return {
+    runtime,
+    owned,
+    tools,
+    calls,
+    cancelQueued: (error) => queue.cancel(error)
+  };
+}
+function createVars(vars) {
+  return new Proxy({ ...vars }, {
+    get(target, property) {
+      if (typeof property !== "string" || PROXY_PROBE_PROPS.has(property)) return void 0;
+      if (property in target) return target[property];
+      const defined = Object.keys(target);
+      throw new Error(
+        `vars.${property} is not defined. Pass it with --var ${property}=value` + (defined.length > 0 ? ` (defined vars: ${defined.join(", ")}).` : " (no vars were passed).") + ` Use \`"${property}" in vars\` to test for optional vars.`
+      );
+    }
+  });
+}
+function createRunProcess() {
+  return new Proxy(globalThis.process, {
+    get(target, property) {
+      if (property === "argv") {
+        throw new McpRunUsageError(
+          "process.argv is unavailable in mcp run. Pass dynamic values with --var KEY=value and read them as vars.KEY."
+        );
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function concurrentOutcomeError(error, calls) {
+  if (calls.length < 2) return error;
+  const outcomes = calls.map((call) => ({
+    ref: call.ref,
+    outcome: call.outcome,
+    ...call.error ? { error: call.error } : {}
+  }));
+  const summary = outcomes.map((call) => `${call.ref}=${call.outcome}`).join(", ");
+  const message = `${error.message} Workflow call outcomes: ${summary}. Inspect state before retrying side-effecting calls.`;
+  return new McpRunToolError(error.server, error.tool, message, {
+    cause: error,
+    details: { ...error.details, message, calls: outcomes }
+  });
+}
+function positiveInteger(value, label, fallback) {
+  const parsed = value === void 0 ? fallback : Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new McpRunUsageError(`${label} expects a positive integer, got '${value ?? ""}'.`);
+  }
+  return parsed;
+}
+async function runMcpJavaScript(code, opts = {}) {
+  const timeoutMs = positiveInteger(
+    opts.timeoutMs ?? process.env.PI_RECIPES_MCP_RUN_TIMEOUT_MS,
+    "PI_RECIPES_MCP_RUN_TIMEOUT_MS",
+    DEFAULT_RUN_TIMEOUT_MS
+  );
+  const callTimeoutMs = positiveInteger(
+    opts.callTimeoutMs ?? process.env.PI_RECIPES_MCP_RUN_CALL_TIMEOUT_MS,
+    "PI_RECIPES_MCP_RUN_CALL_TIMEOUT_MS",
+    Math.min(DEFAULT_TOOL_CALL_TIMEOUT_MS, timeoutMs)
+  );
+  const maxCalls = positiveInteger(
+    opts.maxCalls ?? process.env.PI_RECIPES_MCP_RUN_MAX_CALLS,
+    "PI_RECIPES_MCP_RUN_MAX_CALLS",
+    DEFAULT_MAX_RUN_TOOL_CALLS
+  );
+  const maxConcurrentCalls = positiveInteger(
+    opts.maxConcurrentCalls ?? process.env.PI_RECIPES_MCP_RUN_MAX_CONCURRENCY,
+    "PI_RECIPES_MCP_RUN_MAX_CONCURRENCY",
+    DEFAULT_MAX_CONCURRENT_TOOL_CALLS
+  );
+  const deadlineMs = Date.now() + timeoutMs;
+  const { runtime, owned, tools, calls, cancelQueued } = await createTools({
+    callTimeoutMs,
+    maxCalls,
+    maxConcurrentCalls,
+    deadlineMs
+  });
+  const AsyncFunction = Object.getPrototypeOf(async function() {
+  }).constructor;
+  const run = new AsyncFunction("tools", "vars", "process", code);
+  let timeout;
+  let primaryError;
+  try {
+    let scriptError;
+    try {
+      await Promise.race([
+        run(tools, createVars(opts.vars ?? {}), createRunProcess()),
+        new Promise((_resolve, reject) => {
+          timeout = setTimeout(() => {
+            reject(
+              new McpRunTimeoutError(
+                `mcp run timed out after ${timeoutMs}ms. Remote side effects may already have occurred; inspect state before retrying.`
+              )
+            );
+          }, timeoutMs);
+        })
+      ]);
+    } catch (error) {
+      scriptError = error;
+    }
+    if (scriptError instanceof McpRunTimeoutError) {
+      cancelQueued(scriptError);
+      for (const call of calls) {
+        if (call.outcome === "pending") call.outcome = "outcome_unknown";
+      }
+      throw scriptError;
+    }
+    const unsafeAtExit = calls.filter(
+      (call) => !call.observed || call.outcome === "pending"
+    );
+    if (unsafeAtExit.length > 0) {
+      const remainingSettleMs = Math.max(0, Math.min(15e3, deadlineMs - Date.now()));
+      if (remainingSettleMs > 0) {
+        let settleTimer;
+        try {
+          await Promise.race([
+            Promise.allSettled(unsafeAtExit.map((call) => call.promise)),
+            new Promise((resolve2) => {
+              settleTimer = setTimeout(resolve2, remainingSettleMs);
+            })
+          ]);
+        } finally {
+          if (settleTimer) clearTimeout(settleTimer);
+        }
+      }
+      for (const call of unsafeAtExit) {
+        if (call.outcome === "pending") call.outcome = "outcome_unknown";
+      }
+      const remainingUnsafe = unsafeAtExit.filter(
+        (call) => !call.observed || call.outcome === "outcome_unknown"
+      );
+      if (scriptError instanceof McpRunToolError && remainingUnsafe.length === 0) {
+        throw concurrentOutcomeError(scriptError, calls);
+      }
+      const summary = unsafeAtExit.map(
+        (call) => `${call.ref}=${call.outcome}` + (call.error ? ` (${call.error})` : "")
+      ).join(", ");
+      throw new McpRunUsageError(
+        `mcp run: ${unsafeAtExit.length} tool call(s) were not awaited: ${summary}. Await or return every tool-call chain before the script exits; attaching .then/.catch without awaiting the chain is not enough. Remote side effects may already have occurred.` + (scriptError ? ` The script also failed: ${scriptError instanceof Error ? scriptError.message : String(scriptError)}.` : "")
+      );
+    }
+    if (scriptError) throw scriptError;
+  } catch (error) {
+    primaryError = error;
+    throw error;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    try {
+      await closeOwnedRuntime(runtime, owned);
+    } catch (closeError) {
+      if (primaryError === void 0) throw closeError;
+    }
+  }
+}
+var RUN_WATCHDOG_GRACE_MS = 2e3;
+function startRunWatchdog(timeoutMs) {
+  const worker = new Worker(
+    `const { workerData } = require("node:worker_threads");
+     const { writeSync } = require("node:fs");
+     setTimeout(() => {
+       writeSync(
+         2,
+         "mcp run: killed after " + workerData.limitMs + "ms. The script never yielded " +
+           "(synchronous busy-loop?) or ignored the timeout. Use await inside loops and " +
+           "set PI_RECIPES_MCP_RUN_TIMEOUT_MS to adjust the limit. Remote side effects " +
+           "may already have occurred; inspect state before retrying.\\n"
+       );
+       process.kill(process.pid, "SIGKILL");
+     }, workerData.limitMs);`,
+    { eval: true, workerData: { limitMs: timeoutMs + RUN_WATCHDOG_GRACE_MS } }
+  );
+  worker.unref();
+  return () => void worker.terminate();
+}
+async function runCode(args) {
+  const vars = {};
+  const positional = [];
+  let jsonErrors = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json-errors") {
+      jsonErrors = true;
+      continue;
+    }
+    const inline = arg.startsWith("--var=") ? arg.slice("--var=".length) : void 0;
+    const value = inline ?? (arg === "--var" ? args[++index] : void 0);
+    if (arg === "--var" || inline !== void 0) {
+      const eq = value?.indexOf("=") ?? -1;
+      if (value === void 0 || eq < 1) {
+        stderr.write("--var expects KEY=value.\n");
+        return 2;
+      }
+      vars[value.slice(0, eq)] = value.slice(eq + 1);
+      continue;
+    }
+    positional.push(arg);
+  }
+  const file = positional[0];
+  if (positional.length > 1) {
+    stderr.write("mcp run accepts at most one file path.\n");
+    return 2;
+  }
+  const code = file ? await readFile(file, "utf8") : await readStdin();
+  if (!code.trim()) {
+    stderr.write(
+      "mcp run: empty script. Pass a file path or pipe JavaScript on stdin (see `mcp run --help`).\n"
+    );
+    return 2;
+  }
+  let timeoutMs;
+  try {
+    timeoutMs = positiveInteger(
+      process.env.PI_RECIPES_MCP_RUN_TIMEOUT_MS,
+      "PI_RECIPES_MCP_RUN_TIMEOUT_MS",
+      DEFAULT_RUN_TIMEOUT_MS
+    );
+  } catch (error) {
+    stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 2;
+  }
+  const stopWatchdog = isMainThread ? startRunWatchdog(timeoutMs) : () => {
+  };
+  try {
+    await runMcpJavaScript(code, { vars, timeoutMs });
+  } catch (error) {
+    const message = error instanceof Error ? error.name === "Error" ? error.message : `${error.name}: ${error.message}` : String(error);
+    const prefixed = message.startsWith("mcp run") ? message : `mcp run: ${message}`;
+    const code2 = error instanceof McpRunUsageError ? 2 : 1;
+    if (jsonErrors) {
+      const remoteDetails = error instanceof McpRunToolError ? error.details : void 0;
+      stderr.write(
+        `${JSON.stringify({
+          error: {
+            ...remoteDetails,
+            code: remoteDetails?.code ?? (error instanceof McpRunUsageError ? "invalid_usage" : error instanceof McpRunToolError ? "tool_execution" : error instanceof McpRunTimeoutError ? "timeout" : "script_failure"),
+            message: remoteDetails?.message ?? prefixed,
+            retryable: remoteDetails?.retryable ?? false,
+            action: remoteDetails?.action ?? (error instanceof McpRunUsageError ? "correct_script" : error instanceof McpRunTimeoutError ? "inspect_state" : "inspect_error"),
+            ...error instanceof McpRunTimeoutError ? { outcome: error.outcome } : {},
+            ...error instanceof McpRunToolError ? { server: error.server, tool: error.tool } : {}
+          }
+        })}
+`
+      );
+    } else {
+      stderr.write(`${prefixed}
+`);
+    }
+    return code2;
+  } finally {
+    stopWatchdog();
+  }
+  return 0;
+}
+function createDelegatedErrorFilter(write) {
+  let buffer = "";
+  let sawOAuthMetadataError = false;
+  const emit = (line) => {
+    if (/^\s+at\s\S/.test(line)) return;
+    if (/trying to load OAuth metadata/.test(line)) sawOAuthMetadataError = true;
+    const safe = line.replace(
+      /Tool '([^']+)' is not accessible on server '([^']+)' \(blocked by configuration\)/g,
+      "Tool '$1' is not enabled on server '$2' in this recipe session"
+    ).replace(
+      /Failed to resolve header 'Authorization' for server '([^']+)': Environment variable\(s\) [A-Z0-9_, ]+ must be set for MCP header substitution\./g,
+      "Authentication is required for MCP server '$1'. Ask the user to authenticate this MCP connection outside the agent session, then retry."
+    ).replace(
+      /Next: run ['`]mcporter auth [^'`]+['`] to finish authentication\.?/gi,
+      "Authentication is required. Ask the user to authenticate this MCP connection outside the agent session, then retry."
+    );
+    write(safe);
+  };
+  return {
+    push(chunk) {
+      buffer += chunk;
+      let index = buffer.indexOf("\n");
+      while (index !== -1) {
+        emit(buffer.slice(0, index + 1));
+        buffer = buffer.slice(index + 1);
+        index = buffer.indexOf("\n");
+      }
+    },
+    flush() {
+      if (buffer) emit(buffer);
+      buffer = "";
+      if (sawOAuthMetadataError) {
+        write(
+          "Hint: this server is called with a configured bearer token; the token may be invalid or expired.\n"
+        );
+        sawOAuthMetadataError = false;
+      }
+    }
+  };
+}
+function duplicateCallArgumentKeys(args) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const token of args.slice(1)) {
+    const rawKey = token.match(/^([A-Za-z_][A-Za-z0-9_.-]*)=/)?.[1];
+    if (!rawKey) continue;
+    const key = rawKey.replace(
+      /-([a-zA-Z0-9])/g,
+      (_match, char) => char.toUpperCase()
+    );
+    if (seen.has(key)) duplicates.add(key);
+    seen.add(key);
+  }
+  return [...duplicates];
+}
+function callJsonArgumentError(args) {
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      const value = args[index + 1];
+      if (value === void 0 || value.startsWith("--") && value !== "-") {
+        return `mcp call: ${arg} expects a JSON object or - for stdin. Example: mcp call server.tool --json '{"tags":["a","b"]}'`;
+      }
+      index += 1;
+      continue;
+    }
+    if (arg === "--json=") {
+      return `mcp call: ${arg.slice(0, -1)} expects a JSON object or - for stdin.`;
+    }
+  }
+  return null;
+}
+function malformedCallExpression(args) {
+  const ref = args.find((arg) => !arg.startsWith("-"));
+  if (!ref || !/[()]/.test(ref)) return null;
+  return `mcp call: function-call expressions are unavailable. Use mcp call <server>.<tool> key=value or --json for structured arguments.`;
+}
+async function callWithMcporter(args) {
+  const shared = currentMcpCommandContext()?.runtime;
+  if (shared) return callWithSharedRuntime(shared, args);
+  const previousDisableAutorun = process.env.MCPORTER_DISABLE_AUTORUN;
+  const previousExitCode = process.exitCode;
+  process.env.MCPORTER_DISABLE_AUTORUN = "1";
+  process.exitCode = void 0;
+  let runtime;
+  let owned = false;
+  try {
+    ({ runtime, owned } = await acquireRuntime());
+    const { handleCall } = await import("./cli-UV4QJZZM.js");
+    await handleCall(runtime, args);
+    return process.exitCode ?? 0;
+  } finally {
+    process.exitCode = previousExitCode;
+    if (previousDisableAutorun === void 0) {
+      delete process.env.MCPORTER_DISABLE_AUTORUN;
+    } else {
+      process.env.MCPORTER_DISABLE_AUTORUN = previousDisableAutorun;
+    }
+    if (runtime && owned) await runtime.close().catch(() => {
+    });
+  }
+}
+async function callWithSharedRuntime(runtime, args) {
+  const selector = args[0];
+  const separator = selector?.indexOf(".") ?? -1;
+  if (!selector || separator <= 0 || separator === selector.length - 1) {
+    stderr.write("mcp call requires <server>.<tool>.\n");
+    return 2;
+  }
+  const server = selector.slice(0, separator);
+  const tool = selector.slice(separator + 1);
+  const values = {};
+  let timeoutMs;
+  let output;
+  for (let index = 1; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === "--no-oauth") continue;
+    if (token === "--json" || token.startsWith("--json=")) {
+      const raw2 = token === "--json" ? args[++index] : token.slice("--json=".length);
+      const source = raw2 === "-" ? await readStdin() : raw2;
+      if (!source) {
+        stderr.write("mcp call: --json expects an object or -.\n");
+        return 2;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(source);
+      } catch {
+        stderr.write("mcp call: --json contains invalid JSON.\n");
+        return 2;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        stderr.write("mcp call: --json expects a JSON object.\n");
+        return 2;
+      }
+      Object.assign(values, parsed);
+      continue;
+    }
+    if (token === "--timeout" || token.startsWith("--timeout=")) {
+      const raw2 = token === "--timeout" ? args[++index] : token.slice("--timeout=".length);
+      const parsed = Number(raw2);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        stderr.write("mcp call: --timeout expects a positive number.\n");
+        return 2;
+      }
+      timeoutMs = parsed;
+      continue;
+    }
+    if (token === "--output" || token.startsWith("--output=")) {
+      const raw2 = token === "--output" ? args[++index] : token.slice("--output=".length);
+      if (!raw2 || !["text", "markdown", "json", "raw"].includes(raw2)) {
+        stderr.write("mcp call: --output expects text, markdown, json, or raw.\n");
+        return 2;
+      }
+      output = raw2;
+      continue;
+    }
+    const equals = token.indexOf("=");
+    if (equals <= 0) {
+      stderr.write(`mcp call: invalid argument '${token}'.
+`);
+      return 2;
+    }
+    const key = token.slice(0, equals).replace(/-([a-zA-Z0-9])/g, (_match, char) => char.toUpperCase());
+    let raw = token.slice(equals + 1);
+    if (raw.startsWith("@@")) raw = raw.slice(1);
+    else if (raw.startsWith("@")) raw = await readFile(raw.slice(1), "utf8");
+    try {
+      values[key] = JSON.parse(raw);
+    } catch {
+      values[key] = raw;
+    }
+  }
+  try {
+    const call = runtime.callTool(server, tool, {
+      args: values,
+      timeoutMs,
+      disableOAuth: true
+    });
+    const signal = currentMcpCommandContext()?.signal;
+    let cancelled;
+    const raw = signal ? await Promise.race([
+      call,
+      new Promise((_resolve, reject) => {
+        cancelled = () => reject(new Error("MCP command cancelled."));
+        if (signal.aborted) cancelled();
+        else signal.addEventListener("abort", cancelled, { once: true });
+      })
+    ]).finally(() => {
+      if (cancelled) signal.removeEventListener("abort", cancelled);
+    }) : await call;
+    const result = createCallResult(raw);
+    let rendered;
+    if (output === "raw") rendered = raw;
+    else if (output === "json") rendered = result.json();
+    else if (output === "markdown") rendered = result.markdown();
+    else if (output === "text") rendered = result.text();
+    else rendered = result.json() ?? result.structuredContent() ?? result.text() ?? raw;
+    const serialized = typeof rendered === "string" ? rendered : JSON.stringify(rendered, null, 2);
+    const configuredLimit = process.env.PI_RECIPES_MCP_MAX_OUTPUT_BYTES;
+    if (configuredLimit !== void 0) {
+      const limit = Number(configuredLimit);
+      if (!Number.isSafeInteger(limit) || limit <= 0) {
+        stderr.write("PI_RECIPES_MCP_MAX_OUTPUT_BYTES must be a positive integer.\n");
+        return 2;
+      }
+      const size = Buffer.byteLength(serialized, "utf8");
+      if (size > limit) {
+        stderr.write(
+          `MCP result is ${size} bytes, exceeding PI_RECIPES_MCP_MAX_OUTPUT_BYTES=${limit}. Use tool pagination or a narrower field projection.
+`
+        );
+        return 1;
+      }
+    }
+    stdout.write(`${serialized}
+`);
+    return asRecord(raw).isError === true ? 1 : 0;
+  } catch (error) {
+    stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+async function main(args = process.argv.slice(2)) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h" || args[0] === "help" && args.length === 1) {
+    stdout.write(`${mcpCliHelpText()}
+`);
+    return 0;
+  }
+  if (args[0] === "search" && isHelpArg(args[1])) {
+    stdout.write(`${mcpSearchHelpText()}
+`);
+    return 0;
+  }
+  if (args[0] === "list" && args.slice(1).some(isHelpArg)) {
+    stdout.write(`${mcpListHelpText()}
+`);
+    return 0;
+  }
+  if (args[0] === "call" && args.slice(1).some(isHelpArg)) {
+    stdout.write(`${mcpCallHelpText()}
+`);
+    return 0;
+  }
+  if (args[0] === "run" && isHelpArg(args[1])) {
+    stdout.write(`${mcpRunHelpText()}
+`);
+    return 0;
+  }
+  pinSessionMcporterConfig();
+  if (args[0] === "run") return runCode(args.slice(1));
+  if (args[0] === "search") return searchCatalog(args.slice(1));
+  if (args[0] === "call") {
+    const malformed = malformedCallExpression(args.slice(1));
+    if (malformed) {
+      stderr.write(`${malformed}
+`);
+      return 2;
+    }
+    const jsonArgumentError = callJsonArgumentError(args.slice(1));
+    if (jsonArgumentError) {
+      stderr.write(`${jsonArgumentError}
+`);
+      return 2;
+    }
+  }
+  let validated;
+  try {
+    validated = validateDelegatedMcpCommand(args, await sessionCliPolicy());
+  } catch (error) {
+    stderr.write(`mcp: failed to load the session MCP policy: ${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+  if (validated.error) {
+    stderr.write(`mcp: ${validated.error}
+`);
+    return 2;
+  }
+  if (!validated.command) {
+    stderr.write("mcp: invalid session command policy result.\n");
+    return 1;
+  }
+  if (args[0] === "call") {
+    const duplicates = duplicateCallArgumentKeys(
+      validated.command.args.slice(1)
+    );
+    if (duplicates.length > 0) {
+      stderr.write(
+        `mcp call: argument${duplicates.length === 1 ? "" : "s"} ${duplicates.map((key) => `'${key}'`).join(", ")} ${duplicates.length === 1 ? "was" : "were"} passed more than once. Pass each argument exactly once.
+`
+      );
+      return 2;
+    }
+  }
+  const delegatedArgs = validated.command.args;
+  if (delegatedArgs[0] === "list") return compactList(delegatedArgs);
+  if (delegatedArgs[0] === "call") {
+    return callWithMcporter(delegatedArgs.slice(1));
+  }
+  stderr.write(`mcp: command '${delegatedArgs[0]}' is unavailable in recipe sessions.
+`);
+  return 2;
+}
+async function executeMcpCommand(opts) {
+  const context = {
+    runtime: opts.runtime,
+    stdin: opts.stdin,
+    stdout: opts.stdout,
+    stderr: opts.stderr,
+    signal: opts.signal
+  };
+  return runWithMcpCommandContext(context, () => main(opts.args));
+}
+
+export {
+  installMcpCommandIoRouting,
+  MCP_DAEMON_SOCKET_ENV,
+  MCP_DAEMON_TOKEN_ENV,
+  MCP_DAEMON_FINGERPRINT_ENV,
+  MCP_DAEMON_PARENT_PID_ENV,
+  MCP_DAEMON_MAX_FRAME_BYTES,
+  serializeMcpDaemonEnvelope,
+  discoverMcpCatalogs,
+  executeMcpCommand
+};