@desplega.ai/agent-swarm 1.91.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/sdk-allowlist.ts

@@ -39,6 +39,9 @@ export const SDK_TOOL_NAME_MAP = {
   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",

package/src/scripts-runtime/types/stdlib.d.ts

@@ -262,6 +262,20 @@ declare module "swarm-sdk" {
     }): Promise<unknown>;
     script_delete(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
     script_queryTypes(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
+    script_launchRun(args: {
+      source: string;
+      args?: unknown;
+      idempotencyKey?: string;
+      scriptName?: string;
+      requestedByUserId?: string;
+    }): Promise<unknown>;
+    script_getRun(args: { id: string }): Promise<unknown>;
+    script_listRuns(args?: {
+      status?: "running" | "paused" | "completed" | "failed" | "cancelled" | "aborted_limit";
+      agentId?: string;
+      limit?: number;
+      offset?: number;
+    }): Promise<unknown>;
 
     // --- write: repos ---
     repo_update(args: Record<string, unknown>): Promise<unknown>;
@@ -320,7 +334,53 @@ declare module "swarm-sdk" {
 
   export interface ScriptLogger extends Console {}
 
+  export interface ScriptRunContext {
+    id: string;
+    agentId: string;
+    args: unknown;
+  }
+
+  export interface ScriptWorkflowSteps {
+    rawLlm(
+      label: string,
+      config: { prompt: string; model?: string; schema?: Record<string, unknown> },
+    ): Promise<unknown>;
+    agentTask(
+      label: string,
+      config: {
+        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>;
+      },
+    ): Promise<unknown>;
+    swarmScript(
+      label: string,
+      config: {
+        name?: string;
+        scriptName?: string;
+        source?: string;
+        args?: unknown;
+        scope?: ScriptScope;
+        fsMode?: ScriptFsMode;
+        intent?: string;
+        idempotencyKey?: string;
+      },
+    ): Promise<unknown>;
+    humanInTheLoop(): Promise<never>;
+  }
+
   export interface ScriptContext {
+    run?: ScriptRunContext;
+    step?: ScriptWorkflowSteps;
     swarm: SwarmSdk & { config: SwarmConfig };
     stdlib: ScriptStdlib;
     logger: ScriptLogger;

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

@@ -244,6 +244,20 @@ declare module "swarm-sdk" {
     }): Promise<unknown>;
     script_delete(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
     script_queryTypes(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
+    script_launchRun(args: {
+      source: string;
+      args?: unknown;
+      idempotencyKey?: string;
+      scriptName?: string;
+      requestedByUserId?: string;
+    }): Promise<unknown>;
+    script_getRun(args: { id: string }): Promise<unknown>;
+    script_listRuns(args?: {
+      status?: "running" | "paused" | "completed" | "failed" | "cancelled" | "aborted_limit";
+      agentId?: string;
+      limit?: number;
+      offset?: number;
+    }): Promise<unknown>;
 
     // --- write: repos ---
     repo_update(args: Record<string, unknown>): Promise<unknown>;
@@ -302,7 +316,53 @@ declare module "swarm-sdk" {
 
   export interface ScriptLogger extends Console {}
 
+  export interface ScriptRunContext {
+    id: string;
+    agentId: string;
+    args: unknown;
+  }
+
+  export interface ScriptWorkflowSteps {
+    rawLlm(
+      label: string,
+      config: { prompt: string; model?: string; schema?: Record<string, unknown> },
+    ): Promise<unknown>;
+    agentTask(
+      label: string,
+      config: {
+        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>;
+      },
+    ): Promise<unknown>;
+    swarmScript(
+      label: string,
+      config: {
+        name?: string;
+        scriptName?: string;
+        source?: string;
+        args?: unknown;
+        scope?: ScriptScope;
+        fsMode?: ScriptFsMode;
+        intent?: string;
+        idempotencyKey?: string;
+      },
+    ): Promise<unknown>;
+    humanInTheLoop(): Promise<never>;
+  }
+
   export interface ScriptContext {
+    run?: ScriptRunContext;
+    step?: ScriptWorkflowSteps;
     swarm: SwarmSdk & { config: SwarmConfig };
     stdlib: ScriptStdlib;
     logger: ScriptLogger;

package/src/server.ts

@@ -78,6 +78,7 @@ import {
 import { registerScriptDeleteTool } from "./tools/script-delete";
 import { registerScriptQueryTypesTool } from "./tools/script-query-types";
 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 { registerSendTaskTool } from "./tools/send-task";
@@ -227,6 +228,7 @@ export function createServer() {
   registerScriptUpsertTool(server);
   registerScriptDeleteTool(server);
   registerScriptQueryTypesTool(server);
+  registerScriptRunsTools(server);
 
   // External command routes - mirrors the `agent-swarm x ...` CLI surface.
   registerSwarmXTool(server);

package/src/slack/handlers.ts

@@ -18,6 +18,7 @@ import type { SlackFile } from "./files";
 import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
+import { extractSlackMessageText } from "./message-text";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
 import { registerTreeMessage } from "./watcher";
 
@@ -173,6 +174,8 @@ interface ThreadMessage {
   subtype?: string;
   text?: string;
   ts: string;
+  attachments?: Array<{ fallback?: string; text?: string; title?: string; pretext?: string }>;
+  blocks?: unknown[];
 }
 
 // Cache for bot's own user ID (avoids redundant auth.test calls)
@@ -286,8 +289,11 @@ async function getThreadContext(
     });
 
     const messages = (result.messages || []) as ThreadMessage[];
-    // Filter out the current message only (keep bot messages for context)
-    const previousMessages = messages.filter((m) => m.ts !== currentTs && m.text);
+    // Filter out the current message; include any message with extractable text
+    const previousMessages = messages.filter((m) => {
+      if (m.ts === currentTs) return false;
+      return extractSlackMessageText(m) !== "";
+    });
 
     if (previousMessages.length === 0) return "";
 
@@ -298,13 +304,14 @@ async function getThreadContext(
       const isBotMessage =
         m.user === botUserId || m.bot_id !== undefined || m.subtype === "bot_message";
 
+      const text = extractSlackMessageText(m);
       if (isBotMessage) {
         // Bot/agent message - truncate if too long
-        const truncatedText = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+        const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
         formattedMessages.push(`[Agent]: ${truncatedText}`);
       } else {
         const userName = m.user ? await getUserDisplayName(client, m.user) : "Unknown";
-        formattedMessages.push(`${userName}: ${m.text}`);
+        formattedMessages.push(`${userName}: ${text}`);
       }
     }
 

package/src/slack/message-text.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared utility for extracting displayable text from a Slack message.
+ *
+ * Slack integration/alert apps (Datadog, PagerDuty, GitHub) often post with
+ * an empty top-level `text` field and put all content in legacy `attachments`
+ * or Block Kit `blocks`. This helper falls back through those layers so callers
+ * never silently drop those messages.
+ */
+
+interface SlackAttachment {
+  fallback?: string;
+  text?: string;
+  title?: string;
+  pretext?: string;
+}
+
+// Internal shape used only inside the helper; callers pass `blocks?: unknown[]`
+interface SlackBlockInternal {
+  type?: string;
+  text?: { type?: string; text?: string };
+  /** section blocks may use fields[] instead of (or alongside) a top-level text object */
+  fields?: Array<{ type?: string; text?: string }>;
+  elements?: unknown[];
+}
+
+export interface SlackMessageLike {
+  text?: string;
+  attachments?: SlackAttachment[];
+  /** Typed as unknown[] so any Slack SDK block variant is accepted without casting. */
+  blocks?: unknown[];
+}
+
+/**
+ * Recursively collect plain text from a Slack rich_text node tree.
+ *
+ * Handles text leaf nodes plus all container types that carry child elements:
+ * rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted.
+ */
+function collectRichTextParts(node: unknown, parts: string[]): void {
+  if (node == null || typeof node !== "object") return;
+  const n = node as { type?: string; text?: string; elements?: unknown[] };
+  if (n.type === "text" && n.text) {
+    parts.push(n.text);
+  }
+  if (Array.isArray(n.elements)) {
+    for (const child of n.elements) {
+      collectRichTextParts(child, parts);
+    }
+  }
+}
+
+/**
+ * Return the best displayable text for a Slack message.
+ *
+ * Priority:
+ * 1. `msg.text` (non-empty)
+ * 2. `msg.attachments[]` — joins `fallback || text || title || pretext` for each
+ * 3. `msg.blocks[]` — extracts text from section (text + fields) and rich_text blocks
+ * 4. `""` if nothing found
+ */
+export function extractSlackMessageText(msg: SlackMessageLike): string {
+  if (msg.text?.trim()) return msg.text;
+
+  // Legacy attachments (Datadog, PagerDuty, GitHub alert apps)
+  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+    const parts = msg.attachments
+      .filter((a): a is SlackAttachment => a != null && typeof a === "object")
+      .map((a) => a.fallback || a.text || a.title || a.pretext || "")
+      .filter(Boolean);
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  // Block Kit blocks
+  if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
+    const parts: string[] = [];
+    for (const rawBlock of msg.blocks) {
+      if (rawBlock == null || typeof rawBlock !== "object") continue;
+      const block = rawBlock as SlackBlockInternal;
+      if (block.type === "section") {
+        if (block.text?.text) parts.push(block.text.text);
+        if (Array.isArray(block.fields)) {
+          for (const field of block.fields) {
+            if (field != null && typeof field === "object" && field.text) {
+              parts.push(field.text);
+            }
+          }
+        }
+      } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
+        for (const el of block.elements) {
+          collectRichTextParts(el, parts);
+        }
+      }
+    }
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  return "";
+}

package/src/slack/thread-buffer.ts

@@ -4,6 +4,7 @@ import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
+import { extractSlackMessageText } from "./message-text";
 import { registerTreeMessage } from "./watcher";
 
 interface BufferedMessage {
@@ -93,15 +94,16 @@ async function getThreadContextForBuffer(channelId: string, threadTs: string): P
     if (messages.length === 0) return "";
 
     const formatted = messages
-      .filter((m) => m.text)
+      .filter((m) => extractSlackMessageText(m) !== "")
       .map((m) => {
         const msg = m as Record<string, unknown>;
         const isBotMessage = msg.bot_id !== undefined || msg.subtype === "bot_message";
+        const text = extractSlackMessageText(m);
         if (isBotMessage) {
-          const truncated = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+          const truncated = text.length > 500 ? `${text.slice(0, 500)}...` : text;
           return `[Agent]: ${truncated}`;
         }
-        return `<@${m.user}>: ${m.text}`;
+        return `<@${m.user}>: ${text}`;
       })
       .join("\n");