@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/script-workflows/workflow-ctx.ts

@@ -0,0 +1,205 @@
+import { stdlib } from "../scripts-runtime/stdlib";
+
+type StepStatusResponse =
+  | { stepKey: string; stepType: string; result: unknown }
+  | { error: string };
+
+type StepWriteResponse = { ok: true } | { error: string };
+
+type RawLlmConfig = {
+  prompt: string;
+  model?: string;
+  schema?: Record<string, unknown>;
+};
+
+type AgentTaskConfig = {
+  template?: string;
+  task?: string;
+  agentId?: string;
+  tags?: string[];
+  priority?: number;
+  offerMode?: boolean;
+  dir?: string;
+  vcsRepo?: string;
+  model?: string;
+  parentTaskId?: string;
+  requestedByUserId?: string;
+  outputSchema?: Record<string, unknown>;
+};
+
+type SwarmScriptConfig = {
+  name?: string;
+  scriptName?: string;
+  source?: string;
+  args?: unknown;
+  scope?: "agent" | "global";
+  fsMode?: "none" | "workspace-rw";
+  intent?: string;
+  idempotencyKey?: string;
+};
+
+type WorkflowRunInfo = {
+  id: string;
+  agentId: string;
+  args: unknown;
+};
+
+export type WorkflowCtx = {
+  run: WorkflowRunInfo;
+  step: {
+    rawLlm: (label: string, config: RawLlmConfig) => Promise<unknown>;
+    agentTask: (label: string, config: AgentTaskConfig) => Promise<unknown>;
+    swarmScript: (label: string, config: SwarmScriptConfig) => Promise<unknown>;
+    humanInTheLoop: () => Promise<never>;
+  };
+  swarm: Record<string, (args?: unknown) => Promise<unknown>>;
+  stdlib: typeof stdlib;
+  logger: Console;
+};
+
+function encodeStepKey(label: string): string {
+  return encodeURIComponent(label);
+}
+
+function headers(apiKey: string, agentId: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "X-Agent-ID": agentId,
+    "Content-Type": "application/json",
+  };
+}
+
+async function readJson(res: Response): Promise<unknown> {
+  const text = await res.text();
+  return text ? JSON.parse(text) : {};
+}
+
+function apiError(prefix: string, status: number, body: unknown): Error {
+  const message =
+    body && typeof body === "object" && "error" in body
+      ? String((body as { error: unknown }).error)
+      : JSON.stringify(body);
+  return new Error(`${prefix} failed with ${status}: ${message}`);
+}
+
+export function buildWorkflowCtx(input: {
+  runId: string;
+  agentId: string;
+  apiKey: string;
+  baseUrl: string;
+  args: unknown;
+}): WorkflowCtx {
+  const baseUrl = input.baseUrl.replace(/\/$/, "");
+  const authHeaders = headers(input.apiKey, input.agentId);
+
+  async function fetchJson(path: string, init: RequestInit = {}): Promise<unknown> {
+    const res = await fetch(`${baseUrl}${path}`, {
+      ...init,
+      headers: { ...authHeaders, ...((init.headers as Record<string, string>) ?? {}) },
+    });
+    const body = await readJson(res);
+    if (!res.ok) throw apiError(path, res.status, body);
+    return body;
+  }
+
+  async function completedStep(
+    label: string,
+  ): Promise<{ found: true; result: unknown } | { found: false }> {
+    const res = await fetch(
+      `${baseUrl}/api/internal/script-runs/${input.runId}/steps/${encodeStepKey(label)}`,
+      {
+        headers: authHeaders,
+      },
+    );
+    if (res.status === 404) return { found: false };
+    const body = (await readJson(res)) as StepStatusResponse;
+    if (!res.ok) throw apiError(`step ${label}`, res.status, body);
+    return { found: true, result: "result" in body ? body.result : undefined };
+  }
+
+  async function writeStep(
+    label: string,
+    stepType: string,
+    config: unknown,
+    status: "completed" | "failed",
+    result?: unknown,
+    error?: string,
+  ): Promise<void> {
+    const body = (await fetchJson(`/api/internal/script-runs/${input.runId}/steps`, {
+      method: "POST",
+      body: JSON.stringify({ stepKey: label, stepType, config, status, result, error }),
+    })) as StepWriteResponse;
+    if (!("ok" in body)) throw new Error(`Failed to write journal step ${label}`);
+  }
+
+  async function durableStep(
+    label: string,
+    stepType: string,
+    config: unknown,
+    execute: () => Promise<unknown>,
+  ): Promise<unknown> {
+    const replayed = await completedStep(label);
+    if (replayed.found) return replayed.result;
+    try {
+      const result = await execute();
+      await writeStep(label, stepType, config, "completed", result);
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      await writeStep(label, stepType, config, "failed", undefined, error);
+      throw err;
+    }
+  }
+
+  const swarm = new Proxy({} as Record<string, (args?: unknown) => Promise<unknown>>, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return undefined;
+      return (args?: unknown) =>
+        fetchJson("/api/mcp-bridge", {
+          method: "POST",
+          body: JSON.stringify({ tool: prop.replaceAll("_", "-"), args: args ?? {} }),
+        });
+    },
+  });
+
+  return {
+    run: { id: input.runId, agentId: input.agentId, args: input.args },
+    step: {
+      rawLlm: (label, config) =>
+        durableStep(label, "raw-llm", config, async () =>
+          fetchJson("/api/internal/raw-llm", {
+            method: "POST",
+            body: JSON.stringify(config),
+          }),
+        ),
+      agentTask: (label, config) =>
+        durableStep(label, "agent-task", config, async () =>
+          fetchJson(`/api/internal/script-runs/${input.runId}/agent-task`, {
+            method: "POST",
+            body: JSON.stringify({ stepKey: label, ...config }),
+          }),
+        ),
+      swarmScript: (label, config) =>
+        durableStep(label, "swarm-script", config, async () =>
+          fetchJson("/api/scripts/run", {
+            method: "POST",
+            body: JSON.stringify({
+              name: config.name ?? config.scriptName,
+              source: config.source,
+              args: config.args,
+              scope: config.scope,
+              fsMode: config.fsMode ?? "none",
+              intent: config.intent ?? `script-run:${input.runId}:${label}`,
+              idempotencyKey: config.idempotencyKey,
+            }),
+          }),
+        ),
+      humanInTheLoop: async () => {
+        throw new Error("ctx.step.humanInTheLoop is stubbed in Script Workflows v1");
+      },
+    },
+    swarm,
+    stdlib,
+    logger: console,
+  };
+}

package/src/scripts-runtime/executors/native.ts

@@ -90,6 +90,7 @@ async function writeBareImportShims(tmpdir: string): Promise<void> {
     const shims: [string, string][] = [
       ["stdlib", `${runtimeDir}/stdlib.bundle.js`],
       ["swarm-sdk", `${runtimeDir}/swarm-sdk.bundle.js`],
+      ["zod", `${runtimeDir}/zod.bundle.js`],
     ];
     for (const [name, bundlePath] of shims) {
       const dir = `${tmpdir}/node_modules/${name}`;

package/src/scripts-runtime/sdk-allowlist.ts

@@ -1,19 +1,143 @@
 export const SDK_TOOL_NAME_MAP = {
+  // ── memory ──
   memory_search: "memory-search",
   memory_get: "memory-get",
   memory_rate: "memory_rate",
+  memory_delete: "memory-delete", // destructive
+  inject_learning: "inject-learning",
+
+  // ── tasks ──
   task_list: "get-tasks",
   task_get: "get-task-details",
   task_storeProgress: "store-progress",
+  task_poll: "poll-task",
+  task_send: "send-task",
+  task_cancel: "cancel-task", // destructive
+  task_action: "task-action",
+
+  // ── kv ──
   kv_get: "kv-get",
   kv_set: "kv-set",
   kv_del: "kv-delete",
   kv_incr: "kv-incr",
   kv_list: "kv-list",
+
+  // ── repos ──
   repo_list: "get-repos",
+  repo_update: "update-repo",
+
+  // ── schedules ──
   schedule_list: "list-schedules",
+  schedule_create: "create-schedule",
+  schedule_update: "update-schedule",
+  schedule_delete: "delete-schedule", // destructive
+  schedule_runNow: "run-schedule-now",
+
+  // ── scripts ──
   script_search: "script-search",
   script_run: "script-run",
+  script_upsert: "script-upsert",
+  script_delete: "script-delete", // destructive
+  script_queryTypes: "script-query-types",
+  script_launchRun: "launch-script-run",
+  script_getRun: "get-script-run",
+  script_listRuns: "list-script-runs",
+
+  // ── swarm / agent ──
+  swarm_get: "get-swarm",
+  agent_info: "my-agent-info",
+  agent_join: "join-swarm",
+  metrics_get: "get-metrics",
+  user_resolve: "resolve-user",
+  user_manage: "manage-user",
+  db_query: "db-query",
+
+  // ── config ──
+  config_get: "get-config",
+  config_list: "list-config",
+  config_set: "set-config",
+  config_delete: "delete-config", // destructive
+
+  // ── slack ──
+  slack_read: "slack-read",
+  slack_listChannels: "slack-list-channels",
+  slack_post: "slack-post", // external: sends to Slack
+  slack_reply: "slack-reply", // external: sends to Slack
+  slack_startThread: "slack-start-thread", // external: sends to Slack
+  slack_uploadFile: "slack-upload-file", // external: sends to Slack
+  slack_downloadFile: "slack-download-file",
+
+  // ── messaging (internal) ──
+  message_read: "read-messages",
+  message_post: "post-message",
+
+  // ── profiles ──
+  profile_update: "update-profile",
+
+  // ── context / profiles ──
+  context_history: "context-history",
+  context_diff: "context-diff",
+
+  // ── services ──
+  service_list: "list-services",
+  service_register: "register-service",
+  service_unregister: "unregister-service", // destructive
+  service_updateStatus: "update-service-status",
+
+  // ── workflows ──
+  workflow_list: "list-workflows",
+  workflow_get: "get-workflow",
+  workflow_create: "create-workflow",
+  workflow_update: "update-workflow",
+  workflow_patch: "patch-workflow",
+  workflow_patchNode: "patch-workflow-node",
+  workflow_delete: "delete-workflow", // destructive
+  workflow_trigger: "trigger-workflow",
+  workflow_listRuns: "list-workflow-runs",
+  workflow_getRun: "get-workflow-run",
+  workflow_retryRun: "retry-workflow-run",
+  workflow_cancelRun: "cancel-workflow-run", // destructive
+
+  // ── prompt templates ──
+  prompt_list: "list-prompt-templates",
+  prompt_get: "get-prompt-template",
+  prompt_set: "set-prompt-template",
+  prompt_delete: "delete-prompt-template", // destructive
+  prompt_preview: "preview-prompt-template",
+
+  // ── tracker ──
+  tracker_status: "tracker-status",
+  tracker_syncStatus: "tracker-sync-status",
+  tracker_linkTask: "tracker-link-task",
+  tracker_unlink: "tracker-unlink", // destructive
+  tracker_mapAgent: "tracker-map-agent",
+
+  // ── skills ──
+  skill_list: "skill-list",
+  skill_get: "skill-get",
+  skill_search: "skill-search",
+  skill_create: "skill-create",
+  skill_update: "skill-update",
+  skill_delete: "skill-delete", // destructive
+  skill_install: "skill-install",
+  skill_uninstall: "skill-uninstall", // destructive
+  skill_publish: "skill-publish",
+
+  // ── mcp servers ──
+  mcpServer_list: "mcp-server-list",
+  mcpServer_get: "mcp-server-get",
+  mcpServer_create: "mcp-server-create",
+  mcpServer_update: "mcp-server-update",
+  mcpServer_delete: "mcp-server-delete", // destructive
+  mcpServer_install: "mcp-server-install",
+  mcpServer_uninstall: "mcp-server-uninstall", // destructive
+
+  // ── pages & metrics ──
+  page_create: "create_page",
+  metric_create: "create_metric",
+
+  // ── human input ──
+  request_humanInput: "request-human-input",
 } as const;
 
 export const SDK_ALLOWLIST = Object.keys(SDK_TOOL_NAME_MAP) as Array<

package/src/scripts-runtime/swarm-sdk.ts

@@ -1,6 +1,6 @@
 import { scrubObject } from "../utils/secret-scrubber";
 import { Redacted } from "./redacted";
-import { isSdkToolAllowed } from "./sdk-allowlist";
+import { isSdkToolAllowed, mcpToolNameForSdkMethod } from "./sdk-allowlist";
 import type { SwarmConfig } from "./swarm-config";
 
 type BridgeRequest = {
@@ -43,9 +43,14 @@ function kvPath(args: Record<string, unknown>, keyRequired = true): string {
   return key ? `/api/kv/${encodeURIComponent(key)}` : "/api/kv";
 }
 
-function bridgeRequestFor(name: string, args: unknown): BridgeRequest {
+/**
+ * Maps SDK method names to specific REST endpoints where they exist.
+ * Returns null for tools that should fall through to the generic MCP bridge.
+ */
+function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
   const body = argsRecord(args);
   switch (name) {
+    // ── memory ──
     case "memory_search":
       return { method: "POST", path: "/api/memory/search", body };
     case "memory_get": {
@@ -67,6 +72,13 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest {
       };
       return { method: "POST", path: "/api/memory/rate", body: { events: [event] } };
     }
+    case "memory_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("memory_delete requires string `id`");
+      return { method: "DELETE", path: `/api/memory/${encodeURIComponent(id)}` };
+    }
+
+    // ── tasks ──
     case "task_list":
       return { method: "GET", path: appendQuery("/api/tasks", body) };
     case "task_get": {
@@ -94,6 +106,13 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest {
         body: { progress: body.progress ?? "" },
       };
     }
+    case "task_cancel": {
+      const taskId = typeof body.taskId === "string" ? body.taskId : undefined;
+      if (!taskId) throw new Error("task_cancel requires string `taskId`");
+      return { method: "POST", path: `/api/tasks/${encodeURIComponent(taskId)}/cancel` };
+    }
+
+    // ── kv ──
     case "kv_get":
       return { method: "GET", path: kvPath(body) };
     case "kv_set":
@@ -119,11 +138,15 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest {
           offset: body.offset,
         }),
       };
+
+    // ── repos ──
     case "repo_list":
       return {
         method: "GET",
         path: appendQuery("/api/repos", { autoClone: body.autoClone, name: body.name }),
       };
+
+    // ── schedules ──
     case "schedule_list":
       return {
         method: "GET",
@@ -134,12 +157,164 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest {
           hideCompleted: body.hideCompleted,
         }),
       };
+
+    // ── scripts ──
     case "script_search":
       return { method: "POST", path: "/api/scripts/search", body };
     case "script_run":
       return { method: "POST", path: "/api/scripts/run", body };
+
+    // ── swarm / agent ──
+    case "db_query":
+      return { method: "POST", path: "/api/db-query", body };
+    case "swarm_get":
+      return {
+        method: "GET",
+        path: appendQuery("/api/agents", {
+          fields: body.includeFull ? "full" : "slim",
+        }),
+      };
+    case "agent_info":
+      return { method: "GET", path: "/me" };
+    case "metrics_get":
+      return { method: "GET", path: "/api/metrics" };
+    case "task_poll":
+      return { method: "GET", path: "/api/poll" };
+
+    // ── config ──
+    case "config_get":
+      return {
+        method: "GET",
+        path: appendQuery("/api/config/resolved", {
+          agentId: body.agentId,
+          repoId: body.repoId,
+          key: body.key,
+          includeSecrets: body.includeSecrets,
+        }),
+      };
+    case "config_list":
+      return {
+        method: "GET",
+        path: appendQuery("/api/config", {
+          scope: body.scope,
+          scopeId: body.scopeId,
+          key: body.key,
+          includeSecrets: body.includeSecrets,
+        }),
+      };
+    case "config_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("config_delete requires string `id`");
+      return { method: "DELETE", path: `/api/config/${encodeURIComponent(id)}` };
+    }
+
+    // ── services ──
+    case "service_list":
+      return {
+        method: "GET",
+        path: appendQuery("/api/services", {
+          agentId: body.agentId,
+          name: body.name,
+          status: body.status,
+        }),
+      };
+
+    // ── workflows ──
+    case "workflow_list":
+      return {
+        method: "GET",
+        path: appendQuery("/api/workflows", {
+          fields: body.includeFull ? "full" : "slim",
+        }),
+      };
+    case "workflow_get": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("workflow_get requires string `id`");
+      return { method: "GET", path: `/api/workflows/${encodeURIComponent(id)}` };
+    }
+    case "workflow_listRuns": {
+      const wfId = typeof body.workflowId === "string" ? body.workflowId : undefined;
+      if (!wfId) throw new Error("workflow_listRuns requires string `workflowId`");
+      return {
+        method: "GET",
+        path: appendQuery(`/api/workflows/${encodeURIComponent(wfId)}/runs`, {
+          status: body.status,
+        }),
+      };
+    }
+    case "workflow_getRun": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("workflow_getRun requires string `id`");
+      return { method: "GET", path: `/api/workflow-runs/${encodeURIComponent(id)}` };
+    }
+    case "workflow_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("workflow_delete requires string `id`");
+      return { method: "DELETE", path: `/api/workflows/${encodeURIComponent(id)}` };
+    }
+
+    // ── prompt templates ──
+    case "prompt_list":
+      return {
+        method: "GET",
+        path: appendQuery("/api/prompt-templates", {
+          eventType: body.eventType,
+          scope: body.scope,
+          scopeId: body.scopeId,
+          isDefault: body.isDefault,
+        }),
+      };
+    case "prompt_get": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("prompt_get requires string `id`");
+      return { method: "GET", path: `/api/prompt-templates/${encodeURIComponent(id)}` };
+    }
+    case "prompt_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("prompt_delete requires string `id`");
+      return { method: "DELETE", path: `/api/prompt-templates/${encodeURIComponent(id)}` };
+    }
+
+    // ── skills ──
+    case "skill_list":
+      return {
+        method: "GET",
+        path: appendQuery("/api/skills", {
+          scope: body.scope,
+          scopeId: body.scopeId,
+          includeBuiltin: body.includeBuiltin,
+        }),
+      };
+    case "skill_get": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("skill_get requires string `id`");
+      return { method: "GET", path: `/api/skills/${encodeURIComponent(id)}` };
+    }
+    case "skill_search":
+      return { method: "POST", path: "/api/skills/search", body };
+    case "skill_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("skill_delete requires string `id`");
+      return { method: "DELETE", path: `/api/skills/${encodeURIComponent(id)}` };
+    }
+
+    // ── mcp servers ──
+    case "mcpServer_list":
+      return { method: "GET", path: "/api/mcp-servers" };
+    case "mcpServer_get": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("mcpServer_get requires string `id`");
+      return { method: "GET", path: `/api/mcp-servers/${encodeURIComponent(id)}` };
+    }
+    case "mcpServer_delete": {
+      const id = typeof body.id === "string" ? body.id : undefined;
+      if (!id) throw new Error("mcpServer_delete requires string `id`");
+      return { method: "DELETE", path: `/api/mcp-servers/${encodeURIComponent(id)}` };
+    }
+
+    // ── fallthrough: proxy via generic MCP bridge ──
     default:
-      throw new Error(`Tool '${name}' is not exposed through the scripts SDK bridge`);
+      return null;
   }
 }
 
@@ -152,6 +327,26 @@ async function callBridgeApi(
   const baseUrl = Redacted.value(config.mcpBaseUrl).replace(/\/$/, "");
   const request = bridgeRequestFor(name, args);
 
+  // Tools without a specific REST route go through the generic MCP bridge
+  if (!request) {
+    const mcpToolName = mcpToolNameForSdkMethod(name);
+    const res = await fetch(`${baseUrl}/api/mcp-bridge`, {
+      method: "POST",
+      headers: headers(config),
+      body: JSON.stringify({ tool: mcpToolName, args: args ?? {} }),
+    });
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : {};
+    if (!res.ok && options.throwOnError) {
+      const message =
+        data && typeof data === "object" && "error" in data
+          ? String((data as { error: unknown }).error)
+          : `api failed with ${res.status}`;
+      throw new Error(`swarm-sdk: ${name} failed with ${res.status}: ${message}`);
+    }
+    return scrubObject({ success: res.ok, status: res.status, data });
+  }
+
   const res = await fetch(`${baseUrl}${request.path}`, {
     method: request.method,
     headers: headers(config),