@desplega.ai/agent-swarm 2.7.4 → 2.7.5

package/dist/{cli-avgcz4ra.js → cli-rm6hqj3z.js}

@@ -2,14 +2,14 @@ import {
   ACP_TARGET_IDS,
   isAcpTarget,
   getAcpTargetCatalogEntry
-} from "./cli-9cctx1tn.js";
+} from "./cli-a22h291q.js";
 import {
   applyReasoningEffort
-} from "./cli-vqgnyh76.js";
+} from "./cli-98rw5dt5.js";
 import {
   applyOpenRouterBaseUrlOverride2,
   buildOpenAICompatibleProviderBlock2
-} from "./cli-13jvmew3.js";
+} from "./cli-zppwg9p9.js";
 import {
   fetchInstalledMcpServers
 } from "./cli-bst1vp7e.js";
@@ -17,7 +17,7 @@ import {
   getContextWindowSize,
   clampContextPercent,
   init_context_window
-} from "./cli-rtk9g7av.js";
+} from "./cli-73jzwksr.js";
 import {
   detachedProcessGroup,
   registerProcessGroup,
@@ -27,6 +27,16 @@ import {
 import {
   init_v4
 } from "./cli-5xaqj21p.js";
+import {
+  DEFAULT_MODEL_TIER_MAP,
+  init_types4
+} from "./cli-7wspm5gm.js";
+import {
+  resolveTemplateFromCode,
+  resolveTemplateAsync,
+  init_resolver,
+  init_session_templates
+} from "./cli-cm5yqn35.js";
 import {
   NEVER,
   string2,
@@ -48,18 +58,39 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-pe09p6dv.js";
+} from "./cli-tqgg40ek.js";
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-a4btqqft.js";
+} from "./cli-1b7btd38.js";
 import {
+  fxModelRoute,
   normalizeGrokModel,
   baseUrlOverride,
   providerBaseUrl,
   providerForModel,
   init_src2
-} from "./cli-4r12t6w6.js";
+} from "./cli-5c4hjzne.js";
+
+// src/utils/fx-models.ts
+init_src2();
+init_types4();
+var FX_ROUTE_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "OPENAI_API_KEY",
+  "AI_GATEWAY_API_KEY"
+];
+function resolveFxRoute(model) {
+  const value = model?.trim() || DEFAULT_MODEL_TIER_MAP.fx.regular;
+  const route = fxModelRoute(value);
+  return "error" in route ? route : { ...route, model: value };
+}
+function requireFxRoute(model) {
+  const route = resolveFxRoute(model);
+  if ("error" in route)
+    throw new Error(route.error);
+  return route;
+}
 
 // node_modules/@agentclientprotocol/sdk/dist/v1/unstable/schema/index.js
 var AGENT_METHODS = {
@@ -4180,10 +4211,13 @@ function translateAcpSessionNotification(notification) {
 
 // src/providers/acp-targets.ts
 init_src2();
+init_resolver();
+init_session_templates();
 init_context_window();
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+init_secret_scrubber();
 class AcpTargetResolutionError extends Error {
   constructor(message) {
     super(message);
@@ -4678,6 +4712,171 @@ var grokTargetProfile = {
     return `Grok rejected the credentials (XAI_API_KEY or OPENROUTER_API_KEY invalid or missing): ${message}`;
   }
 };
+var FX_SYSTEM_PROMPT_INLINE_MAX_BYTES = 60 * 1024;
+var FX_SYSTEM_PROMPT_HEAD_BYTES = 56 * 1024;
+var FX_SYSTEM_PROMPT_FILE_TEMPLATE = "system.agent.fx.system_prompt_file";
+var FX_CONTEXT_NOTICE_PREFIX = "[context] ";
+var FX_AUTH_ERROR_RE = /authentication is unavailable|credential is unavailable|MissingApiKey|unauthorized|\b401\b/i;
+function fxRunDir(config) {
+  const safe = config.taskId.replace(/[^A-Za-z0-9._-]/g, "_") || "session";
+  return join(tmpdir(), `fx-${safe}`);
+}
+function utf8Head(bytes, max) {
+  let end = Math.min(max, bytes.length);
+  while (end > 0 && end < bytes.length && ((bytes[end] ?? 0) & 192) === 128)
+    end -= 1;
+  return new TextDecoder().decode(bytes.subarray(0, end));
+}
+async function fxSystemPromptPointer(path) {
+  try {
+    const result = await resolveTemplateAsync(FX_SYSTEM_PROMPT_FILE_TEMPLATE, { path });
+    if (!result.skipped && result.text.trim())
+      return result.text;
+  } catch {}
+  return resolveTemplateFromCode(FX_SYSTEM_PROMPT_FILE_TEMPLATE, { path }).text;
+}
+async function fxSystemPrompt(systemPrompt, dir) {
+  if (!systemPrompt.trim())
+    return;
+  const bytes = new TextEncoder().encode(systemPrompt);
+  if (bytes.length <= FX_SYSTEM_PROMPT_INLINE_MAX_BYTES) {
+    return { blocks: [{ type: "text", text: systemPrompt }] };
+  }
+  const artifactPath = join(dir, "SYSTEM.md");
+  await mkdir(dir, { recursive: true });
+  await Bun.write(artifactPath, systemPrompt);
+  await chmod(artifactPath, 384);
+  const head = utf8Head(bytes, FX_SYSTEM_PROMPT_HEAD_BYTES);
+  const pointer = await fxSystemPromptPointer(artifactPath);
+  return { blocks: [{ type: "text", text: `${head}
+
+${pointer}` }], artifactPath };
+}
+async function fxSessionExists(sessionId, home) {
+  if (!home || !/^[A-Za-z0-9_-]+$/.test(sessionId))
+    return false;
+  return Bun.file(join(home, ".fx", "sessions", "v2", sessionId, "log.jsonl")).exists();
+}
+function rewriteFxEvent(event, update) {
+  if (event.type === "message" && event.role === "assistant" && event.content.startsWith(FX_CONTEXT_NOTICE_PREFIX)) {
+    return {
+      type: "custom",
+      name: "fx_context_notice",
+      data: { text: event.content, messageId: event.messageId ?? null }
+    };
+  }
+  if (event.type === "tool_start" && update?.sessionUpdate === "tool_call") {
+    const mcp = update._meta?.fx?.toolCall?.mcp;
+    if (typeof mcp?.server === "string" && typeof mcp.tool === "string" && mcp.server && mcp.tool) {
+      return { ...event, toolName: `mcp__${mcp.server}__${mcp.tool}` };
+    }
+    const name = update.name;
+    if (typeof name === "string" && name.trim())
+      return { ...event, toolName: name.trim() };
+  }
+  return event;
+}
+async function steerFx({
+  sessionId,
+  delivery,
+  initResult,
+  prompt,
+  onUpdate
+}) {
+  if (delivery.mode !== "steer") {
+    return { delivered: false, reason: `fx supports steer only, not ${delivery.mode}` };
+  }
+  const meta = initResult.agentCapabilities?._meta;
+  if (meta?.fx?.steering !== true) {
+    return { delivered: false, reason: "fx did not advertise _meta.fx.steering" };
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let stopListening = () => {};
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      stopListening();
+      resolve(result);
+    };
+    stopListening = onUpdate((update) => {
+      if (update.sessionUpdate !== "user_message_chunk")
+        return;
+      const steering = update._meta?.fx?.steering;
+      if (!steering || update.content.type !== "text" || update.content.text !== delivery.text) {
+        return;
+      }
+      settle({ delivered: true, mode: "steer" });
+    });
+    prompt({
+      sessionId,
+      prompt: [{ type: "text", text: delivery.text }],
+      _meta: { fx: { steer: true } }
+    }).then((response) => {
+      const state = response._meta?.fx?.steering;
+      settle(state === "absorbed" ? { delivered: true, mode: "steer" } : {
+        delivered: false,
+        reason: `fx did not absorb the steer (stopReason ${response.stopReason}, steering ${JSON.stringify(state ?? null)})`
+      });
+    }, (err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      settle({ delivered: false, reason: scrubSecrets(`fx steer failed: ${message}`) });
+    });
+  });
+}
+var fxTargetProfile = {
+  target: "fx",
+  command(config) {
+    const binary = readEnv(config, "FX_BINARY")?.trim() || "fx";
+    const route = requireFxRoute(config.model);
+    return [
+      binary,
+      "acp",
+      "--model",
+      route.fxModel,
+      "--log-file",
+      join(fxRunDir(config), "acp.log")
+    ];
+  },
+  env(config) {
+    const route = requireFxRoute(config.model);
+    const env = baseTargetEnv(config);
+    copyEnvKeys(config, env, [route.keyVar]);
+    env.FX_PROVIDER = route.fxProvider;
+    env.FX_PERMISSION_MODE = "full-access";
+    env.FX_AUTO_UPGRADE = "0";
+    env.FX_NO_OPEN_BROWSER = "1";
+    return env;
+  },
+  configuredOptions(config) {
+    if (!config.reasoningEffort)
+      return {};
+    const effort = applyReasoningEffort("fx", config.model.trim(), config.reasoningEffort);
+    return effort.kind === "fx-effort" ? { effort: effort.reasoningEffort } : {};
+  },
+  async writeSystemPromptArtifact(config) {
+    await mkdir(fxRunDir(config), { recursive: true, mode: 448 });
+  },
+  async cleanupSystemPromptArtifact(config) {
+    await rm(fxRunDir(config), { recursive: true, force: true });
+  },
+  sessionSystemPrompt(config) {
+    return fxSystemPrompt(config.systemPrompt ?? "", fxRunDir(config));
+  },
+  requiresSecureMcpUrl: true,
+  steer: steerFx,
+  resume: {
+    method: "session/resume",
+    canResume: (sessionId) => fxSessionExists(sessionId, process.env.HOME)
+  },
+  rewriteEvent: rewriteFxEvent,
+  describeError(message) {
+    if (!FX_AUTH_ERROR_RE.test(message))
+      return;
+    return `fx could not authenticate the model route (OPENROUTER_API_KEY, OPENAI_API_KEY or AI_GATEWAY_API_KEY invalid or missing): ${message}`;
+  }
+};
 function resolveAcpTarget(config) {
   const target = readEnv(config, "ACP_TARGET") ?? "custom";
   if (!isAcpTarget(target)) {
@@ -4701,6 +4900,69 @@ function resolveAcpTarget(config) {
   }
 }
 
+// src/providers/mcp-loopback-proxy.ts
+init_secret_scrubber();
+var DROPPED_REQUEST_HEADERS = [
+  "host",
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "upgrade"
+];
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function needsLoopbackProxy(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  return parsed.protocol === "http:" && !LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase());
+}
+async function startMcpLoopbackProxy(upstream) {
+  const base = new URL(upstream);
+  const prefix = base.pathname.replace(/\/+$/, "");
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 0,
+    async fetch(req) {
+      const incoming = new URL(req.url);
+      const target = new URL(base);
+      target.pathname = `${prefix}${incoming.pathname}`;
+      target.search = incoming.search;
+      const headers = new Headers(req.headers);
+      for (const name of DROPPED_REQUEST_HEADERS)
+        headers.delete(name);
+      try {
+        const hasBody = req.method !== "GET" && req.method !== "HEAD";
+        return await fetch(target, {
+          method: req.method,
+          headers,
+          body: hasBody ? req.body : undefined,
+          redirect: "manual",
+          signal: req.signal,
+          decompress: false
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return new Response(JSON.stringify({
+          error: scrubSecrets(`MCP loopback proxy: upstream failed: ${message}`)
+        }), { status: 502, headers: { "Content-Type": "application/json" } });
+      }
+    }
+  });
+  let stopped = null;
+  return {
+    url: `http://127.0.0.1:${server.port}`,
+    stop() {
+      stopped ??= server.stop(true);
+      return stopped;
+    }
+  };
+}
+
 // src/providers/acp-adapter.ts
 var ACP_LOG_MAX_CHARS = 30000;
 var ACP_CANCEL_SETTLE_MS = 3000;
@@ -4802,6 +5064,7 @@ class SwarmAcpClient {
   emit;
   target;
   reportedCostUsd = null;
+  updateListeners = new Set;
   constructor(emit, target) {
     this.emit = emit;
     this.target = target;
@@ -4818,8 +5081,16 @@ class SwarmAcpClient {
     if (costUsd !== null)
       this.reportedCostUsd = costUsd;
     for (const event of translateAcpSessionNotification(params)) {
-      this.emit(this.target?.rewriteEvent?.(event) ?? event);
+      this.emit(this.target?.rewriteEvent?.(event, params.update) ?? event);
     }
+    for (const listener of this.updateListeners)
+      listener(params.update);
+  }
+  onUpdate(listener) {
+    this.updateListeners.add(listener);
+    return () => {
+      this.updateListeners.delete(listener);
+    };
   }
 }
 
@@ -4830,6 +5101,7 @@ class ACPSession {
   config;
   providerName;
   target;
+  extras;
   sessionId;
   listeners = new Set;
   pendingEvents = [];
@@ -4840,20 +5112,44 @@ class ACPSession {
   completionPromise;
   completionResolve;
   ephemeralTokenId = null;
-  constructor(agent, client, process2, config, sessionId, providerName, target, providerMeta, ephemeralTokenId) {
+  deliverSteering;
+  constructor(agent, client, process2, config, sessionId, providerName, target, providerMeta, ephemeralTokenId, extras) {
     this.agent = agent;
     this.client = client;
     this.process = process2;
     this.config = config;
     this.providerName = providerName;
     this.target = target;
+    this.extras = extras;
     this.sessionId = sessionId;
     this.ephemeralTokenId = ephemeralTokenId ?? null;
     this.completionPromise = new Promise((resolve) => {
       this.completionResolve = resolve;
     });
+    const steer = target.steer;
+    if (steer && extras) {
+      const initResult = extras.initResult;
+      this.deliverSteering = async (delivery) => {
+        if (this.completed || this.aborted) {
+          return { delivered: false, reason: "The ACP session has already finished" };
+        }
+        return steer({
+          sessionId,
+          delivery,
+          initResult,
+          prompt: (params) => this.agent.request(methods.agent.session.prompt, params),
+          onUpdate: (listener) => this.client.onUpdate(listener)
+        });
+      };
+    }
     this.consumeStderr();
-    this.emit({ type: "session_init", sessionId, provider: providerName, providerMeta });
+    this.emit({
+      type: "session_init",
+      sessionId,
+      provider: providerName,
+      providerMeta,
+      ...extras?.harnessVariantMeta ? { harnessVariantMeta: extras.harnessVariantMeta } : {}
+    });
     this.runPrompt();
   }
   onEvent(listener) {
@@ -5003,6 +5299,7 @@ class ACPSession {
       return;
     this.completed = true;
     this.completionResolve(result);
+    stopProxies(this.extras?.proxies ?? []);
     if (this.ephemeralTokenId) {
       revokeAcpSessionToken(this.config.apiUrl, this.config.apiKey, this.ephemeralTokenId);
     }
@@ -5056,39 +5353,71 @@ class ACPAdapter2 {
     const stream = ndJsonStream2(fileSinkWritableStream(proc.stdin), proc.stdout);
     const agent = client().onRequest(methods.client.session.requestPermission, ({ params }) => client2.requestPermission(params)).onNotification(methods.client.session.update, ({ params }) => client2.sessionUpdate(params)).connect(stream).agent;
     let ephemeralToken = null;
+    const proxies = [];
     try {
-      await agent.request(methods.agent.initialize, {
+      const initResult = await agent.request(methods.agent.initialize, {
         protocolVersion: PROTOCOL_VERSION,
         clientInfo: { name: "agent-swarm", version: package_default.version },
         clientCapabilities: { session: { configOptions: { boolean: {} } } }
       });
       ephemeralToken = await mintAcpSessionToken(config.apiUrl, config.apiKey, config.agentId, config.taskId);
       const installedServers = await fetchInstalledMcpServers(config.apiUrl, config.apiKey, config.agentId, "claude");
+      let mcpServers = [
+        {
+          type: "http",
+          name: "swarm",
+          url: `${config.apiUrl.replace(/\/+$/, "")}/mcp`,
+          headers: [
+            { name: "Authorization", value: `Bearer ${ephemeralToken.plaintext}` },
+            { name: "X-Agent-ID", value: config.agentId },
+            { name: "X-Source-Task-Id", value: config.taskId }
+          ]
+        },
+        ...toAcpMcpServers(installedServers)
+      ];
+      if (target.requiresSecureMcpUrl) {
+        mcpServers = await secureMcpServers(mcpServers, initResult.agentCapabilities?.mcpCapabilities?.sse === true, proxies);
+      }
       const sessionMeta = target.sessionMeta?.(config);
-      const newSession = await agent.request(methods.agent.session.new, {
-        ...sessionMeta ? { _meta: sessionMeta } : {},
-        cwd: config.cwd,
-        mcpServers: [
-          {
-            type: "http",
-            name: "swarm",
-            url: `${config.apiUrl.replace(/\/+$/, "")}/mcp`,
-            headers: [
-              { name: "Authorization", value: `Bearer ${ephemeralToken.plaintext}` },
-              { name: "X-Agent-ID", value: config.agentId },
-              { name: "X-Source-Task-Id", value: config.taskId }
-            ]
-          },
-          ...toAcpMcpServers(installedServers)
-        ]
-      });
+      const resumeId = target.resume ? config.resumeSessionId?.trim() : undefined;
+      let sessionId;
+      let advertisedOptions;
+      if (resumeId && initResult.agentCapabilities?.sessionCapabilities?.resume) {
+        const resumed = await agent.request(methods.agent.session.resume, {
+          ...sessionMeta ? { _meta: sessionMeta } : {},
+          sessionId: resumeId,
+          cwd: config.cwd,
+          mcpServers
+        });
+        sessionId = resumeId;
+        advertisedOptions = resumed.configOptions ?? [];
+      } else {
+        if (resumeId) {
+          console.warn("\x1B[33m[acp]\x1B[0m Target does not advertise session/resume; starting a new session");
+        }
+        const systemPrompt = await sessionSystemPromptBlocks(target, config, initResult);
+        const newSessionParams = {
+          ...sessionMeta ? { _meta: sessionMeta } : {},
+          cwd: config.cwd,
+          mcpServers,
+          ...systemPrompt ? { systemPrompt } : {}
+        };
+        const newSession = await agent.request(methods.agent.session.new, newSessionParams);
+        sessionId = newSession.sessionId;
+        advertisedOptions = newSession.configOptions ?? [];
+      }
       const configOptions = await applyConfiguredOptions({
         setSessionConfigOption: (params) => agent.request(methods.agent.session.setConfigOption, params)
-      }, newSession.sessionId, newSession.configOptions ?? [], target.configuredOptions(config));
-      session = new ACPSession(agent, client2, proc, config, newSession.sessionId, this.name, target, {
+      }, sessionId, advertisedOptions, target.configuredOptions(config));
+      const agentVersion = initResult.agentInfo?.version?.trim();
+      session = new ACPSession(agent, client2, proc, config, sessionId, this.name, target, {
         target: target.target,
         configOptions: sanitizeAcpConfigOptions(configOptions)
-      }, ephemeralToken.tokenId);
+      }, ephemeralToken.tokenId, {
+        initResult,
+        ...agentVersion ? { harnessVariantMeta: { version: scrubSecrets(agentVersion) } } : {},
+        proxies
+      });
       for (const event of preSessionEvents)
         session.emitFromAcp(event);
       session.waitForCompletion().finally(cleanupArtifact);
@@ -5098,12 +5427,14 @@ class ACPAdapter2 {
         revokeAcpSessionToken(config.apiUrl, config.apiKey, ephemeralToken.tokenId);
       }
       await terminateProcessGroup(proc.pid);
+      await stopProxies(proxies);
       await cleanupArtifact();
       throw new Error(`ACP target failed during startup: ${describeTargetError(target, scrubSecrets(formatError(err)))}`);
     }
   }
-  async canResume(_sessionId) {
-    return false;
+  async canResume(sessionId) {
+    const resume = this.options.target?.resume;
+    return resume ? resume.canResume(sessionId) : false;
   }
   formatCommand(commandName) {
     return `/${commandName}`;
@@ -5199,6 +5530,46 @@ function toAcpMcpServers(installed) {
   }
   return servers;
 }
+async function sessionSystemPromptBlocks(target, config, initResult) {
+  if (!target.sessionSystemPrompt)
+    return;
+  if (!initResult.agentCapabilities?.sessionCapabilities?.systemPrompt) {
+    console.warn("\x1B[33m[acp]\x1B[0m Target does not advertise sessionCapabilities.systemPrompt; the swarm system prompt is not sent");
+    return;
+  }
+  const plan = await target.sessionSystemPrompt(config);
+  return plan?.blocks.length ? plan.blocks : undefined;
+}
+async function secureMcpServers(servers, sseSupported, proxies) {
+  const byOrigin = new Map;
+  const result = [];
+  for (const server of servers) {
+    if (!("url" in server)) {
+      result.push(server);
+      continue;
+    }
+    if (server.type === "sse" && !sseSupported) {
+      console.warn(`\x1B[33m[acp]\x1B[0m Skipping installed MCP server "${server.name}": the target does not support SSE MCP servers`);
+      continue;
+    }
+    if (!needsLoopbackProxy(server.url)) {
+      result.push(server);
+      continue;
+    }
+    const url = new URL(server.url);
+    let proxy = byOrigin.get(url.origin);
+    if (!proxy) {
+      proxy = await startMcpLoopbackProxy(url.origin);
+      byOrigin.set(url.origin, proxy);
+      proxies.push(proxy);
+    }
+    result.push({ ...server, url: `${proxy.url}${url.pathname}${url.search}` });
+  }
+  return result;
+}
+async function stopProxies(proxies) {
+  await Promise.all(proxies.splice(0).map((proxy) => proxy.stop().catch(() => {})));
+}
 function describeTargetError(target, message) {
   return target.describeError?.(message) ?? message;
 }
@@ -5220,4 +5591,4 @@ function fileSinkWritableStream(sink) {
   });
 }
 
-export { isGrokOpenRouterModel, grokTargetProfile, ACPAdapter2 };
+export { FX_ROUTE_KEY_VARS, requireFxRoute, isGrokOpenRouterModel, grokTargetProfile, fxSessionExists, fxTargetProfile, ACPAdapter2 };

package/dist/{cli-0fgr1w9b.js → cli-rpm2sgv0.js}

@@ -1,7 +1,7 @@
 import {
   RuntimeProviderKindSchema,
   init_types4
-} from "./cli-41z8xwj0.js";
+} from "./cli-7wspm5gm.js";
 import {
   init_zod
 } from "./cli-k5671be5.js";
@@ -21,7 +21,7 @@ import {
 import {
   scrubSecrets,
   init_secret_scrubber
-} from "./cli-a4btqqft.js";
+} from "./cli-1b7btd38.js";
 
 // src/runtime-providers/controller.ts
 init_secret_scrubber();