@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/providers/pi-mono-mcp-client.ts

@@ -0,0 +1,124 @@
+/**
+ * Minimal MCP client for Streamable HTTP transport.
+ *
+ * Connects to the swarm's HTTP MCP endpoint, performs the handshake,
+ * discovers tools, and forwards tool calls. This avoids depending on
+ * a separate MCP client library for pi-mono.
+ */
+
+interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+interface McpToolCallResult {
+  content: Array<{ type: string; text?: string }>;
+  isError?: boolean;
+}
+
+export class McpHttpClient {
+  private sessionId: string | null = null;
+  private nextId = 1;
+
+  constructor(
+    private baseUrl: string,
+    private apiKey: string,
+    private agentId: string,
+    private taskId?: string,
+  ) {}
+
+  private async send(body: unknown): Promise<{ data: unknown; headers: Headers }> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${this.apiKey}`,
+      "X-Agent-ID": this.agentId,
+    };
+    if (this.taskId) {
+      headers["X-Source-Task-Id"] = this.taskId;
+    }
+    if (this.sessionId) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+
+    const res = await fetch(`${this.baseUrl}/mcp`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      throw new Error(`MCP request failed: ${res.status} ${res.statusText}`);
+    }
+
+    // Capture session ID from response
+    const sid = res.headers.get("mcp-session-id");
+    if (sid) this.sessionId = sid;
+
+    // Handle SSE responses (extract JSON from event stream)
+    const contentType = res.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
+      const text = await res.text();
+      const dataLines = text
+        .split("\n")
+        .filter((l) => l.startsWith("data: "))
+        .map((l) => l.slice(6));
+      const lastData = dataLines[dataLines.length - 1];
+      return { data: lastData ? JSON.parse(lastData) : null, headers: res.headers };
+    }
+
+    const data = await res.json();
+    return { data, headers: res.headers };
+  }
+
+  /** Perform MCP initialize + initialized handshake */
+  async initialize(): Promise<void> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "initialize",
+      params: {
+        protocolVersion: "2025-03-26",
+        capabilities: {},
+        clientInfo: { name: "agent-swarm-pi-mono", version: "1.0.0" },
+      },
+    });
+
+    if (!data || typeof data !== "object" || !("result" in (data as Record<string, unknown>))) {
+      throw new Error(`MCP initialize failed: ${JSON.stringify(data)}`);
+    }
+
+    // Send initialized notification (no response expected for notifications)
+    await this.send({
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+    });
+  }
+
+  /** Discover all available MCP tools */
+  async listTools(): Promise<McpTool[]> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "tools/list",
+      params: {},
+    });
+
+    const result = data as { result?: { tools?: McpTool[] } };
+    return result?.result?.tools ?? [];
+  }
+
+  /** Call an MCP tool */
+  async callTool(name: string, args: Record<string, unknown>): Promise<McpToolCallResult> {
+    const { data } = await this.send({
+      jsonrpc: "2.0",
+      id: this.nextId++,
+      method: "tools/call",
+      params: { name, arguments: args },
+    });
+
+    const result = data as { result?: McpToolCallResult };
+    return result?.result ?? { content: [{ type: "text", text: "No result" }] };
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,75 @@
+/** Data for session cost tracking. Shared across all provider adapters. */
+export interface CostData {
+  sessionId: string;
+  taskId?: string;
+  agentId: string;
+  totalCostUsd: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  durationMs: number;
+  numTurns: number;
+  model: string;
+  isError: boolean;
+}
+
+/** Normalized event emitted by any provider adapter. */
+export type ProviderEvent =
+  | { type: "session_init"; sessionId: string }
+  | { type: "message"; role: "assistant" | "user"; content: string }
+  | { type: "tool_start"; toolCallId: string; toolName: string; args: unknown }
+  | { type: "tool_end"; toolCallId: string; toolName: string; result: unknown }
+  | { type: "result"; cost: CostData; output?: string; isError: boolean; errorCategory?: string }
+  | { type: "error"; message: string; category?: string }
+  | { type: "raw_log"; content: string }
+  | { type: "raw_stderr"; content: string }
+  | { type: "custom"; name: string; data: unknown };
+
+/** Configuration passed to a provider adapter to create a session. */
+export interface ProviderSessionConfig {
+  prompt: string;
+  systemPrompt: string;
+  model: string;
+  role: string;
+  agentId: string;
+  taskId: string;
+  apiUrl: string;
+  apiKey: string;
+  cwd: string;
+  resumeSessionId?: string;
+  iteration?: number;
+  logFile: string;
+  /** Extra CLI args — used by Claude adapter, ignored by others. */
+  additionalArgs?: string[];
+  /** Resolved environment variables to pass to the spawned process. */
+  env?: Record<string, string>;
+}
+
+/** A running provider session. */
+export interface ProviderSession {
+  readonly sessionId: string | undefined;
+  onEvent(listener: (event: ProviderEvent) => void): void;
+  waitForCompletion(): Promise<ProviderResult>;
+  abort(): Promise<void>;
+}
+
+/** Result returned when a provider session completes. */
+export interface ProviderResult {
+  exitCode: number;
+  sessionId?: string;
+  cost?: CostData;
+  output?: string;
+  isError: boolean;
+  errorCategory?: string;
+  /** Human-readable failure reason built from error tracking. */
+  failureReason?: string;
+}
+
+/** Main contract for a harness provider adapter. */
+export interface ProviderAdapter {
+  readonly name: string;
+  createSession(config: ProviderSessionConfig): Promise<ProviderSession>;
+  canResume(sessionId: string): Promise<boolean>;
+  formatCommand(commandName: string): string;
+}

package/src/scheduler/scheduler.test.ts

@@ -107,6 +107,8 @@ describe("calculateNextRun", () => {
       priority: 50,
       enabled: true,
       timezone: "UTC",
+      consecutiveErrors: 0,
+      scheduleType: "recurring" as const,
       createdAt: new Date().toISOString(),
       lastUpdatedAt: new Date().toISOString(),
     } as Parameters<typeof calculateNextRun>[0];

package/src/scheduler/scheduler.ts

@@ -7,9 +7,86 @@ import {
   updateScheduledTask,
 } from "@/be/db";
 import type { ScheduledTask } from "@/types";
+import type { ExecutorRegistry } from "@/workflows/executors/registry";
+import { handleScheduleTrigger } from "@/workflows/triggers";
 
 let schedulerInterval: ReturnType<typeof setInterval> | null = null;
 let isProcessing = false;
+let executorRegistry: ExecutorRegistry | null = null;
+
+/**
+ * Recover missed scheduled task runs from downtime.
+ * Fires ONE catch-up run per schedule (not N missed runs).
+ * Tags the task with "recovered" so it's distinguishable.
+ */
+async function recoverMissedSchedules(): Promise<void> {
+  const now = new Date();
+  const dueSchedules = getDueScheduledTasks();
+
+  for (const schedule of dueSchedules) {
+    if (!schedule.nextRunAt) continue;
+    const missedBy = now.getTime() - new Date(schedule.nextRunAt).getTime();
+    if (missedBy < 15000) continue; // Less than 15s — normal timing jitter
+
+    console.log(
+      `[Scheduler] Recovering missed schedule "${schedule.name}" ` +
+        `(was due ${Math.round(missedBy / 1000)}s ago)`,
+    );
+
+    try {
+      // Check if any workflows are linked to this schedule
+      let triggeredWorkflows = false;
+      if (executorRegistry) {
+        const runIds = await handleScheduleTrigger(schedule.id, schedule, executorRegistry);
+        if (runIds.length > 0) {
+          triggeredWorkflows = true;
+          console.log(
+            `[Scheduler] Recovered schedule "${schedule.name}" → triggered ${runIds.length} workflow(s)`,
+          );
+        }
+      }
+
+      if (!triggeredWorkflows) {
+        const tx = getDb().transaction(() => {
+          createTaskExtended(schedule.taskTemplate, {
+            creatorAgentId: schedule.createdByAgentId,
+            taskType: schedule.taskType,
+            tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "recovered"],
+            priority: schedule.priority,
+            agentId: schedule.targetAgentId,
+            model: schedule.model,
+            scheduleId: schedule.id,
+            source: "schedule",
+          });
+        });
+        tx();
+      }
+
+      // Update schedule state regardless of workflow/task path
+      if (schedule.scheduleType === "one_time") {
+        updateScheduledTask(schedule.id, {
+          lastRunAt: now.toISOString(),
+          nextRunAt: null,
+          enabled: false,
+          lastUpdatedAt: now.toISOString(),
+        });
+      } else {
+        const nextRun = calculateNextRun(schedule, now);
+        updateScheduledTask(schedule.id, {
+          lastRunAt: now.toISOString(),
+          nextRunAt: nextRun,
+          lastUpdatedAt: now.toISOString(),
+        });
+      }
+
+      if (schedule.scheduleType === "one_time") {
+        console.log(`[Scheduler] One-time schedule "${schedule.name}" recovered and auto-disabled`);
+      }
+    } catch (err) {
+      console.error(`[Scheduler] Error recovering "${schedule.name}":`, err);
+    }
+  }
+}
 
 /**
  * Calculate next run time based on cron expression or interval.
@@ -38,52 +115,141 @@ export function calculateNextRun(schedule: ScheduledTask, fromTime: Date = new D
   throw new Error("Schedule must have cronExpression or intervalMs");
 }
 
+// Exponential backoff schedule for consecutive errors (in ms)
+const ERROR_BACKOFF_MS = [
+  60_000, // 1 minute
+  300_000, // 5 minutes
+  900_000, // 15 minutes
+  1_800_000, // 30 minutes
+  3_600_000, // 1 hour (cap)
+];
+
+const MAX_CONSECUTIVE_ERRORS = 5;
+
+function getBackoffMs(consecutiveErrors: number): number {
+  const idx = Math.min(consecutiveErrors - 1, ERROR_BACKOFF_MS.length - 1);
+  return ERROR_BACKOFF_MS[Math.max(0, idx)] ?? ERROR_BACKOFF_MS[0]!;
+}
+
 /**
  * Execute a single scheduled task by creating an agent task.
+ * Tracks consecutive errors and applies exponential backoff on failure.
  */
 async function executeSchedule(schedule: ScheduledTask): Promise<void> {
-  // Wrap in transaction to ensure atomicity of task creation and schedule update
-  const tx = getDb().transaction(() => {
+  try {
+    // Check if any workflows are linked to this schedule
+    let triggeredWorkflows = false;
+    if (executorRegistry) {
+      const runIds = await handleScheduleTrigger(schedule.id, schedule, executorRegistry);
+      if (runIds.length > 0) {
+        triggeredWorkflows = true;
+        console.log(
+          `[Scheduler] Schedule "${schedule.name}" → triggered ${runIds.length} workflow(s)`,
+        );
+      }
+    }
+
+    if (!triggeredWorkflows) {
+      // No workflows linked — create standalone task (existing behavior)
+      getDb().transaction(() => {
+        createTaskExtended(schedule.taskTemplate, {
+          creatorAgentId: schedule.createdByAgentId,
+          taskType: schedule.taskType,
+          tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`],
+          priority: schedule.priority,
+          agentId: schedule.targetAgentId,
+          model: schedule.model,
+          scheduleId: schedule.id,
+          source: "schedule",
+        });
+      })();
+    }
+
+    // Update schedule state regardless of workflow/task path
     const now = new Date().toISOString();
+    if (schedule.scheduleType === "one_time") {
+      updateScheduledTask(schedule.id, {
+        lastRunAt: now,
+        nextRunAt: null,
+        enabled: false,
+        lastUpdatedAt: now,
+        consecutiveErrors: 0,
+        lastErrorAt: null,
+        lastErrorMessage: null,
+      });
+      console.log(`[Scheduler] Executed one-time schedule "${schedule.name}", auto-disabled`);
+    } else {
+      const nextRun = calculateNextRun(schedule, new Date());
+      updateScheduledTask(schedule.id, {
+        lastRunAt: now,
+        nextRunAt: nextRun,
+        lastUpdatedAt: now,
+        consecutiveErrors: 0,
+        lastErrorAt: null,
+        lastErrorMessage: null,
+      });
+      console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
+    }
+  } catch (err) {
+    const errorCount = (schedule.consecutiveErrors ?? 0) + 1;
+    const now = new Date();
+    const errorMsg = err instanceof Error ? err.message : String(err);
 
-    // Create the actual task
-    createTaskExtended(schedule.taskTemplate, {
-      creatorAgentId: schedule.createdByAgentId,
-      taskType: schedule.taskType,
-      tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`],
-      priority: schedule.priority,
-      agentId: schedule.targetAgentId, // null goes to pool
-    });
+    console.error(
+      `[Scheduler] Error executing "${schedule.name}" (${errorCount} consecutive):`,
+      errorMsg,
+    );
 
-    // Update lastRunAt and nextRunAt
-    const nextRun = calculateNextRun(schedule, new Date());
-    updateScheduledTask(schedule.id, {
-      lastRunAt: now,
-      nextRunAt: nextRun,
-      lastUpdatedAt: now,
-    });
+    const updates: {
+      consecutiveErrors: number;
+      lastErrorAt: string;
+      lastErrorMessage: string;
+      lastUpdatedAt: string;
+      enabled?: boolean;
+      nextRunAt?: string;
+    } = {
+      consecutiveErrors: errorCount,
+      lastErrorAt: now.toISOString(),
+      lastErrorMessage: errorMsg.slice(0, 500),
+      lastUpdatedAt: now.toISOString(),
+    };
 
-    return nextRun;
-  });
+    if (schedule.scheduleType === "one_time") {
+      updates.enabled = false;
+      console.warn(
+        `[Scheduler] One-time schedule "${schedule.name}" failed, auto-disabled: ${errorMsg}`,
+      );
+    } else if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
+      updates.enabled = false;
+      console.warn(
+        `[Scheduler] Auto-disabled "${schedule.name}" after ${errorCount} consecutive errors`,
+      );
+    } else {
+      const backoff = getBackoffMs(errorCount);
+      updates.nextRunAt = new Date(now.getTime() + backoff).toISOString();
+      console.log(`[Scheduler] Backing off "${schedule.name}" for ${backoff / 1000}s`);
+    }
 
-  const nextRun = tx();
-  console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
+    updateScheduledTask(schedule.id, updates);
+  }
 }
 
 /**
  * Start the scheduler polling loop.
+ * @param registry ExecutorRegistry for triggering workflows linked to schedules
  * @param intervalMs Polling interval in milliseconds (default: 10000)
  */
-export function startScheduler(intervalMs = 10000): void {
+export function startScheduler(registry: ExecutorRegistry, intervalMs = 10000): void {
   if (schedulerInterval) {
     console.log("[Scheduler] Already running");
     return;
   }
 
+  executorRegistry = registry;
   console.log(`[Scheduler] Starting with ${intervalMs}ms polling interval`);
 
-  // Run immediately once, then start interval
-  void processSchedules();
+  // Recover missed schedules from downtime, then run normal processing
+  void recoverMissedSchedules().then(() => processSchedules());
 
   schedulerInterval = setInterval(async () => {
     await processSchedules();
@@ -138,27 +304,52 @@ export async function runScheduleNow(scheduleId: string): Promise<void> {
     throw new Error(`Schedule is disabled: ${schedule.name}`);
   }
 
-  // Wrap in transaction to ensure atomicity of task creation and schedule update
-  const tx = getDb().transaction(() => {
-    const now = new Date().toISOString();
+  // Check if any workflows are linked to this schedule
+  let triggeredWorkflows = false;
+  if (executorRegistry) {
+    const runIds = await handleScheduleTrigger(scheduleId, schedule, executorRegistry);
+    if (runIds.length > 0) {
+      triggeredWorkflows = true;
+      console.log(
+        `[Scheduler] Manual run of "${schedule.name}" → triggered ${runIds.length} workflow(s)`,
+      );
+    }
+  }
 
-    // Create the actual task
-    createTaskExtended(schedule.taskTemplate, {
-      creatorAgentId: schedule.createdByAgentId,
-      taskType: schedule.taskType,
-      tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
-      priority: schedule.priority,
-      agentId: schedule.targetAgentId,
-    });
+  if (!triggeredWorkflows) {
+    // No workflows linked — create standalone task (existing behavior)
+    getDb().transaction(() => {
+      createTaskExtended(schedule.taskTemplate, {
+        creatorAgentId: schedule.createdByAgentId,
+        taskType: schedule.taskType,
+        tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
+        priority: schedule.priority,
+        agentId: schedule.targetAgentId,
+        model: schedule.model,
+        scheduleId: schedule.id,
+        source: "schedule",
+      });
+    })();
+  }
 
+  // Update schedule state
+  const now = new Date().toISOString();
+  if (schedule.scheduleType === "one_time") {
+    updateScheduledTask(schedule.id, {
+      lastRunAt: now,
+      nextRunAt: null,
+      enabled: false,
+      lastUpdatedAt: now,
+    });
+    console.log(
+      `[Scheduler] Manually executed one-time schedule "${schedule.name}", auto-disabled`,
+    );
+  } else {
     // Only update lastRunAt, not nextRunAt (to not affect regular schedule)
     updateScheduledTask(schedule.id, {
       lastRunAt: now,
       lastUpdatedAt: now,
     });
-  });
-
-  tx();
-
-  console.log(`[Scheduler] Manually executed schedule "${schedule.name}"`);
+    console.log(`[Scheduler] Manually executed schedule "${schedule.name}"`);
+  }
 }