@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/tests/script-workflows-label-lint.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { lintWorkflowLabels } from "../script-workflows/label-lint";
+
+describe("lintWorkflowLabels", () => {
+  test("rejects a literal step label inside a loop", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(args, ctx) {
+        for (const item of args.items) {
+          await ctx.step.agentTask("process", { task: item.task });
+        }
+      }
+    `);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]?.label).toBe("process");
+      expect(result.errors[0]?.detail).toContain("inside a loop");
+    }
+  });
+
+  test("allows template literal step labels inside a loop", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(args, ctx) {
+        for (const item of args.items) {
+          await ctx.step.agentTask(\`process:\${item.id}\`, { task: item.task });
+        }
+      }
+    `);
+
+    expect(result).toEqual({ ok: true });
+  });
+
+  test("allows literal step labels outside loops", () => {
+    const result = lintWorkflowLabels(`
+      export default async function main(_args, ctx) {
+        await ctx.step.rawLlm("summarize", { prompt: "hello" });
+      }
+    `);
+
+    expect(result).toEqual({ ok: true });
+  });
+});

package/src/tests/script-workflows-runtime-e2e.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { rm, unlink } from "node:fs/promises";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { closeDb, createAgent, getDb, initDb, listScriptRunJournalSteps } from "../be/db";
+import { handleCore } from "../http/core";
+import { handleScriptRuns } from "../http/script-runs";
+import { handleScripts } from "../http/scripts";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+
+const TEST_DB_PATH = "./test-script-workflows-runtime-e2e.sqlite";
+const WORKFLOW_RUNTIME_DIR = "./test-script-workflows-runtime";
+const API_KEY = "test-script-workflows-runtime-key-1234567890";
+
+let agentId: string;
+let server: Server;
+let baseUrl: string;
+let savedEnv: NodeJS.ProcessEnv;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function listen(server: Server): Promise<number> {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") reject(new Error("No server address"));
+      else resolve(address.port);
+    });
+  });
+}
+
+function closeServer(server: Server): Promise<void> {
+  return new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+async function route(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const agentId = req.headers["x-agent-id"] as string | undefined;
+  if (await handleCore(req, res, agentId, API_KEY)) return;
+  const pathSegments = getPathSegments(req.url || "");
+  const queryParams = parseQueryParams(req.url || "");
+  if (await handleScriptRuns(req, res, pathSegments, queryParams, agentId)) return;
+  if (await handleScripts(req, res, pathSegments, queryParams, agentId)) return;
+  res.writeHead(404);
+  res.end("Not Found");
+}
+
+async function api(path: string, init: RequestInit = {}): Promise<Response> {
+  return fetch(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "X-Agent-ID": agentId,
+      "Content-Type": "application/json",
+      ...((init.headers as Record<string, string>) ?? {}),
+    },
+  });
+}
+
+async function waitForRun(
+  id: string,
+): Promise<{ status: string; output?: unknown; error?: string }> {
+  const deadline = Date.now() + 10_000;
+  while (Date.now() < deadline) {
+    const res = await api(`/api/script-runs/${id}`);
+    const body = (await res.json()) as {
+      run: { status: string; output?: unknown; error?: string };
+    };
+    if (["completed", "failed", "cancelled", "aborted_limit"].includes(body.run.status)) {
+      return body.run;
+    }
+    await Bun.sleep(250);
+  }
+  throw new Error("Timed out waiting for script run");
+}
+
+beforeAll(async () => {
+  savedEnv = { ...process.env };
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  process.env.AGENT_SWARM_API_KEY = API_KEY;
+  process.env.API_KEY = API_KEY;
+  process.env.APP_URL = "https://app.example.test";
+  delete process.env.SCRIPT_RUN_SUPERVISOR_DISABLE;
+  await rm(WORKFLOW_RUNTIME_DIR, { recursive: true, force: true });
+  await Bun.$`bun build ./src/script-workflows/harness.ts --target bun --no-splitting --outfile ${WORKFLOW_RUNTIME_DIR}/harness.bundle.js`.quiet();
+  process.env.SCRIPT_WORKFLOW_RUNTIME_DIR = WORKFLOW_RUNTIME_DIR;
+  refreshSecretScrubberCache();
+
+  const agent = createAgent({ name: "script-workflow-e2e-worker", isLead: false, status: "idle" });
+  agentId = agent.id;
+  server = createServer((req, res) => {
+    route(req, res).catch((err) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+    });
+  });
+  const port = await listen(server);
+  baseUrl = `http://127.0.0.1:${port}`;
+  process.env.MCP_BASE_URL = baseUrl;
+});
+
+afterAll(async () => {
+  await closeServer(server);
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+  await rm(WORKFLOW_RUNTIME_DIR, { recursive: true, force: true });
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshSecretScrubberCache();
+});
+
+beforeEach(() => {
+  getDb().run("DELETE FROM script_run_journal");
+  getDb().run("DELETE FROM script_runs");
+});
+
+describe("script workflow runtime", () => {
+  test("runs a durable one-off script and replays a completed step", async () => {
+    const source = `
+      export default async function main(args, ctx) {
+        const first = await ctx.step.swarmScript("double", {
+          source: "export default async (args) => args.value * 2;",
+          args: { value: args.value },
+          intent: "script-workflow-e2e"
+        });
+        const second = await ctx.step.swarmScript("double", {
+          source: "export default async () => 999;",
+          intent: "script-workflow-e2e-should-replay"
+        });
+        return { runId: ctx.run.id, first, second };
+      }
+    `;
+
+    const created = await api("/api/script-runs", {
+      method: "POST",
+      body: JSON.stringify({ source, args: { value: 7 }, background: true }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string };
+
+    const run = await waitForRun(id);
+    expect(run.status).toBe("completed");
+    expect(run.output).toMatchObject({
+      runId: id,
+      first: { result: 14, exitCode: 0 },
+      second: { result: 14, exitCode: 0 },
+    });
+
+    const journal = listScriptRunJournalSteps(id);
+    expect(journal).toHaveLength(1);
+    expect(journal[0]?.stepKey).toBe("double");
+    expect(journal[0]?.stepType).toBe("swarm-script");
+  });
+});

package/src/tests/scripts-mcp-e2e.test.ts

@@ -6,10 +6,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { closeDb, createAgent, getDb, initDb } from "../be/db";
 import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import { handleCore } from "../http/core";
+import { handleScriptRuns } from "../http/script-runs";
 import { handleScripts } from "../http/scripts";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { registerScriptDeleteTool } from "../tools/script-delete";
 import { registerScriptRunTool } from "../tools/script-run";
+import { registerScriptRunsTools } from "../tools/script-runs";
 import { registerScriptSearchTool } from "../tools/script-search";
 import { registerScriptUpsertTool } from "../tools/script-upsert";
 import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
@@ -65,6 +67,7 @@ function buildToolServer() {
   const server = new McpServer({ name: "scripts-mcp-e2e", version: "1.0.0" });
   registerScriptSearchTool(server);
   registerScriptRunTool(server);
+  registerScriptRunsTools(server);
   registerScriptUpsertTool(server);
   registerScriptDeleteTool(server);
   const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
@@ -74,6 +77,9 @@ function buildToolServer() {
     run: registered["script-run"]!,
     upsert: registered["script-upsert"]!,
     del: registered["script-delete"]!,
+    launchScriptRun: registered["launch-script-run"]!,
+    getScriptRun: registered["get-script-run"]!,
+    listScriptRuns: registered["list-script-runs"]!,
   };
 }
 
@@ -126,7 +132,10 @@ async function dispatchScriptsApi(url: string, init: RequestInit = {}): Promise<
   if (!(await handleCore(req, res, agentId, API_KEY))) {
     const pathSegments = getPathSegments(req.url || "");
     const queryParams = parseQueryParams(req.url || "");
-    if (!(await handleScripts(req, res, pathSegments, queryParams, agentId))) {
+    if (
+      !(await handleScripts(req, res, pathSegments, queryParams, agentId)) &&
+      !(await handleScriptRuns(req, res, pathSegments, queryParams, agentId))
+    ) {
       res.writeHead(404);
       res.end("Not Found");
     }
@@ -148,6 +157,7 @@ beforeAll(async () => {
   await removeDbFiles(TEST_DB_PATH);
   initDb(TEST_DB_PATH);
   process.env.AGENT_SWARM_API_KEY = API_KEY;
+  process.env.SCRIPT_RUN_SUPERVISOR_DISABLE = "true";
   delete process.env.API_KEY;
   refreshSecretScrubberCache();
   setScriptEmbeddingProviderForTests(fakeEmbeddingProvider);
@@ -155,7 +165,10 @@ beforeAll(async () => {
   process.env.MCP_BASE_URL = "http://scripts-mcp-e2e.test";
   globalThis.fetch = (async (input, init) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (url.startsWith("http://scripts-mcp-e2e.test/api/scripts/")) {
+    if (
+      url.startsWith("http://scripts-mcp-e2e.test/api/scripts/") ||
+      url.startsWith("http://scripts-mcp-e2e.test/api/script-runs")
+    ) {
       return dispatchScriptsApi(url, init);
     }
     return savedFetch(input, init);
@@ -179,6 +192,8 @@ afterAll(async () => {
 
 beforeEach(() => {
   getDb().run("DELETE FROM scripts");
+  getDb().run("DELETE FROM script_run_journal");
+  getDb().run("DELETE FROM script_runs");
 });
 
 describe("script_ MCP HTTP proxy tools", () => {
@@ -226,6 +241,38 @@ describe("script_ MCP HTTP proxy tools", () => {
     expect(result.structuredContent.error).toContain("HTTP MCP transport");
   });
 
+  test("launches, lists, and inspects durable script workflow runs", async () => {
+    const tools = buildToolServer();
+    const source = `export default async function main() { return { ok: true }; }`;
+
+    const launched = (await tools.launchScriptRun.handler(
+      { source, args: { input: true }, scriptName: "mcp-script-workflow" },
+      meta(workerId),
+    )) as StructuredResult<{ id: string; status: string; url: string }>;
+    expect(launched.structuredContent.success).toBe(true);
+    expect(launched.structuredContent.status).toBe(201);
+    expect(launched.structuredContent.data?.status).toBe("running");
+    const runId = launched.structuredContent.data?.id;
+    expect(runId).toBeTruthy();
+
+    const listed = (await tools.listScriptRuns.handler(
+      { status: "running", limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{ runs: Array<{ id: string }>; total: number }>;
+    expect(listed.structuredContent.success).toBe(true);
+    expect(listed.structuredContent.data?.total).toBe(1);
+    expect(listed.structuredContent.data?.runs[0]?.id).toBe(runId);
+
+    const detail = (await tools.getScriptRun.handler(
+      { id: runId },
+      meta(workerId),
+    )) as StructuredResult<{ run: { id: string; status: string }; journal: unknown[] }>;
+    expect(detail.structuredContent.success).toBe(true);
+    expect(detail.structuredContent.data?.run.id).toBe(runId);
+    expect(detail.structuredContent.data?.run.status).toBe("running");
+    expect(detail.structuredContent.data?.journal).toEqual([]);
+  });
+
   test("typed SDK fixture passes upsert typecheck and wrong arg type fails", async () => {
     const tools = buildToolServer();
     const source = `

package/src/tests/scripts-runtime.test.ts

@@ -288,6 +288,39 @@ describe("runScript", () => {
     }
   });
 
+  test("zod import works in compiled binary mode (SCRIPT_RUNTIME_DIR)", async () => {
+    const tmpdir = `${process.env.TMPDIR ?? "/tmp"}/script-runtime-test-${crypto.randomUUID()}`;
+    await Bun.$`mkdir -p ${tmpdir}`;
+    try {
+      const runtimeSrc = new URL("../scripts-runtime", import.meta.url).pathname;
+      await Bun.$`bun build ${runtimeSrc}/eval-harness.ts --target bun --no-splitting --outfile ${tmpdir}/eval-harness.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/stdlib/index.ts --target bun --no-splitting --outfile ${tmpdir}/stdlib.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/swarm-sdk.ts --target bun --no-splitting --outfile ${tmpdir}/swarm-sdk.bundle.js`.quiet();
+      const zodEntry = Bun.resolveSync("zod", import.meta.dir);
+      await Bun.$`bun build ${zodEntry} --target bun --no-splitting --outfile ${tmpdir}/zod.bundle.js`.quiet();
+
+      process.env.SCRIPT_RUNTIME_DIR = tmpdir;
+
+      const output = await runScript({
+        agentId: "agent-1",
+        args: { name: "test" },
+        resources,
+        source: `
+          import { z } from "zod";
+          export const argsSchema = z.object({ name: z.string() });
+          export default async (args: z.infer<typeof argsSchema>) => ({ greeting: "hello " + args.name });
+        `,
+      });
+
+      expect(output.error).toBeUndefined();
+      expect(output.result).toEqual({ greeting: "hello test" });
+      expect(output.exitCode).toBe(0);
+    } finally {
+      delete process.env.SCRIPT_RUNTIME_DIR;
+      await Bun.$`rm -rf ${tmpdir}`;
+    }
+  });
+
   test("argsSchema rejects invalid args with a formatted Zod error", async () => {
     const output = await runScript({
       agentId: "agent-1",