@desplega.ai/agent-swarm 1.100.3 → 1.100.4

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.100.3",
+    "version": "1.100.4",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.100.3",
+  "version": "1.100.4",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/tests/workflow-swarm-script.test.ts

@@ -255,6 +255,231 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { seen: "mapped-value" } });
   });
 
+  test("exact object token outside swarm-script args is still stringified", async () => {
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "echo",
+          type: "echo",
+          config: { value: "{{trigger.payload}}" },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { payload: { a: 1 } }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const echoStep = steps.find((step) => step.nodeId === "echo");
+
+    expect(run?.status).toBe("completed");
+    expect(echoStep?.status).toBe("completed");
+    expect(echoStep?.output).toEqual({ value: '{"a":1}' });
+  });
+
+  test("{{path}} args: object arg is injected as raw object, not JSON string", async () => {
+    await saveScript(
+      "echo-obj",
+      `export default async (args: { data: Record<string, unknown> }) => ({ isObject: typeof args.data === "object" && !Array.isArray(args.data), keys: Object.keys(args.data ?? {}) });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-obj",
+            args: { data: "{{trigger.payload}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { payload: { a: 1, b: 2 } }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isObject: true, keys: ["a", "b"] } });
+  });
+
+  test("{{path}} args: array arg is injected as raw array, not JSON string", async () => {
+    await saveScript(
+      "echo-arr",
+      `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-arr",
+            args: { items: "{{trigger.list}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { list: ["x", "y", "z"] }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 3 } });
+  });
+
+  test("{{path}} args: empty array is injected as raw empty array with length 0, not '[]' string", async () => {
+    await saveScript(
+      "echo-empty-arr",
+      `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-empty-arr",
+            args: { items: "{{trigger.empty}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { empty: [] }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 0 } });
+  });
+
+  test("{{path}} args: string scalar arg is injected as the string value", async () => {
+    await saveScript(
+      "echo-str",
+      `export default async (args: { name: string }) => ({ isString: typeof args.name === "string", value: args.name });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-str",
+            args: { name: "{{trigger.ruleName}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(
+      wf,
+      { ruleName: "local-rules/cognitive-complexity" },
+      registry,
+    );
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({
+      result: { isString: true, value: "local-rules/cognitive-complexity" },
+    });
+  });
+
+  test("{{path}} args: number scalar arg is injected as a number, not a string", async () => {
+    await saveScript(
+      "echo-num",
+      `export default async (args: { count: number }) => ({ isNumber: typeof args.count === "number", value: args.count });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-num",
+            args: { count: "{{trigger.maxFiles}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { maxFiles: 3 }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isNumber: true, value: 3 } });
+  });
+
+  test("{{path}} args: boolean scalar arg is injected as a boolean, not a string", async () => {
+    await saveScript(
+      "echo-bool",
+      `export default async (args: { enabled: boolean }) => ({ isBoolean: typeof args.enabled === "boolean", value: args.enabled });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-bool",
+            args: { enabled: "{{trigger.enabled}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { enabled: false }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isBoolean: true, value: false } });
+  });
+
+  test("{{path}} args: mixed string template still produces a string via interpolation", async () => {
+    await saveScript(
+      "echo-mixed",
+      `export default async (args: { label: string }) => ({ isString: typeof args.label === "string", value: args.label });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-mixed",
+            args: { label: "rule-{{trigger.ruleName}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { ruleName: "no-explicit-any" }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({
+      result: { isString: true, value: "rule-no-explicit-any" },
+    });
+  });
+
   test("fsMode workspace-rw is rejected at config validation with a clear error message", async () => {
     await saveScript("noop", `export default async () => ({ ok: true });`);
     const executor = new SwarmScriptExecutor(deps);

package/src/tests/workflow-template.test.ts

@@ -205,6 +205,23 @@ describe("deepInterpolate", () => {
     expect(unresolved).toEqual([]);
   });
 
+  test("exact object token is stringified by default", () => {
+    const { value, unresolved } = deepInterpolate("{{body}}", { body: { message: "hello" } });
+    expect(value).toBe('{"message":"hello"}');
+    expect(unresolved).toEqual([]);
+  });
+
+  test("exact object token preserves raw value when requested", () => {
+    const body = { message: "hello" };
+    const { value, unresolved } = deepInterpolate(
+      "{{body}}",
+      { body },
+      { preserveRawTokens: true },
+    );
+    expect(value).toBe(body);
+    expect(unresolved).toEqual([]);
+  });
+
   test("mixed array (string + number + boolean)", () => {
     const { value, unresolved } = deepInterpolate(["{{name}}", 42, true, null], {
       name: "Test",

package/src/workflows/engine.ts

@@ -494,7 +494,7 @@ async function executeStep(
   }
 
   // 4. Deep-interpolate config using local context (not global ctx)
-  const { value: interpolatedValue, unresolved } = deepInterpolate(node.config, interpolationCtx);
+  const { value: interpolatedValue, unresolved } = interpolateNodeConfig(node, interpolationCtx);
   const interpolatedConfig = interpolatedValue as Record<string, unknown>;
   const executionCtx: Record<string, unknown> = { ...ctx, ...interpolationCtx };
 
@@ -709,6 +709,27 @@ export function findReadyNodes(
   });
 }
 
+export function interpolateNodeConfig(
+  node: Pick<WorkflowNode, "type" | "config">,
+  interpolationCtx: Record<string, unknown>,
+): { value: unknown; unresolved: string[] } {
+  if (node.type !== "swarm-script" || !Object.hasOwn(node.config, "args")) {
+    return deepInterpolate(node.config, interpolationCtx);
+  }
+
+  const { args, ...configWithoutArgs } = node.config;
+  const configResult = deepInterpolate(configWithoutArgs, interpolationCtx);
+  const argsResult = deepInterpolate(args, interpolationCtx, { preserveRawTokens: true });
+
+  return {
+    value: {
+      ...(configResult.value as Record<string, unknown>),
+      args: argsResult.value,
+    },
+    unresolved: [...configResult.unresolved, ...argsResult.unresolved],
+  };
+}
+
 // ─── Helpers ───────────────────────────────────────────────
 
 function timeoutPromise(ms: number): Promise<never> {

package/src/workflows/retry-poller.ts

@@ -8,9 +8,8 @@ import {
 import type { RetryPolicy } from "../types";
 import { checkpointStep, checkpointStepFailure } from "./checkpoint";
 import { getSuccessors } from "./definition";
-import { walkGraph } from "./engine";
+import { interpolateNodeConfig, walkGraph } from "./engine";
 import type { ExecutorRegistry } from "./executors/registry";
-import { deepInterpolate } from "./template";
 import { runStepValidation } from "./validation";
 
 let pollerTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -62,7 +61,7 @@ export function startRetryPoller(registry: ExecutorRegistry, intervalMs = 5000):
           const ctx = (run.context ?? {}) as Record<string, unknown>;
 
           // Deep-interpolate config
-          const { value: interpolatedValue } = deepInterpolate(node.config, ctx);
+          const { value: interpolatedValue } = interpolateNodeConfig(node, ctx);
           const interpolatedConfig = interpolatedValue as Record<string, unknown>;
 
           // Get executor and re-run

package/src/workflows/template.ts

@@ -10,6 +10,10 @@ export interface InterpolateResult {
   unresolved: string[];
 }
 
+export interface DeepInterpolateOptions {
+  preserveRawTokens?: boolean;
+}
+
 export function interpolate(template: string, ctx: Record<string, unknown>): InterpolateResult {
   const unresolved: string[] = [];
   const result = template.replace(/\{\{([^}]+)\}\}/g, (_match, path: string) => {
@@ -43,18 +47,62 @@ function safeStringify(value: unknown): string {
   }
 }
 
+/** Matches a string that is EXACTLY one {{path}} token with no surrounding text. */
+const EXACT_TOKEN_RE = /^\{\{([^}]+)\}\}$/;
+
+/**
+ * Resolve a dot-separated path against a context object.
+ * Returns `{ found: true, value }` on success, `{ found: false }` when any
+ * segment is missing or the traversal hits a non-object.
+ */
+function resolvePath(
+  path: string,
+  ctx: Record<string, unknown>,
+): { found: true; value: unknown } | { found: false } {
+  const keys = path.trim().split(".");
+  let value: unknown = ctx;
+  for (const key of keys) {
+    if (value == null || typeof value !== "object") return { found: false };
+    value = (value as Record<string, unknown>)[key];
+  }
+  if (value === undefined) return { found: false };
+  return { found: true, value };
+}
+
 /**
  * Deep-interpolate an arbitrary value tree (objects, arrays, strings).
+ *
+ * When `preserveRawTokens` is true and a string value is **exactly** one
+ * `{{path}}` token with no surrounding text, the resolved value is returned
+ * as-is (preserving object / array / number / boolean types). This is the
+ * "raw injection" path used by `swarm-script` node `config.args`.
+ *
+ * When a string contains multiple tokens or surrounding text (e.g.
+ * `"prefix-{{x}}"`) the existing string-interpolation path is used so the
+ * result remains a string.
+ *
  * Non-string leaves are passed through unchanged.
  */
 export function deepInterpolate(
   value: unknown,
   ctx: Record<string, unknown>,
+  options: DeepInterpolateOptions = {},
 ): { value: unknown; unresolved: string[] } {
   const allUnresolved: string[] = [];
 
   function walk(v: unknown): unknown {
     if (typeof v === "string") {
+      const exactMatch = options.preserveRawTokens ? EXACT_TOKEN_RE.exec(v) : null;
+      if (exactMatch?.[1]) {
+        const path = exactMatch[1].trim();
+        const resolved = resolvePath(path, ctx);
+        if (!resolved.found) {
+          allUnresolved.push(path);
+          return "";
+        }
+        return resolved.value;
+      }
+      // Multi-token or mixed string - fall back to string interpolation.
       const { result, unresolved } = interpolate(v, ctx);
       allUnresolved.push(...unresolved);
       return result;