@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{pi-mono-adapter-m6dvv0dz.js → pi-mono-adapter-g7qzvr3v.js}

@@ -1,63 +1,90 @@
+import {
+  readPkgVersion
+} from "./cli-gt4hxb8p.js";
 import {
   DefaultResourceLoader,
   ModelRuntime,
   SessionManager,
+  SettingsManager,
   createAgentSession,
-  getAgentDir
-} from "./cli-s8eet254.js";
-import"./cli-5bfdm1ah.js";
+  createCodemodeExtension,
+  createMcpExtension,
+  createToolSearchExtension
+} from "./cli-jajnsm8q.js";
+import"./cli-0x01kwrd.js";
+import"./cli-741yb0xx.js";
+import"./cli-447dt1h3.js";
 import {
-  readPkgVersion
-} from "./cli-2djtr51b.js";
+  getAgentDir,
+  setEmbeddedQuickJSWasmPath
+} from "./cli-d5czme6m.js";
+import"./cli-5bfdm1ah.js";
+import"./cli-0m7wct0d.js";
 import {
   summarizeSession
-} from "./cli-cw9zck8j.js";
+} from "./cli-xjcywfsf.js";
 import {
   checkToolLoop,
   clearToolHistory
 } from "./cli-hp1n6zq3.js";
+import {
+  fetchInstalledMcpServers
+} from "./cli-tng3131n.js";
 import {
   applyReasoningEffort
-} from "./cli-h967nb6r.js";
-import"./cli-vj6h9kc2.js";
+} from "./cli-4derpgyk.js";
 import"./cli-7nxes1hs.js";
 import {
   buildRatingsFromLlm,
   fetchRetrievalsForTask,
   getMemoryRaterNames,
   postRatings
-} from "./cli-tt9k8r35.js";
-import"./cli-vhjwh6cz.js";
+} from "./cli-cpvsaqsw.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
+import {
+  McpHttpClient
+} from "./cli-epan13p1.js";
+import"./cli-12tszpk9.js";
+import"./cli-ygwm91nt.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterBaseUrl
 } from "./cli-3dpj7atn.js";
 import {
-  exports_typebox,
   getBuiltinModel,
   getBuiltinModels
-} from "./cli-aw1jwp1r.js";
+} from "./cli-10nhj6xq.js";
 import {
-  McpHttpClient
-} from "./cli-epan13p1.js";
+  exports_typebox
+} from "./cli-rb9m6rpe.js";
+import"./cli-rykfmgwg.js";
 import"./cli-bsakbbkm.js";
+import"./cli-trc24wk2.js";
 import"./cli-3er6gcsn.js";
-import"./cli-cqt19wg6.js";
-import"./cli-ej6gbxfb.js";
+import {
+  CORE_TOOLS,
+  init_tool_config
+} from "./cli-3qhyh31j.js";
+import"./cli-1a2j50m0.js";
+import {
+  init_env_flag,
+  parseEnvFlag
+} from "./cli-ej6gbxfb.js";
+import"./cli-kmcpfwn2.js";
 import"./cli-sd0mxa3c.js";
 import"./cli-w5e1d1vv.js";
 import {
   init_secret_scrubber,
   scrubSecrets
 } from "./cli-r2ap2czm.js";
-import"./cli-pw9rj5t9.js";
-import"./cli-5b6b62tz.js";
+import"./cli-0xqde53b.js";
+import"./cli-pqetb83f.js";
+import"./cli-13hw4z91.js";
 import"./cli-btbzvq95.js";
 import"./cli-1m2e086m.js";
-import"./cli-mcnhgnn1.js";
+import"./cli-ykk5jaax.js";
 import"./cli-bzr0ftht.js";
 import {
   __require,
@@ -68,6 +95,15 @@ import {
 import { existsSync, lstatSync, symlinkSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 
+// node_modules/quickjs-wasi/quickjs.wasm
+var quickjs_default = "./quickjs-r1pq2107.wasm";
+
+// src/providers/pi-codemode-runtime.ts
+setEmbeddedQuickJSWasmPath(quickjs_default);
+
+// src/providers/pi-mono-adapter.ts
+init_tool_config();
+
 // src/utils/aws-error-classifier.ts
 var AWS_ERROR_RULES = [
   {
@@ -121,6 +157,7 @@ function classifyAwsSdkError(text) {
 }
 
 // src/providers/pi-mono-adapter.ts
+init_env_flag();
 init_secret_scrubber();
 
 // src/providers/pi-mono-extension.ts
@@ -394,6 +431,13 @@ function createSwarmHooksExtension(config) {
   return (pi) => {
     let lastContextPostTime = 0;
     pi.on("session_start", async (_event, _ctx) => {
+      for (const [name, server] of Object.entries(config.mcpServers ?? {})) {
+        try {
+          pi.registerMcpServer(name, server);
+        } catch (err) {
+          console.warn(`[pi] Failed to register MCP server "${name}": ${err}`);
+        }
+      }
       fireAndForget(`${config.apiUrl}/ping`, {
         method: "POST",
         headers: apiHeaders(config)
@@ -692,12 +736,27 @@ async function checkPiMonoCredentials(env, opts = {}) {
 function jsonSchemaToTypeBox(schema) {
   return exports_typebox.Unsafe(schema);
 }
-function mcpToolsToDefinitions(mcpClient, tools) {
+var SWARM_TOOL_NAMESPACE = { name: "agent-swarm" };
+function isPiToolDeferralEnabled(env = process.env) {
+  return parseEnvFlag(env.PI_TOOL_DEFERRAL, false);
+}
+function isPiCodemodeEnabled(env = process.env) {
+  return parseEnvFlag(env.PI_CODEMODE, false);
+}
+function isCoreSwarmTool(tool) {
+  return CORE_TOOLS.has(tool.name) || tool._meta?.["anthropic/alwaysLoad"] === true;
+}
+function mcpToolsToDefinitions(mcpClient, tools, options = {}) {
   return tools.map((tool) => ({
     name: tool.name,
     label: tool.name,
     description: tool.description || tool.name,
     parameters: jsonSchemaToTypeBox(tool.inputSchema),
+    ...tool.outputSchema && { outputSchema: jsonSchemaToTypeBox(tool.outputSchema) },
+    ...options.namespace && { namespace: options.namespace },
+    ...options.deferNonCore && {
+      exposure: isCoreSwarmTool(tool) ? "direct" : "deferred"
+    },
     async execute(_toolCallId, params) {
       const result = await mcpClient.callTool(tool.name, params);
       const text = result.content.map((c) => c.text ?? "").filter(Boolean).join(`
@@ -707,7 +766,10 @@ function mcpToolsToDefinitions(mcpClient, tools) {
       }
       return {
         content: [{ type: "text", text: text || "(no output)" }],
-        details: undefined
+        details: undefined,
+        ...result.structuredContent && {
+          structuredContent: result.structuredContent
+        }
       };
     }
   }));
@@ -1192,20 +1254,181 @@ class PiMonoSession {
     }
   }
 }
+function createSwarmMcpExtension() {
+  return createMcpExtension({
+    loadConfig: () => ({ servers: [], errors: [], autoEnableCodemode: false })
+  });
+}
+function piExtensionFactories(swarmExtension, features) {
+  const factories = [swarmExtension];
+  if (features.toolDeferral)
+    factories.push(createToolSearchExtension());
+  if (features.installedMcp)
+    factories.push(createSwarmMcpExtension());
+  if (features.codemode)
+    factories.push(createBoundedCodemodeExtension());
+  return factories;
+}
+var PI_CODEMODE_TIMEOUT_MS = 120000;
+var PI_CODEMODE_MAX_NESTED_CALLS = 32;
+var PI_CODEMODE_MAX_CONCURRENT_CALLS = 4;
+var DEFAULT_CODEMODE_LIMITS = {
+  timeoutMs: PI_CODEMODE_TIMEOUT_MS,
+  maxNestedCalls: PI_CODEMODE_MAX_NESTED_CALLS,
+  maxConcurrentCalls: PI_CODEMODE_MAX_CONCURRENT_CALLS
+};
+function createBoundedCodemodeExtension(limits = DEFAULT_CODEMODE_LIMITS) {
+  const codemode = createCodemodeExtension({ mode: "on", models: false });
+  return (pi) => codemode(new Proxy(pi, {
+    get(target, prop) {
+      if (prop === "registerTool") {
+        return (tool) => target.registerTool(boundCodemodeTool(tool, limits));
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  }));
+}
+function boundCodemodeTool(tool, limits) {
+  return {
+    ...tool,
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      const script = new AbortController;
+      const stop = (message) => {
+        if (!script.signal.aborted)
+          script.abort(new Error(message));
+      };
+      const onOuterAbort = () => script.abort(signal?.reason ?? new Error("Codemode script cancelled"));
+      if (signal?.aborted)
+        onOuterAbort();
+      else
+        signal?.addEventListener("abort", onOuterAbort, { once: true });
+      const timer = setTimeout(() => stop(`Codemode script exceeded its ${limits.timeoutMs} ms deadline`), limits.timeoutMs);
+      let started = 0;
+      let running = 0;
+      const waiters = [];
+      const release = () => {
+        running--;
+        waiters.shift()?.();
+      };
+      const executeTool = async (name, args, options) => {
+        if (script.signal.aborted)
+          throw new Error("Codemode script already stopped");
+        if (++started > limits.maxNestedCalls) {
+          const message = `Codemode script exceeded its budget of ${limits.maxNestedCalls} nested tool calls`;
+          stop(message);
+          throw new Error(message);
+        }
+        while (running >= limits.maxConcurrentCalls) {
+          await new Promise((resolve) => {
+            waiters.push(resolve);
+            script.signal.addEventListener("abort", () => resolve(), { once: true });
+          });
+          if (script.signal.aborted) {
+            waiters.shift()?.();
+            throw new Error("Codemode script already stopped");
+          }
+        }
+        running++;
+        try {
+          return await ctx.executeTool(name, args, {
+            ...options,
+            signal: options?.signal ?? script.signal
+          });
+        } finally {
+          release();
+        }
+      };
+      const boundedCtx = ctx ? Object.defineProperties({}, {
+        ...Object.getOwnPropertyDescriptors(ctx),
+        executeTool: { value: executeTool, enumerable: true }
+      }) : ctx;
+      try {
+        return await tool.execute(toolCallId, params, script.signal, onUpdate, boundedCtx);
+      } finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onOuterAbort);
+      }
+    }
+  };
+}
+function escapePiConfigValue(value) {
+  const escaped = value.replace(/\$/g, () => "$$");
+  return escaped.startsWith("!") ? `$${escaped}` : escaped;
+}
+function escapeValues(values) {
+  const out = {};
+  if (!values || typeof values !== "object")
+    return out;
+  for (const [key, value] of Object.entries(values)) {
+    if (typeof value === "string")
+      out[key] = escapePiConfigValue(value);
+  }
+  return out;
+}
+function toPiMcpServers(installed) {
+  const servers = {};
+  for (const [name, entry] of Object.entries(installed ?? {})) {
+    if (typeof entry.command === "string") {
+      servers[name] = {
+        type: "stdio",
+        command: entry.command,
+        args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+        env: escapeValues(entry.env),
+        exposure: "direct"
+      };
+    } else if (typeof entry.url === "string") {
+      servers[name] = {
+        type: "http",
+        url: entry.url,
+        headers: escapeValues(entry.headers),
+        exposure: "direct"
+      };
+    }
+  }
+  return servers;
+}
+function piDefaultToolAdditions(features) {
+  const additions = [];
+  if (features.toolDeferral)
+    additions.push("+tool_search");
+  if (features.codemode)
+    additions.push("+codemode");
+  return additions;
+}
+async function createPiResourceLoader(opts) {
+  const settingsManager = SettingsManager.create(opts.cwd, opts.agentDir, {
+    projectTrusted: false
+  });
+  const resourceLoader = new DefaultResourceLoader({
+    cwd: opts.cwd,
+    agentDir: opts.agentDir,
+    settingsManager,
+    noContextFiles: true,
+    appendSystemPrompt: opts.systemPrompt ? [opts.systemPrompt] : undefined,
+    extensionFactories: opts.extensionFactories
+  });
+  await resourceLoader.reload();
+  return { resourceLoader, settingsManager };
+}
 
 class PiMonoAdapter {
   name = "pi";
-  traits = {
-    hasMcp: true,
-    nativeSkillDiscovery: true,
-    hasLocalEnvironment: true,
-    steerModes: ["steer", "queue"]
-  };
+  get traits() {
+    return {
+      hasMcp: true,
+      hasToolSearch: isPiToolDeferralEnabled(),
+      nativeSkillDiscovery: true,
+      hasLocalEnvironment: true,
+      steerModes: ["steer", "queue"]
+    };
+  }
   lastCwd = ".";
   async createSession(config) {
     this.lastCwd = config.cwd;
     console.log(`\x1B[2m[${config.role}]\x1B[0m \x1B[35m▸\x1B[0m Spawning pi-mono for task ${config.taskId.slice(0, 8)}`);
     const createdSymlink = createAgentsMdSymlink(config.cwd);
+    const deferTools = isPiToolDeferralEnabled();
     let customTools = [];
     if (config.apiUrl && config.apiKey) {
       try {
@@ -1216,47 +1439,20 @@ class PiMonoAdapter {
         }
         await mcpClient.initialize();
         const tools = await mcpClient.listTools();
-        customTools = mcpToolsToDefinitions(mcpClient, tools);
-        console.log(`\x1B[2m[${config.role}]\x1B[0m Discovered ${tools.length} MCP tools from swarm`);
+        customTools = mcpToolsToDefinitions(mcpClient, tools, {
+          deferNonCore: deferTools,
+          namespace: SWARM_TOOL_NAMESPACE
+        });
+        const deferredCount = deferTools ? tools.filter((t) => !isCoreSwarmTool(t)).length : 0;
+        console.log(`\x1B[2m[${config.role}]\x1B[0m Discovered ${tools.length} MCP tools from swarm` + (deferTools ? ` (${deferredCount} deferred behind tool_search)` : ""));
       } catch (err) {
         console.warn(`\x1B[33m[${config.role}] Failed to discover MCP tools: ${err}\x1B[0m`);
       }
-      try {
-        const mcpServersRes = await fetch(`${config.apiUrl}/api/agents/${config.agentId}/mcp-servers?resolveSecrets=true`, {
-          headers: {
-            Authorization: `Bearer ${config.apiKey}`,
-            "X-Agent-ID": config.agentId
-          }
-        });
-        if (mcpServersRes.ok) {
-          const mcpServersData = await mcpServersRes.json();
-          const httpServers = mcpServersData.servers.filter((s) => s.isActive && s.isEnabled && (s.transport === "http" || s.transport === "sse") && s.url);
-          for (const srv of httpServers) {
-            try {
-              const srvClient = new McpHttpClient(srv.url, "", "");
-              srvClient.useRawUrl = true;
-              let parsedHeaders = {};
-              try {
-                parsedHeaders = srv.headers ? JSON.parse(srv.headers) : {};
-              } catch {}
-              srvClient.customHeaders = {
-                ...parsedHeaders,
-                ...srv.resolvedHeaders || {}
-              };
-              await srvClient.initialize();
-              const srvTools = await srvClient.listTools();
-              const prefixed = mcpToolsToDefinitions(srvClient, srvTools).map((t) => ({
-                ...t,
-                name: `mcp__${srv.name}__${t.name}`
-              }));
-              customTools.push(...prefixed);
-              console.log(`\x1B[2m[${config.role}]\x1B[0m Discovered ${srvTools.length} tools from MCP server "${srv.name}"`);
-            } catch (srvErr) {
-              console.warn(`\x1B[33m[${config.role}] Failed to discover tools from MCP server "${srv.name}": ${srvErr}\x1B[0m`);
-            }
-          }
-        }
-      } catch {}
+    }
+    const installedMcpServers = config.apiUrl && config.apiKey && config.agentId ? await fetchInstalledMcpServers(config.apiUrl, config.apiKey, config.agentId, "claude") : null;
+    const piMcpServers = toPiMcpServers(installedMcpServers);
+    if (Object.keys(piMcpServers).length > 0) {
+      console.log(`\x1B[2m[${config.role}]\x1B[0m Registering ${Object.keys(piMcpServers).length} installed MCP server(s) with pi`);
     }
     const sessionEnv = config.env ?? process.env;
     await ensureOpenRouterModelsOverride(getAgentDir(), sessionEnv);
@@ -1269,14 +1465,27 @@ class PiMonoAdapter {
       agentId: config.agentId,
       taskId: config.taskId,
       isLead: config.role === "lead",
-      env: sessionEnv
+      env: sessionEnv,
+      mcpServers: piMcpServers
     });
-    const resourceLoader = new DefaultResourceLoader({
+    const features = {
+      toolDeferral: deferTools,
+      installedMcp: Object.keys(piMcpServers).length > 0,
+      codemode: isPiCodemodeEnabled()
+    };
+    if (features.codemode) {
+      console.log(`\x1B[2m[${config.role}]\x1B[0m codemode on`);
+    }
+    const { resourceLoader, settingsManager } = await createPiResourceLoader({
       cwd: config.cwd,
       agentDir: getAgentDir(),
-      appendSystemPrompt: config.systemPrompt ? [config.systemPrompt] : undefined,
-      extensionFactories: [swarmExtension]
+      systemPrompt: config.systemPrompt,
+      extensionFactories: piExtensionFactories(swarmExtension, features)
     });
+    const extraDefaultTools = piDefaultToolAdditions(features);
+    if (extraDefaultTools.length > 0) {
+      settingsManager.applyOverrides({ defaultTools: extraDefaultTools });
+    }
     const reasoningApplication = applyReasoningEffort("pi", config.model, config.reasoningEffort);
     const reasoningSessionOptions = reasoningApplication.kind === "pi-session" ? reasoningApplication.sessionOptions : {};
     const appliedReasoningEffort = reasoningApplication.kind === "pi-session" ? config.reasoningEffort ?? null : null;
@@ -1285,10 +1494,12 @@ class PiMonoAdapter {
       model,
       customTools,
       resourceLoader,
+      settingsManager,
       modelRuntime,
       ...reasoningSessionOptions
     };
     const { session } = await createAgentSession(sessionOptions);
+    await session.bindExtensions({});
     return new PiMonoSession(session, config, createdSymlink, appliedReasoningEffort);
   }
   async canResume(sessionId) {
@@ -1305,13 +1516,27 @@ class PiMonoAdapter {
   }
 }
 export {
+  PI_CODEMODE_MAX_CONCURRENT_CALLS,
+  PI_CODEMODE_MAX_NESTED_CALLS,
+  PI_CODEMODE_TIMEOUT_MS,
   PiMonoAdapter,
   PiMonoSession,
+  SWARM_TOOL_NAMESPACE,
+  boundCodemodeTool,
   checkPiMonoCredentials,
+  createBoundedCodemodeExtension,
+  createPiResourceLoader,
   createPiRuntimeAuth,
+  createSwarmMcpExtension,
   ensureOpenRouterModelsOverride,
   extractPiAssistantText,
+  isCoreSwarmTool,
+  isPiCodemodeEnabled,
+  isPiToolDeferralEnabled,
   mcpToolsToDefinitions,
+  piDefaultToolAdditions,
+  piExtensionFactories,
   resolveModel,
-  runBedrockSdkProbeAndEnumerate
+  runBedrockSdkProbeAndEnumerate,
+  toPiMcpServers
 };

package/dist/pricing-refresh-wx0tp7cb.js

@@ -0,0 +1,39 @@
+import {
+  MODEL_CATALOG_FORCE_COOLDOWN_MS,
+  MODEL_CATALOG_FRESH_MS,
+  PRICING_REFRESH_INTERVAL_MS,
+  refreshModelCatalog,
+  refreshPricingFromModelsDev,
+  requestModelCatalogRefresh,
+  resetModelCatalogRefreshGuardForTests,
+  startPricingRefreshLoop
+} from "./cli-tfky2838.js";
+import"./cli-vctdqs5h.js";
+import"./cli-qydf22qq.js";
+import"./cli-3qhyh31j.js";
+import"./cli-ktmyrtpn.js";
+import"./cli-r1mxd1xh.js";
+import"./cli-n7h1kqpf.js";
+import"./cli-ptr8h7kp.js";
+import"./cli-dv6cdjs2.js";
+import"./cli-1a2j50m0.js";
+import"./cli-0wgxmwf6.js";
+import"./cli-ywybs5as.js";
+import"./cli-ej6gbxfb.js";
+import"./cli-kmcpfwn2.js";
+import"./cli-sd0mxa3c.js";
+import"./cli-w5e1d1vv.js";
+import"./cli-0q3avq3s.js";
+import"./cli-r2ap2czm.js";
+import"./cli-zf8jjwex.js";
+import"./cli-bc05qbss.js";
+export {
+  MODEL_CATALOG_FORCE_COOLDOWN_MS,
+  MODEL_CATALOG_FRESH_MS,
+  PRICING_REFRESH_INTERVAL_MS,
+  refreshModelCatalog,
+  refreshPricingFromModelsDev,
+  requestModelCatalogRefresh,
+  resetModelCatalogRefreshGuardForTests,
+  startPricingRefreshLoop
+};

package/dist/{rbac-roles-c9wqz83x.js → rbac-roles-8tzawacv.js}

@@ -1,26 +1,28 @@
 import {
   PermissionVerbSchema
-} from "./cli-g8djp6qe.js";
+} from "./cli-tmqt7dpj.js";
 import {
   getDb,
   getDbClient,
   init_db
-} from "./cli-47m6dkd3.js";
-import"./cli-4198qc9v.js";
-import"./cli-3gmcwfyx.js";
-import"./cli-ggm92wcn.js";
-import"./cli-19jenss3.js";
-import"./cli-dv6cdjs2.js";
+} from "./cli-qydf22qq.js";
+import"./cli-3qhyh31j.js";
+import"./cli-ktmyrtpn.js";
+import"./cli-r1mxd1xh.js";
 import"./cli-n7h1kqpf.js";
-import"./cli-de1396j2.js";
-import"./cli-cqt19wg6.js";
+import"./cli-ptr8h7kp.js";
+import"./cli-dv6cdjs2.js";
+import"./cli-1a2j50m0.js";
+import"./cli-0wgxmwf6.js";
+import"./cli-ywybs5as.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
 } from "./cli-ej6gbxfb.js";
+import"./cli-kmcpfwn2.js";
 import"./cli-sd0mxa3c.js";
 import"./cli-w5e1d1vv.js";
-import"./cli-c07r9a2m.js";
+import"./cli-0q3avq3s.js";
 import"./cli-r2ap2czm.js";
 import"./cli-zf8jjwex.js";
 import"./cli-bc05qbss.js";

package/dist/{render-v2-gryrh9h8.js → render-v2-mm7zswb8.js}

@@ -16,24 +16,26 @@ import {
   slackErrorSummary,
   streamOutcomeCard,
   withStatusLead
-} from "./cli-j57qkrpq.js";
+} from "./cli-azhgzetg.js";
 import"./cli-q51yprfq.js";
 import"./cli-3er6gcsn.js";
 import"./cli-2658f6at.js";
 import"./cli-yatxqynm.js";
-import"./cli-47m6dkd3.js";
-import"./cli-4198qc9v.js";
-import"./cli-3gmcwfyx.js";
-import"./cli-ggm92wcn.js";
-import"./cli-19jenss3.js";
-import"./cli-dv6cdjs2.js";
+import"./cli-qydf22qq.js";
+import"./cli-3qhyh31j.js";
+import"./cli-ktmyrtpn.js";
+import"./cli-r1mxd1xh.js";
 import"./cli-n7h1kqpf.js";
-import"./cli-de1396j2.js";
-import"./cli-cqt19wg6.js";
+import"./cli-ptr8h7kp.js";
+import"./cli-dv6cdjs2.js";
+import"./cli-1a2j50m0.js";
+import"./cli-0wgxmwf6.js";
+import"./cli-ywybs5as.js";
 import"./cli-ej6gbxfb.js";
+import"./cli-kmcpfwn2.js";
 import"./cli-sd0mxa3c.js";
 import"./cli-w5e1d1vv.js";
-import"./cli-c07r9a2m.js";
+import"./cli-0q3avq3s.js";
 import"./cli-r2ap2czm.js";
 import"./cli-bd957dgb.js";
 import"./cli-pzxba7gw.js";

package/dist/runtime-zyssgse0.js

@@ -0,0 +1,24 @@
+import {
+  McpOAuthCredentialStore,
+  McpServerConnection,
+  McpServerLog,
+  McpSignInCancelledError,
+  createDefaultTransport,
+  signInMcpServer
+} from "./cli-v7fn5gms.js";
+import"./cli-447dt1h3.js";
+import"./cli-d5czme6m.js";
+import"./cli-5bfdm1ah.js";
+import"./cli-0m7wct0d.js";
+import"./cli-rykfmgwg.js";
+import"./cli-0xqde53b.js";
+import"./cli-pqetb83f.js";
+import"./cli-bc05qbss.js";
+export {
+  McpOAuthCredentialStore,
+  McpServerConnection,
+  McpServerLog,
+  McpSignInCancelledError,
+  createDefaultTransport,
+  signInMcpServer
+};

package/dist/{setup-q9720bt6.js → setup-8y70ys6t.js}

@@ -4,14 +4,14 @@ import {
   createDefaultMcpJson,
   createDefaultSettingsLocal,
   createHooksConfig
-} from "./cli-9httdpyq.js";
+} from "./cli-g2whhdrf.js";
 import {
   require_jsx_dev_runtime
-} from "./cli-eetrvv91.js";
+} from "./cli-t3p77qk1.js";
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
-import"./cli-c07r9a2m.js";
+import"./cli-0q3avq3s.js";
 import {
   Box_default,
   Spinner,
@@ -19,8 +19,9 @@ import {
   TextInput,
   require_react,
   use_app_default
-} from "./cli-zt1227k1.js";
-import"./cli-pw9rj5t9.js";
+} from "./cli-fkqhbg8g.js";
+import"./cli-0xqde53b.js";
+import"./cli-pqetb83f.js";
 import {
   __toESM
 } from "./cli-bc05qbss.js";