@desplega.ai/agent-swarm 1.162.0 → 1.164.0

package/dist/cli-dsdg2wrk.js

@@ -0,0 +1,516 @@
+import {
+  resolveSlashSkillPrompt
+} from "./cli-wgbezhw2.js";
+import {
+  clampContextPercent,
+  getContextWindowSize
+} from "./cli-6behs2bt.js";
+import {
+  applyReasoningEffort
+} from "./cli-cn53e7vc.js";
+import {
+  swarmRuntimeInstanceId
+} from "./cli-re8z5p8p.js";
+import {
+  DEFAULT_MODEL_TIER_MAP,
+  init_types
+} from "./cli-9x3bwfd3.js";
+import {
+  init_session_templates
+} from "./cli-g5erf0zt.js";
+import {
+  init_resolver,
+  resolveTemplateAsync,
+  resolveTemplateFromCode
+} from "./cli-5c2j5yvx.js";
+import {
+  init_env_flag,
+  parseEnvFlag
+} from "./cli-ej6gbxfb.js";
+import {
+  cursorCatalogRef,
+  init_src
+} from "./cli-g3qgrzck.js";
+import {
+  init_secret_scrubber,
+  registerVolatileSecret,
+  scrubSecrets
+} from "./cli-nexqx4ve.js";
+import {
+  __require
+} from "./cli-bc05qbss.js";
+
+// src/providers/cursor-adapter.ts
+init_src();
+init_session_templates();
+init_resolver();
+init_types();
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+init_env_flag();
+init_secret_scrubber();
+var CURSOR_SDK_VERSION = "1.0.36";
+var CURSOR_MCP_SERVER_NAME = "agent-swarm";
+var NATIVE_SYSTEM_PROMPT_ENV = "CURSOR_NATIVE_SYSTEM_PROMPT";
+var FIRST_MESSAGE_TEMPLATE = "system.agent.cursor.first_message";
+function checkCursorCredentials(env) {
+  return env.CURSOR_API_KEY?.trim() ? { ready: true, missing: [], satisfiedBy: "env" } : { ready: false, missing: ["CURSOR_API_KEY"], hint: "Set CURSOR_API_KEY for cursor." };
+}
+async function liveTestCursorKey(apiKey) {
+  const { Cursor } = await import("./index-fdk1t4d6.js");
+  try {
+    await Cursor.me({ apiKey });
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: scrubSecrets(`Cursor rejected CURSOR_API_KEY: ${errorMessage(error)}`)
+    };
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var MODEL_LIST_TTL_MS = 600000;
+var modelListCache;
+async function listCursorModels(apiKey) {
+  if (modelListCache?.key === apiKey && Date.now() - modelListCache.at < MODEL_LIST_TTL_MS) {
+    return modelListCache.models;
+  }
+  const { Cursor } = await import("./index-fdk1t4d6.js");
+  const models = await Cursor.models.list({ apiKey });
+  modelListCache = { key: apiKey, at: Date.now(), models };
+  return models;
+}
+var EFFORT_PARAM_IDS = ["reasoning_effort", "reasoning", "effort"];
+var EFFORT_VALUE_ALIASES = {
+  off: ["none"],
+  low: ["low"],
+  medium: ["medium"],
+  high: ["high"],
+  xhigh: ["xhigh", "extra-high"],
+  max: ["max"]
+};
+function cursorModelSelection(modelId, effort, models) {
+  const item = models.find((m) => m.id === modelId || m.aliases?.includes(modelId));
+  const selection = { id: item?.id ?? modelId };
+  if (!effort || !item)
+    return { selection, appliedEffort: null };
+  const param = item.parameters?.find((p) => EFFORT_PARAM_IDS.includes(p.id));
+  const value = param?.values.map((v) => v.value).find((v) => EFFORT_VALUE_ALIASES[effort].includes(v));
+  if (param && value) {
+    selection.params = [{ id: param.id, value }];
+    return { selection, appliedEffort: effort };
+  }
+  const thinking = item.parameters?.find((p) => p.id === "thinking");
+  if (effort === "off" && thinking?.values.some((v) => v.value === "false")) {
+    selection.params = [{ id: "thinking", value: "false" }];
+    return { selection, appliedEffort: effort };
+  }
+  return { selection, appliedEffort: null };
+}
+function contextWindowFor(model) {
+  const { providerId, modelId } = cursorCatalogRef(model);
+  return providerId === "cursor" ? null : getContextWindowSize(`${providerId}/${modelId}`);
+}
+function uncachedInput(usage) {
+  return Math.max(0, usage.inputTokens - usage.cacheReadTokens - usage.cacheWriteTokens);
+}
+function translateCursorMessage(message) {
+  switch (message.type) {
+    case "assistant": {
+      const text = message.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      return text ? [{ type: "message", role: "assistant", content: text }] : [];
+    }
+    case "tool_call": {
+      const toolName = cursorToolName(message.name, message.args);
+      if (message.status === "running") {
+        return [
+          { type: "tool_start", toolCallId: message.call_id, toolName, args: message.args ?? {} }
+        ];
+      }
+      return [
+        {
+          type: "tool_end",
+          toolCallId: message.call_id,
+          toolName,
+          result: message.status === "error" ? { error: message.result } : message.result
+        }
+      ];
+    }
+    case "thinking":
+      return [{ type: "custom", name: "cursor_thinking", data: { text: message.text } }];
+    case "task":
+      return message.text ? [{ type: "progress", message: message.text }] : [];
+    default:
+      return [];
+  }
+}
+function cursorToolName(name, args) {
+  if (name !== "mcp" || !args || typeof args !== "object")
+    return name;
+  const { providerIdentifier, toolName } = args;
+  if (typeof toolName !== "string" || !toolName)
+    return name;
+  return `mcp__${typeof providerIdentifier === "string" && providerIdentifier ? providerIdentifier : CURSOR_MCP_SERVER_NAME}__${toolName}`;
+}
+async function composeFirstMessage(systemPrompt, prompt) {
+  if (!systemPrompt.trim())
+    return prompt;
+  const variables = { systemPrompt, prompt };
+  try {
+    const result = await resolveTemplateAsync(FIRST_MESSAGE_TEMPLATE, variables);
+    if (!result.skipped && result.text.trim())
+      return result.text;
+  } catch {}
+  return resolveTemplateFromCode(FIRST_MESSAGE_TEMPLATE, variables).text;
+}
+function isSystemPromptUnavailable(message) {
+  return Boolean(message?.includes("--system-prompt"));
+}
+var QUEUE_NOT_SENT = "cursor session ended before the queued message was sent";
+
+class CursorSession {
+  agent;
+  info;
+  directory;
+  sessionId;
+  listeners = [];
+  pending = [];
+  startedAt = Date.now();
+  contextWindow;
+  currentRun;
+  queue = [];
+  ended = false;
+  aborted = false;
+  usage;
+  runs = 0;
+  output;
+  failure;
+  assistantText = "";
+  completion;
+  constructor(agent, firstMessage, info, directory) {
+    this.agent = agent;
+    this.info = info;
+    this.directory = directory;
+    this.contextWindow = contextWindowFor(info.model.id);
+    this.announce(info.recreateWithoutSystemPrompt ? "native" : "first-message");
+    this.completion = this.run(firstMessage);
+  }
+  announce(systemPrompt) {
+    this.sessionId = this.agent.agentId;
+    this.emit({ type: "session_init", sessionId: this.agent.agentId, provider: "cursor" });
+    this.emit({
+      type: "raw_log",
+      content: JSON.stringify({
+        type: "model",
+        provider: "cursor",
+        model: this.info.model,
+        systemPrompt
+      })
+    });
+  }
+  onEvent(listener) {
+    this.listeners.push(listener);
+    for (const event of this.pending.splice(0))
+      listener(event);
+  }
+  emit(event) {
+    if (this.listeners.length === 0)
+      this.pending.push(event);
+    else
+      for (const listener of this.listeners)
+        listener(event);
+  }
+  flushText() {
+    if (!this.assistantText)
+      return;
+    this.emit({ type: "message", role: "assistant", content: this.assistantText });
+    this.assistantText = "";
+  }
+  handle(message) {
+    this.emit({ type: "raw_log", content: scrubSecrets(JSON.stringify(message)) });
+    if (message.type === "status" && message.status === "ERROR" && message.message) {
+      this.failure = scrubSecrets(message.message);
+    }
+    for (const event of translateCursorMessage(message)) {
+      if (event.type === "message") {
+        this.assistantText += event.content;
+        continue;
+      }
+      this.flushText();
+      this.emit(event);
+    }
+  }
+  recordRun(usage, toolRounds) {
+    const calls = toolRounds + 1;
+    const used = Math.round((usage.inputTokens + usage.cacheWriteTokens + usage.outputTokens) / calls);
+    if (used <= 0)
+      return;
+    this.emit({
+      type: "context_usage",
+      contextUsedTokens: used,
+      contextTotalTokens: this.contextWindow,
+      contextPercent: clampContextPercent(used, this.contextWindow),
+      outputTokens: Math.round(usage.outputTokens / calls),
+      contextFormula: "peak-proxy"
+    });
+  }
+  addUsage(usage) {
+    if (!usage)
+      return;
+    const prev = this.usage;
+    this.usage = prev ? {
+      inputTokens: prev.inputTokens + usage.inputTokens,
+      outputTokens: prev.outputTokens + usage.outputTokens,
+      cacheReadTokens: prev.cacheReadTokens + usage.cacheReadTokens,
+      cacheWriteTokens: prev.cacheWriteTokens + usage.cacheWriteTokens,
+      totalTokens: prev.totalTokens + usage.totalTokens,
+      reasoningTokens: (prev.reasoningTokens ?? 0) + (usage.reasoningTokens ?? 0)
+    } : { ...usage };
+  }
+  buildCost(isError) {
+    if (!this.sessionId || !this.usage)
+      return;
+    return {
+      sessionId: this.sessionId,
+      taskId: this.info.taskId,
+      agentId: this.info.agentId,
+      totalCostUsd: 0,
+      inputTokens: uncachedInput(this.usage),
+      outputTokens: this.usage.outputTokens,
+      cacheReadTokens: this.usage.cacheReadTokens,
+      cacheWriteTokens: this.usage.cacheWriteTokens,
+      reasoningOutputTokens: this.usage.reasoningTokens || undefined,
+      durationMs: Date.now() - this.startedAt,
+      numTurns: this.runs,
+      model: this.info.model.id,
+      isError,
+      provider: "cursor"
+    };
+  }
+  async sendAndDrain(text, onAccepted) {
+    if (this.aborted)
+      return "cancelled";
+    let toolRounds = 0;
+    const run = await this.agent.send(text, {
+      onDelta: ({ update }) => {
+        if (update.type === "tool-requests-listed")
+          toolRounds += 1;
+      }
+    });
+    this.currentRun = run;
+    this.runs += 1;
+    if (this.aborted) {
+      await run.cancel().catch(() => {});
+      const result2 = await run.wait().catch(() => {
+        return;
+      });
+      this.addUsage(result2?.usage);
+      return "cancelled";
+    }
+    onAccepted?.();
+    for await (const message of run.stream())
+      this.handle(message);
+    this.flushText();
+    const result = await run.wait();
+    this.addUsage(result.usage);
+    if (result.usage)
+      this.recordRun(result.usage, toolRounds);
+    if (result.result)
+      this.output = result.result;
+    if (result.status === "error") {
+      this.failure = scrubSecrets(result.error?.message ?? this.failure ?? "cursor run failed");
+    }
+    return result.status;
+  }
+  async run(firstMessage) {
+    try {
+      let status = await this.sendAndDrain(firstMessage);
+      if (status === "error" && this.runs === 1 && !this.aborted && isSystemPromptUnavailable(this.failure)) {
+        const recreate = this.info.recreateWithoutSystemPrompt;
+        if (recreate) {
+          this.emit({
+            type: "progress",
+            message: "Cursor systemPrompt unavailable for this account; using the first message"
+          });
+          this.agent.close();
+          this.agent = await recreate();
+          this.announce("first-message");
+          this.failure = undefined;
+          this.output = undefined;
+          this.runs = 0;
+          status = await this.sendAndDrain(await composeFirstMessage(this.info.systemPrompt, firstMessage));
+        }
+      }
+      while (status === "finished" && !this.aborted) {
+        const next = this.queue.shift();
+        if (next === undefined)
+          break;
+        try {
+          status = await this.sendAndDrain(next.text, () => next.settle({ delivered: true, mode: "queue" }));
+        } finally {
+          next.settle({ delivered: false, reason: QUEUE_NOT_SENT });
+        }
+      }
+      this.ended = true;
+      const isError = this.aborted || status !== "finished";
+      const failureReason = isError ? this.aborted || status === "cancelled" ? "cursor session aborted" : this.failure || `cursor run ended with status ${status}` : undefined;
+      if (failureReason)
+        this.emit({ type: "error", message: failureReason });
+      const cost = this.buildCost(isError);
+      if (cost)
+        this.emit({ type: "result", cost, output: this.output, isError });
+      return {
+        exitCode: isError ? 1 : 0,
+        sessionId: this.sessionId,
+        cost,
+        output: this.output,
+        isError,
+        failureReason,
+        appliedReasoningEffort: this.info.appliedEffort
+      };
+    } catch (error) {
+      this.ended = true;
+      const failureReason = scrubSecrets(errorMessage(error));
+      this.emit({ type: "error", message: failureReason });
+      return {
+        exitCode: 1,
+        sessionId: this.sessionId,
+        cost: this.buildCost(true),
+        isError: true,
+        failureReason,
+        appliedReasoningEffort: this.info.appliedEffort
+      };
+    } finally {
+      this.ended = true;
+      this.settleQueued(QUEUE_NOT_SENT);
+      this.agent.close();
+      await rm(this.directory, { recursive: true, force: true });
+    }
+  }
+  settleQueued(reason) {
+    for (const item of this.queue.splice(0))
+      item.settle({ delivered: false, reason });
+  }
+  waitForCompletion() {
+    return this.completion;
+  }
+  async abort() {
+    this.aborted = true;
+    this.settleQueued("cursor session aborted before the queued message was sent");
+    const run = this.currentRun;
+    if (run && run.status === "running")
+      await run.cancel().catch(() => {});
+  }
+  async deliverSteering({ mode, text }) {
+    if (this.ended || this.aborted) {
+      return { delivered: false, reason: "cursor session already completed" };
+    }
+    const run = this.currentRun;
+    if (mode === "steer" && run?.steer && run.status === "running") {
+      try {
+        const outcome = await run.steer(text);
+        if (outcome === "complete_delivered")
+          return { delivered: true, mode: "steer" };
+      } catch (error) {
+        return { delivered: false, reason: scrubSecrets(errorMessage(error)) };
+      }
+    }
+    if (this.ended || this.aborted) {
+      return { delivered: false, reason: "cursor session already completed" };
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      this.queue.push({
+        text,
+        settle: (result) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve(result);
+        }
+      });
+    });
+  }
+}
+
+class CursorAdapter {
+  name = "cursor";
+  traits = {
+    hasMcp: true,
+    hasToolSearch: false,
+    nativeSkillDiscovery: false,
+    hasLocalEnvironment: true,
+    steerModes: ["steer", "queue"]
+  };
+  async createSession(config) {
+    const env = { ...process.env, ...config.env };
+    const apiKey = env.CURSOR_API_KEY?.trim();
+    if (!apiKey)
+      throw new Error("cursor requires CURSOR_API_KEY");
+    registerVolatileSecret(apiKey, "CURSOR_API_KEY");
+    const { Agent, JsonlLocalAgentStore } = await import("./index-fdk1t4d6.js");
+    const modelId = config.model || DEFAULT_MODEL_TIER_MAP.cursor.regular;
+    const effort = applyReasoningEffort("cursor", modelId, config.reasoningEffort);
+    const requested = effort.kind === "cursor-effort" ? effort.reasoningEffort : undefined;
+    let models = [];
+    try {
+      models = await listCursorModels(apiKey);
+    } catch {}
+    const { selection, appliedEffort } = cursorModelSelection(modelId, requested, models);
+    const prompt = await resolveSlashSkillPrompt(config.prompt, {
+      providerLabel: "cursor",
+      skillsDir: join(env.HOME ?? "/home/worker", ".agents", "skills")
+    });
+    const runtimeInstanceId = swarmRuntimeInstanceId();
+    const swarmMcp = {
+      type: "http",
+      url: `${config.apiUrl}/mcp`,
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Agent-ID": config.agentId,
+        "X-Source-Task-Id": config.taskId,
+        ...config.contextKey ? { "X-Context-Key": config.contextKey } : {},
+        ...runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}
+      }
+    };
+    const directory = await mkdtemp(join(tmpdir(), "swarm-cursor-"));
+    const nativeSystemPrompt = parseEnvFlag(env[NATIVE_SYSTEM_PROMPT_ENV], false);
+    const create = (withSystemPrompt) => Agent.create({
+      apiKey,
+      model: selection,
+      name: `swarm-${config.taskId}`,
+      mcpServers: { [CURSOR_MCP_SERVER_NAME]: swarmMcp },
+      ...withSystemPrompt && config.systemPrompt ? { systemPrompt: config.systemPrompt } : {},
+      local: {
+        cwd: config.cwd,
+        store: new JsonlLocalAgentStore(directory),
+        sandboxOptions: { enabled: false }
+      }
+    });
+    try {
+      const agent = await create(nativeSystemPrompt);
+      return new CursorSession(agent, nativeSystemPrompt ? prompt : await composeFirstMessage(config.systemPrompt, prompt), {
+        model: selection,
+        appliedEffort,
+        taskId: config.taskId,
+        agentId: config.agentId,
+        systemPrompt: config.systemPrompt,
+        recreateWithoutSystemPrompt: nativeSystemPrompt ? () => create(false) : undefined
+      }, directory);
+    } catch (error) {
+      await rm(directory, { recursive: true, force: true });
+      throw new Error(scrubSecrets(`cursor agent create failed: ${errorMessage(error)}`));
+    }
+  }
+  async canResume(_sessionId) {
+    return false;
+  }
+  formatCommand(commandName) {
+    return `/${commandName}`;
+  }
+}
+
+export { CURSOR_SDK_VERSION, checkCursorCredentials, liveTestCursorKey, cursorModelSelection, translateCursorMessage, composeFirstMessage, CursorAdapter };

package/dist/{cli-q24re23n.js → cli-e2xnc4m5.js}

@@ -17,13 +17,13 @@ import {
   recoverIncompleteRuns,
   repointTrackerSyncBySwarmId,
   resolveLeadOnlyRecoveryAssignment
-} from "./cli-kp42yek0.js";
+} from "./cli-fyra5y8k.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-re8z5p8p.js";
 import {
   createApprovalFollowUpTask
-} from "./cli-5xhpb3kv.js";
+} from "./cli-0z9dj97t.js";
 import {
   MAX_EMPTY_POLLS,
   assignUnassignedTaskPending,
@@ -74,13 +74,13 @@ import {
   settleSupersededTaskDependents,
   supersedeTask,
   updateAgentStatus
-} from "./cli-jf7wmv1r.js";
+} from "./cli-tsvj33y0.js";
 import {
   init_registry,
   init_resolver,
   registerTemplate,
   resolveTemplate
-} from "./cli-qjjvzwzd.js";
+} from "./cli-5c2j5yvx.js";
 import {
   init_env_flag,
   isEnvFlagEnabled

package/dist/{cli-f7kvq46p.js → cli-erxeg64j.js}

@@ -10,11 +10,18 @@ import {
 // src/workflows/event-bus.ts
 class InProcessEventBus {
   bus;
+  prefixHandlers = new Map;
   constructor(bus = new InProcessBus) {
     this.bus = bus;
   }
   emit(event, data) {
     this.bus.publish(`workflow:${event}`, data);
+    for (const [prefix, handlers] of this.prefixHandlers) {
+      if (!event.startsWith(prefix))
+        continue;
+      for (const handler of [...handlers])
+        handler(event, data);
+    }
   }
   on(event, handler) {
     this.bus.subscribe(`workflow:${event}`, handler);
@@ -22,6 +29,19 @@ class InProcessEventBus {
   off(event, handler) {
     this.bus.unsubscribe(`workflow:${event}`, handler);
   }
+  onPrefix(prefix, handler) {
+    const handlers = this.prefixHandlers.get(prefix) ?? new Set;
+    handlers.add(handler);
+    this.prefixHandlers.set(prefix, handlers);
+  }
+  offPrefix(prefix, handler) {
+    const handlers = this.prefixHandlers.get(prefix);
+    if (!handlers)
+      return;
+    handlers.delete(handler);
+    if (handlers.size === 0)
+      this.prefixHandlers.delete(prefix);
+  }
 }
 var workflowEventBus;
 var init_event_bus = __esm(() => {