@vellumai/assistant 0.5.6 → 0.5.8

package/src/swarm/backend-claude-code.ts

@@ -1,225 +0,0 @@
-/**
- * Claude Code worker backend for swarm execution.
- *
- * Extracted from the swarm delegate tool so backend construction
- * is testable and swappable independently of the tool adapter.
- */
-
-import { resolveModelIntent } from "../providers/model-intents.js";
-import type { ModelIntent } from "../providers/types.js";
-import { getProviderKeyAsync } from "../security/secure-keys.js";
-import { getLogger } from "../util/logger.js";
-import type {
-  SwarmWorkerBackend,
-  SwarmWorkerBackendInput,
-} from "./worker-backend.js";
-import { getProfilePolicy } from "./worker-backend.js";
-
-const log = getLogger("swarm-backend-claude-code");
-
-const MAX_CLAUDE_CODE_DEPTH = 1;
-const DEPTH_ENV_VAR = "VELLUM_CLAUDE_CODE_DEPTH";
-
-/**
- * Create a Claude Code worker backend that enforces profile-based tool policies.
- * Uses the Claude Agent SDK to run autonomous worker tasks.
- */
-export function createClaudeCodeBackend(): SwarmWorkerBackend {
-  return {
-    name: "claude_code",
-
-    async isAvailable(): Promise<boolean> {
-      const apiKey = await getProviderKeyAsync("anthropic");
-      return !!apiKey;
-    },
-
-    async runTask(input: SwarmWorkerBackendInput) {
-      const start = Date.now();
-      const stderrLines: string[] = [];
-      try {
-        const { query } = await import("@anthropic-ai/claude-agent-sdk");
-        const apiKey = await getProviderKeyAsync("anthropic");
-        if (!apiKey) {
-          return {
-            success: false,
-            output: "No API key",
-            failureReason: "backend_unavailable" as const,
-            durationMs: 0,
-          };
-        }
-
-        const profilePolicy = getProfilePolicy(input.profile);
-
-        // Enforce profile restrictions — swarm workers run autonomously so
-        // there is no user to prompt; denied tools are blocked, everything
-        // else is allowed.
-        const canUseTool: import("@anthropic-ai/claude-agent-sdk").CanUseTool =
-          async (toolName) => {
-            if (profilePolicy.deny.has(toolName)) {
-              log.debug(
-                { toolName, profile: input.profile },
-                "Swarm worker tool denied by profile",
-              );
-              return {
-                behavior: "deny" as const,
-                message: `Tool "${toolName}" is denied by profile "${input.profile}"`,
-              };
-            }
-            return { behavior: "allow" as const };
-          };
-
-        // Enforce nesting depth limit
-        const currentDepth = parseInt(process.env[DEPTH_ENV_VAR] ?? "0", 10);
-        if (currentDepth >= MAX_CLAUDE_CODE_DEPTH) {
-          log.warn(
-            { currentDepth, max: MAX_CLAUDE_CODE_DEPTH },
-            "Swarm worker nesting depth exceeded",
-          );
-          return {
-            success: false,
-            output: `Nesting depth exceeded (depth ${currentDepth}, max ${MAX_CLAUDE_CODE_DEPTH})`,
-            failureReason: "backend_unavailable" as const,
-            durationMs: Date.now() - start,
-          };
-        }
-
-        // Strip the SDK's nesting guard but set our own depth counter.
-        const subprocessEnv: Record<string, string | undefined> = {
-          ...process.env,
-          ANTHROPIC_API_KEY: apiKey,
-          [DEPTH_ENV_VAR]: String(currentDepth + 1),
-        };
-        delete subprocessEnv.CLAUDECODE;
-        delete subprocessEnv.CLAUDE_CODE_ENTRYPOINT;
-
-        const conversation = query({
-          prompt: input.prompt,
-          options: {
-            cwd: input.workingDir,
-            model: input.modelIntent
-              ? resolveModelIntent(
-                  "anthropic",
-                  input.modelIntent as ModelIntent,
-                )
-              : "claude-sonnet-4-6",
-            canUseTool,
-            permissionMode: "default",
-            maxTurns: 30,
-            env: subprocessEnv,
-            stderr: (data: string) => {
-              const trimmed = data.trimEnd();
-              if (trimmed) {
-                stderrLines.push(trimmed);
-                log.debug(
-                  { stderr: trimmed },
-                  "Swarm worker subprocess stderr",
-                );
-              }
-            },
-          },
-        });
-
-        let resultText = "";
-        let hasError = false;
-        for await (const message of conversation) {
-          if (input.signal?.aborted) break;
-          if (message.type === "assistant") {
-            if (message.error) {
-              log.error(
-                { error: message.error, conversationId: message.session_id },
-                "Swarm worker assistant message error",
-              );
-              hasError = true;
-              resultText += `\n[Claude Code error: ${message.error}]`;
-            }
-            if (message.message?.content) {
-              for (const block of message.message.content) {
-                if (block.type === "text") resultText += block.text;
-              }
-            }
-          } else if (message.type === "result") {
-            if (message.subtype === "success") {
-              log.info(
-                {
-                  numTurns: message.num_turns,
-                  durationMs: message.duration_ms,
-                  costUsd: message.total_cost_usd,
-                },
-                "Swarm worker completed",
-              );
-              if (message.result && !resultText) {
-                resultText = message.result;
-              }
-            } else {
-              hasError = true;
-              const errors = message.errors ?? [];
-              const denials = message.permission_denials ?? [];
-              log.error(
-                {
-                  subtype: message.subtype,
-                  errors,
-                  permissionDenials: denials.length,
-                  numTurns: message.num_turns,
-                  durationMs: message.duration_ms,
-                },
-                "Swarm worker session failed",
-              );
-
-              const parts: string[] = [
-                `[${message.subtype}] (${message.num_turns} turns, ${(
-                  message.duration_ms / 1000
-                ).toFixed(1)}s)`,
-              ];
-              if (errors.length > 0) parts.push(`Errors: ${errors.join("; ")}`);
-              if (denials.length > 0)
-                parts.push(
-                  `Permission denied: ${denials
-                    .map((d: { tool_name: string }) => d.tool_name)
-                    .join(", ")}`,
-                );
-              resultText += `\n${parts.join("\n")}`;
-            }
-          }
-        }
-
-        // Treat abort as non-retryable cancellation, not a retryable timeout
-        if (input.signal?.aborted) {
-          return {
-            success: false,
-            output: "Cancelled (aborted)",
-            failureReason: "cancelled" as const,
-            durationMs: Date.now() - start,
-          };
-        }
-
-        return {
-          success: !hasError,
-          output: resultText || "Completed",
-          durationMs: Date.now() - start,
-        };
-      } catch (err) {
-        const errMessage = err instanceof Error ? err.message : String(err);
-        const recentStderr = stderrLines.slice(-20);
-        log.error(
-          { err, stderrTail: recentStderr },
-          "Swarm worker execution failed",
-        );
-
-        const parts = [errMessage];
-        if (recentStderr.length > 0) {
-          parts.push(
-            `\nSubprocess stderr (last ${
-              recentStderr.length
-            } lines):\n${recentStderr.join("\n")}`,
-          );
-        }
-        return {
-          success: false,
-          output: parts.join(""),
-          failureReason: "backend_unavailable" as const,
-          durationMs: Date.now() - start,
-        };
-      }
-    },
-  };
-}

package/src/swarm/checkpoint.ts

@@ -1,137 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-import { getLogger } from "../util/logger.js";
-import { getRootDir } from "../util/platform.js";
-import type { SwarmPlan, SwarmTaskResult } from "./types.js";
-
-const log = getLogger("swarm-checkpoint");
-
-/** Only allow safe token characters in runId (alphanumeric, hyphens, underscores, dots). */
-const SAFE_RUN_ID = /^[a-zA-Z0-9._-]+$/;
-
-function assertSafeRunId(runId: string): void {
-  if (!SAFE_RUN_ID.test(runId)) {
-    throw new Error(
-      `Invalid runId: must match ${SAFE_RUN_ID} (got "${runId}")`,
-    );
-  }
-}
-
-export interface SwarmCheckpoint {
-  runId: string;
-  objective: string;
-  /** Serialized plan for integrity verification on resume. */
-  planTaskIds: string[];
-  /** Stringified task dependency map for structural integrity on resume. */
-  planHash: string;
-  results: SwarmTaskResult[];
-  /** Set of task IDs whose dependents were blocked due to failure. */
-  blockedTaskIds: string[];
-  updatedAt: string;
-}
-
-function getCheckpointDir(): string {
-  return join(getRootDir(), "swarm-checkpoints");
-}
-
-function getCheckpointPath(runId: string): string {
-  assertSafeRunId(runId);
-  return join(getCheckpointDir(), `${runId}.json`);
-}
-
-/**
- * Deterministic fingerprint of a plan's structure: objective, task IDs,
- * roles, and dependency edges. Two plans with the same hash are structurally
- * identical and safe to resume from.
- */
-function computePlanHash(plan: SwarmPlan): string {
-  const parts = plan.tasks.map(
-    (t) => `${t.id}:${t.role}:${[...t.dependencies].sort().join(",")}`,
-  );
-  return `${plan.objective}|${parts.sort().join("|")}`;
-}
-
-/** Persist the current swarm progress to disk. */
-export function writeCheckpoint(
-  runId: string,
-  plan: SwarmPlan,
-  results: Map<string, SwarmTaskResult>,
-  blockedTaskIds: Set<string>,
-): void {
-  try {
-    const path = getCheckpointPath(runId);
-    const checkpoint: SwarmCheckpoint = {
-      runId,
-      objective: plan.objective,
-      planTaskIds: plan.tasks.map((t) => t.id),
-      planHash: computePlanHash(plan),
-      results: Array.from(results.values()),
-      blockedTaskIds: Array.from(blockedTaskIds),
-      updatedAt: new Date().toISOString(),
-    };
-
-    mkdirSync(dirname(path), { recursive: true });
-    // Atomic-ish write: write to temp then rename to avoid partial reads
-    const tmpPath = path + ".tmp";
-    writeFileSync(tmpPath, JSON.stringify(checkpoint, null, 2) + "\n");
-    renameSync(tmpPath, path);
-  } catch (err) {
-    // Checkpoint failures should not crash the orchestrator
-    log.warn(
-      { runId, error: (err as Error).message },
-      "Failed to write checkpoint",
-    );
-  }
-}
-
-/** Load a checkpoint from disk, or null if none exists. */
-export function loadCheckpoint(runId: string): SwarmCheckpoint | null {
-  const path = getCheckpointPath(runId);
-  if (!existsSync(path)) return null;
-
-  try {
-    const data = readFileSync(path, "utf-8");
-    return JSON.parse(data) as SwarmCheckpoint;
-  } catch (err) {
-    log.warn(
-      { runId, error: (err as Error).message },
-      "Failed to read checkpoint, starting fresh",
-    );
-    return null;
-  }
-}
-
-/** Remove a checkpoint file after successful completion. */
-export function removeCheckpoint(runId: string): void {
-  const path = getCheckpointPath(runId);
-  try {
-    if (existsSync(path)) unlinkSync(path);
-  } catch {
-    // Best-effort cleanup
-  }
-}
-
-/**
- * Validate that a checkpoint matches the current plan.
- * Compares objective, task IDs, roles, and dependency structure via planHash.
- * Falls back to subset check for checkpoints written before planHash existed.
- */
-export function isCheckpointCompatible(
-  checkpoint: SwarmCheckpoint,
-  plan: SwarmPlan,
-): boolean {
-  if (checkpoint.planHash) {
-    return checkpoint.planHash === computePlanHash(plan);
-  }
-  // Legacy checkpoint without planHash — fall back to subset check
-  const planTaskIds = new Set(plan.tasks.map((t) => t.id));
-  return checkpoint.planTaskIds.every((id) => planTaskIds.has(id));
-}

package/src/swarm/graph-utils.ts

@@ -1,53 +0,0 @@
-/**
- * Shared graph utilities for swarm DAG operations.
- */
-
-export interface GraphNode {
-  id: string;
-  dependencies: string[];
-}
-
-/**
- * Detect cycles in a directed graph using Kahn's algorithm.
- * Returns the IDs of nodes involved in cycles, or null if the graph is acyclic.
- */
-export function detectCycles(nodes: GraphNode[]): string[] | null {
-  const inDegree = new Map<string, number>();
-  const adj = new Map<string, string[]>();
-
-  for (const node of nodes) {
-    inDegree.set(node.id, 0);
-    adj.set(node.id, []);
-  }
-
-  for (const node of nodes) {
-    for (const dep of node.dependencies) {
-      if (adj.has(dep)) {
-        adj.get(dep)!.push(node.id);
-        inDegree.set(node.id, (inDegree.get(node.id) ?? 0) + 1);
-      }
-    }
-  }
-
-  const queue: string[] = [];
-  for (const [id, deg] of inDegree) {
-    if (deg === 0) queue.push(id);
-  }
-
-  let processed = 0;
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    processed++;
-    for (const neighbor of adj.get(current)!) {
-      const newDeg = (inDegree.get(neighbor) ?? 0) - 1;
-      inDegree.set(neighbor, newDeg);
-      if (newDeg === 0) queue.push(neighbor);
-    }
-  }
-
-  if (processed < nodes.length) {
-    return nodes.filter((n) => (inDegree.get(n.id) ?? 0) > 0).map((n) => n.id);
-  }
-
-  return null;
-}

package/src/swarm/index.ts

@@ -1,55 +0,0 @@
-export type { SwarmCheckpoint } from "./checkpoint.js";
-export {
-  isCheckpointCompatible,
-  loadCheckpoint,
-  removeCheckpoint,
-  writeCheckpoint,
-} from "./checkpoint.js";
-export type { SwarmLimits } from "./limits.js";
-export {
-  getTimeoutForRole,
-  resolveSwarmLimits,
-  SWARM_HARD_LIMITS,
-} from "./limits.js";
-export type {
-  ExecuteSwarmOptions,
-  OrchestratorEvent,
-  OrchestratorEventKind,
-  OrchestratorStatusCallback,
-} from "./orchestrator.js";
-export { executeSwarm } from "./orchestrator.js";
-export {
-  SwarmPlanValidationError,
-  validateAndNormalizePlan,
-} from "./plan-validator.js";
-export {
-  generatePlan,
-  makeFallbackPlan,
-  parsePlanJSON,
-} from "./router-planner.js";
-export { synthesizeResults } from "./synthesizer.js";
-export type {
-  SwarmExecutionSummary,
-  SwarmPlan,
-  SwarmRole,
-  SwarmTaskNode,
-  SwarmTaskResult,
-  SwarmTaskStatus,
-} from "./types.js";
-export { VALID_SWARM_ROLES } from "./types.js";
-export type {
-  ProfilePolicy,
-  SwarmWorkerBackend,
-  SwarmWorkerBackendInput,
-  SwarmWorkerBackendResult,
-  WorkerFailureReason,
-  WorkerProfile,
-} from "./worker-backend.js";
-export { getProfilePolicy, roleToProfile } from "./worker-backend.js";
-export { buildWorkerPrompt, parseWorkerOutput } from "./worker-prompts.js";
-export type {
-  RunWorkerTaskOptions,
-  WorkerStatusCallback,
-  WorkerStatusKind,
-} from "./worker-runner.js";
-export { runWorkerTask } from "./worker-runner.js";

package/src/swarm/limits.ts

@@ -1,66 +0,0 @@
-/**
- * Runtime limits for swarm execution, resolved from config.
- */
-
-import type { SwarmRole } from "./types.js";
-
-export interface SwarmLimits {
-  maxWorkers: number;
-  maxTasks: number;
-  maxRetriesPerTask: number;
-  workerTimeoutSec: number;
-  /** Per-role timeout overrides. When set, takes precedence over workerTimeoutSec for that role. */
-  roleTimeoutsSec: Partial<Record<SwarmRole, number>>;
-}
-
-/** Hard ceilings that config values are clamped to. */
-export const SWARM_HARD_LIMITS = {
-  maxWorkers: 6,
-  maxTasks: 20,
-  maxRetriesPerTask: 3,
-} as const;
-
-/**
- * Resolve effective limits from config, clamping to hard ceilings.
- */
-export function resolveSwarmLimits(config: {
-  maxWorkers: number;
-  maxTasks: number;
-  maxRetriesPerTask: number;
-  workerTimeoutSec: number;
-  roleTimeoutsSec?: Partial<Record<SwarmRole, number>>;
-}): SwarmLimits {
-  const resolvedRoleTimeouts: Partial<Record<SwarmRole, number>> = {};
-  if (config.roleTimeoutsSec) {
-    for (const [role, timeout] of Object.entries(config.roleTimeoutsSec)) {
-      if (timeout != null) {
-        resolvedRoleTimeouts[role as SwarmRole] = Math.max(1, timeout);
-      }
-    }
-  }
-
-  return {
-    maxWorkers: Math.min(
-      Math.max(1, config.maxWorkers),
-      SWARM_HARD_LIMITS.maxWorkers,
-    ),
-    maxTasks: Math.min(
-      Math.max(1, config.maxTasks),
-      SWARM_HARD_LIMITS.maxTasks,
-    ),
-    maxRetriesPerTask: Math.min(
-      Math.max(0, config.maxRetriesPerTask),
-      SWARM_HARD_LIMITS.maxRetriesPerTask,
-    ),
-    workerTimeoutSec: Math.max(1, config.workerTimeoutSec),
-    roleTimeoutsSec: resolvedRoleTimeouts,
-  };
-}
-
-/** Get the effective timeout for a given role, falling back to the global workerTimeoutSec. */
-export function getTimeoutForRole(
-  limits: SwarmLimits,
-  role: SwarmRole,
-): number {
-  return limits.roleTimeoutsSec[role] ?? limits.workerTimeoutSec;
-}