@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/dist/{cli-avgcz4ra.js → cli-pd7vagab.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-ekwks2vs.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-nhrvpaj7.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-e3r2neck.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 = {
@@ -1561,6 +1592,8 @@ var zSubagentUpdate = object2({
   state: defaultOnError(zStateUpdate.nullish(), () => {
     return;
   }),
+  cwd: string2().nullish(),
+  additionalDirectories: array2(string2()).nullish(),
   _meta: defaultOnError(record2(string2(), unknown()).nullish(), () => {
     return;
   })
@@ -2173,6 +2206,17 @@ var zCancelRequestNotification = object2({
 
 // node_modules/@agentclientprotocol/sdk/dist/core/jsonrpc.js
 var CANCEL_REQUEST_METHOD = "$/cancel_request";
+function treatSessionNotFoundAsSuccess(method, response, success) {
+  if (method !== "session/close" && method !== "session/delete") {
+    return response;
+  }
+  return response.catch((error) => {
+    if (error instanceof RequestError && error.code === -32002) {
+      return success();
+    }
+    throw error;
+  });
+}
 function isRequestMessage(value) {
   return isJsonRpcEnvelope(value) && "id" in value && typeof value["method"] === "string" && isJsonRpcId(value["id"]);
 }
@@ -2205,28 +2249,6 @@ function isJsonRpcId(value) {
 function isResponseShapedMessage(value) {
   return isRecord(value) && !("method" in value) && (("id" in value) || ("result" in value) || ("error" in value));
 }
-function isResponseBatch(batch) {
-  let hasValidCall = false;
-  let hasValidResponse = false;
-  let hasCallShape = false;
-  let hasResponseShape = false;
-  for (const entry of batch) {
-    hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
-    hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord(entry)) {
-      continue;
-    }
-    hasCallShape ||= "method" in entry;
-    hasResponseShape ||= "result" in entry || "error" in entry;
-  }
-  if (hasValidCall) {
-    return false;
-  }
-  if (hasValidResponse) {
-    return true;
-  }
-  return hasResponseShape && !hasCallShape;
-}
 function cancelRequestId(params) {
   if (!isRecord(params) || !isJsonRpcId(params["requestId"])) {
     return;
@@ -2340,7 +2362,6 @@ class RequestResponder {
     });
   }
 }
-var requestBatchSizes = new WeakMap;
 var nullIdResponders = new WeakSet;
 class HandlerRegistration {
   disposeHandler;
@@ -2374,9 +2395,6 @@ class ConnectionContext {
   sendNotification(method, params) {
     return this.connection.sendNotification(method, params);
   }
-  sendBatch(entries) {
-    return this.connection.sendBatch(entries);
-  }
   sendCancelRequest(requestId) {
     return this.connection.sendCancelRequest(requestId);
   }
@@ -2405,7 +2423,6 @@ class Connection {
   retryQueue = [];
   context = new ConnectionContext(this);
   receiveReader;
-  allowBatches = true;
   constructor(requestHandlerOrStream, notificationHandlerOrHandlers, streamOrOptions, options) {
     if (typeof requestHandlerOrStream === "function") {
       const requestHandler = requestHandlerOrStream;
@@ -2466,55 +2483,13 @@ class Connection {
       return rejectedPromise(this.closedReason());
     }
     const request = this.prepareRequest(method, params, mapResponse, options);
-    const requestSent = this.sendWireMessage(request.message);
+    const requestSent = this.sendMessage(request.message);
     requestSent.catch(() => {});
     if (options.cancellationSignal?.aborted) {
       request.cancel();
     }
     return request.response;
   }
-  sendBatch(entries) {
-    if (this.abortController.signal.aborted) {
-      return rejectedPromise(this.closedReason());
-    }
-    if (!this.allowBatches) {
-      return rejectedPromise(new TypeError("JSON-RPC batches are not supported on this connection"));
-    }
-    if (entries.length === 0) {
-      return rejectedPromise(new TypeError("JSON-RPC batch must contain at least one entry"));
-    }
-    const messages = [];
-    const cancellations = [];
-    const outputs = [];
-    for (const entry of entries) {
-      if (entry.kind === "notification") {
-        messages.push({
-          jsonrpc: "2.0",
-          method: entry.method,
-          params: entry.params
-        });
-        outputs.push(Promise.resolve(undefined));
-        continue;
-      }
-      const request = this.prepareRequest(entry.method, entry.params, entry.mapResponse, entry.options);
-      messages.push(request.message);
-      outputs.push(request.response);
-      cancellations.push({
-        signal: entry.options?.cancellationSignal,
-        cancel: request.cancel
-      });
-    }
-    const batch = messages;
-    const batchSent = this.sendWireMessage(batch);
-    for (const cancellation of cancellations) {
-      if (cancellation.signal?.aborted) {
-        cancellation.cancel();
-      }
-    }
-    const response = Promise.all([batchSent, ...outputs]).then(([, ...resolved]) => resolved);
-    response.catch(() => {});
-    return response;
-  }
   sendCancelRequest(requestId) {
     return this.sendNotification(CANCEL_REQUEST_METHOD, { requestId });
   }
@@ -2522,7 +2497,7 @@ class Connection {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
-    return this.sendWireMessage({ jsonrpc: "2.0", method, params });
+    return this.sendMessage({ jsonrpc: "2.0", method, params });
   }
   prepareRequest(method, params, mapResponse, options = {}) {
     const id = this.nextRequestId++;
@@ -2582,7 +2557,6 @@ class Connection {
     this.stream = stream;
     this.staticHandlers = handlers;
     this.fallbackHandlers = [...options?.fallbackHandlers ?? []];
-    this.allowBatches = options?.allowBatches ?? true;
     this.closedPromise = new Promise((resolve) => {
       this.abortController.signal.addEventListener("abort", () => resolve());
     });
@@ -2615,7 +2589,7 @@ class Connection {
           if (done) {
             break;
           }
-          this.receiveWireMessage(message);
+          this.receiveUnvalidatedMessage(message);
         }
       } finally {
         if (this.receiveReader === reader) {
@@ -2629,65 +2603,18 @@ class Connection {
       this.close(closeError);
     }
   }
-  receiveWireMessage(message) {
+  receiveUnvalidatedMessage(message) {
     if (Array.isArray(message)) {
-      if (!this.allowBatches) {
-        this.close(new TypeError("JSON-RPC batches are not supported on this connection"));
-        return;
-      }
-      this.receiveBatch(message);
+      this.sendMessage(protocolErrorResponse(RequestError.invalidRequest(undefined, "JSON-RPC batches are not supported"))).catch(() => {});
       return;
     }
     if (!isRequestMessage(message) && !isNotificationMessage(message) && !isResponseShapedMessage(message)) {
-      this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {});
+      this.sendMessage(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {});
       return;
     }
     this.receiveMessage(message);
   }
-  receiveBatch(batch) {
-    if (batch.length === 0) {
-      this.sendWireMessage(protocolErrorResponse(RequestError.invalidRequest(batch))).catch(() => {});
-      return;
-    }
-    const responseBatch = isResponseBatch(batch);
-    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
-    let remaining = responseCount;
-    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
-    let responseSent = false;
-    const responses = [];
-    const sendResponsesIfReady = async () => {
-      if (responseSent || remaining !== 0 || remainingNotifications !== 0 || responses.length === 0) {
-        return;
-      }
-      responseSent = true;
-      await this.sendWireMessage(responses);
-    };
-    const collectResponse = async (response) => {
-      responses.push(response);
-      remaining -= 1;
-      await sendResponsesIfReady();
-    };
-    for (const message of batch) {
-      if (responseBatch) {
-        if (isResponseShapedMessage(message)) {
-          this.receiveMessage(message);
-        }
-        continue;
-      }
-      if (!isRequestMessage(message) && !isNotificationMessage(message)) {
-        collectResponse(protocolErrorResponse(RequestError.invalidRequest(message))).catch(() => {});
-        continue;
-      }
-      const processing = this.receiveMessage(message, isRequestMessage(message) ? collectResponse : undefined, batch.length);
-      if (isNotificationMessage(message)) {
-        processing.finally(() => {
-          remainingNotifications -= 1;
-          sendResponsesIfReady().catch((error) => this.close(error));
-        });
-      }
-    }
-  }
-  receiveMessage(message, sendResponse, batchSize) {
+  receiveMessage(message) {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
@@ -2699,7 +2626,7 @@ class Connection {
       if (!("id" in message)) {
         this.handleProtocolNotification(message);
       }
-      return this.processIncomingMessage(this.toIncomingMessage(message, sendResponse, batchSize)).catch((error) => this.close(error));
+      return this.processIncomingMessage(this.toIncomingMessage(message)).catch((error) => this.close(error));
     } else if ("id" in message) {
       this.handleResponse(message);
     } else {
@@ -2754,7 +2681,7 @@ class Connection {
       }
     }
   }
-  toIncomingMessage(message, sendResponse, batchSize) {
+  toIncomingMessage(message) {
     if ("id" in message) {
       const abortController = new AbortController;
       this.incomingRequests.set(message.id, abortController);
@@ -2769,11 +2696,8 @@ class Connection {
           id: nullIdResponders.has(responder) ? null : message.id,
           ...result
         };
-        return sendResponse ? sendResponse(response) : this.sendWireMessage(response);
+        return this.sendMessage(response);
       }, abortController.signal, finishRequest);
-      if (batchSize !== undefined) {
-        requestBatchSizes.set(responder, batchSize);
-      }
       return {
         kind: "request",
         method: message.method,
@@ -2824,7 +2748,7 @@ class Connection {
   closedReason() {
     return this.abortController.signal.reason ?? new Error("ACP connection closed");
   }
-  async sendWireMessage(message) {
+  async sendMessage(message) {
     if (this.abortController.signal.aborted) {
       return rejectedPromise(this.closedReason());
     }
@@ -3154,7 +3078,9 @@ function ndJsonStream(output, input, options = {}) {
           await writeJson(protocolErrorResponse(RequestError.parseError()));
           return;
         }
-        if (isRecord(message) || Array.isArray(message)) {
+        if (Array.isArray(message)) {
+          await writeJson(protocolErrorResponse(RequestError.invalidRequest(undefined, "JSON-RPC batches are not supported")));
+        } else if (isRecord(message)) {
           controller.enqueue(message);
         } else {
           await writeJson(protocolErrorResponse(RequestError.invalidRequest(message)));
@@ -3482,7 +3408,7 @@ class ClientContext extends AcpContext {
   }
   request(method, params, options) {
     const spec = agentRequestSpecsByMethod[method];
-    return this.sendRequest(method, params, spec?.mapResponse, options);
+    return treatSessionNotFoundAsSuccess(method, this.sendRequest(method, params, spec?.mapResponse, options), () => spec?.mapResponse ? spec.mapResponse({}) : {});
   }
   notify(method, params) {
     return this.sendNotification(method, params);
@@ -3865,7 +3791,6 @@ function runConnectHandlers(connection, handlers) {
 var appBuilder = Symbol("appBuilder");
 var runAgentConnectHandlers = Symbol("runAgentConnectHandlers");
 var runClientConnectHandlers = Symbol("runClientConnectHandlers");
-var stableConnectionOptions = { allowBatches: false };
 function client(options) {
   return new ClientApp(options);
 }
@@ -3951,7 +3876,7 @@ class ClientApp {
       return state;
     }
     const [thisStream, peerStream] = memoryStreamPair();
-    const peerRawConnection = target[appBuilder]().connect(peerStream, stableConnectionOptions);
+    const peerRawConnection = target[appBuilder]().connect(peerStream);
     const peerConnection = agentConnection(peerRawConnection);
     const state = this.openStreamConnection(thisStream);
     state.rawConnection.closed.then(() => peerConnection.close());
@@ -3967,7 +3892,7 @@ class ClientApp {
     return state;
   }
   openStreamConnection(stream) {
-    const rawConnection = this.builder.connect(stream, stableConnectionOptions);
+    const rawConnection = this.builder.connect(stream);
     return {
       rawConnection,
       connection: clientConnection(rawConnection, this.connectHandlers)
@@ -4180,10 +4105,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 +4606,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 +4794,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 +4958,7 @@ class SwarmAcpClient {
   emit;
   target;
   reportedCostUsd = null;
+  updateListeners = new Set;
   constructor(emit, target) {
     this.emit = emit;
     this.target = target;
@@ -4818,8 +4975,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 +4995,7 @@ class ACPSession {
   config;
   providerName;
   target;
+  extras;
   sessionId;
   listeners = new Set;
   pendingEvents = [];
@@ -4840,20 +5006,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 +5193,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 +5247,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 +5321,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 +5424,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 +5485,4 @@ function fileSinkWritableStream(sink) {
   });
 }
 
-export { isGrokOpenRouterModel, grokTargetProfile, ACPAdapter2 };
+export { FX_ROUTE_KEY_VARS, requireFxRoute, isGrokOpenRouterModel, grokTargetProfile, fxSessionExists, fxTargetProfile, ACPAdapter2 };