wave-agent-sdk 1.0.4 → 1.0.6

package/src/workflow/budgetTracker.ts

@@ -1,34 +0,0 @@
-export class BudgetTracker {
-  private totalSpent = 0;
-
-  constructor(private _total: number | null = null) {}
-
-  addUsage(tokens: number): void {
-    this.totalSpent += tokens;
-  }
-
-  spent(): number {
-    return this.totalSpent;
-  }
-
-  remaining(): number {
-    if (this._total === null) return Infinity;
-    return Math.max(0, this._total - this.totalSpent);
-  }
-
-  isExceeded(): boolean {
-    return this._total !== null && this.totalSpent >= this._total;
-  }
-
-  get total(): number | null {
-    return this._total;
-  }
-
-  toBudgetInfo(): import("./types.js").BudgetInfo {
-    return {
-      total: this._total,
-      spent: () => this.totalSpent,
-      remaining: () => this.remaining(),
-    };
-  }
-}

package/src/workflow/concurrencyLimiter.ts

@@ -1,47 +0,0 @@
-export class ConcurrencyLimiter {
-  private running = 0;
-  private queue: Array<() => void> = [];
-  private readonly maxConcurrency: number;
-  private activeSet = new Set<Promise<unknown>>();
-
-  constructor(maxConcurrency: number) {
-    this.maxConcurrency = Math.max(1, maxConcurrency);
-  }
-
-  async acquire(): Promise<void> {
-    if (this.running < this.maxConcurrency) {
-      this.running++;
-      return;
-    }
-    return new Promise<void>((resolve) => {
-      this.queue.push(resolve);
-    });
-  }
-
-  release(): void {
-    this.running--;
-    if (this.queue.length > 0) {
-      this.running++;
-      const next = this.queue.shift()!;
-      next();
-    }
-  }
-
-  track<T>(promise: Promise<T>): Promise<T> {
-    this.activeSet.add(promise);
-    promise.finally(() => this.activeSet.delete(promise));
-    return promise;
-  }
-
-  async drain(): Promise<void> {
-    await Promise.allSettled(this.activeSet);
-  }
-
-  get activeCount(): number {
-    return this.running;
-  }
-
-  get pendingCount(): number {
-    return this.queue.length;
-  }
-}

package/src/workflow/journal.ts

@@ -1,95 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import type { JournalLine } from "./types.js";
-
-export class Journal {
-  private entries: JournalLine[] = [];
-  private stream: fs.WriteStream | null = null;
-
-  constructor(public readonly filePath: string) {}
-
-  async init(): Promise<void> {
-    // Ensure directory exists
-    await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });
-    // Create append-only write stream
-    this.stream = fs.createWriteStream(this.filePath, { flags: "a" });
-  }
-
-  append(entry: JournalLine): void {
-    this.entries.push(entry);
-    if (this.stream && !this.stream.destroyed && !this.stream.writableEnded) {
-      this.stream.write(JSON.stringify(entry) + "\n");
-    }
-  }
-
-  appendLog(message: string): void {
-    this.append({ type: "log", message });
-  }
-
-  getCachedResult(agentIndex: number): unknown | undefined {
-    const agentEntries = this.entries.filter(
-      (e): e is import("./types.js").JournalEntry => !("type" in e),
-    );
-    // Check if this agent was marked as failed
-    const failedEntry = this.entries.find(
-      (e): e is import("./types.js").AgentFailedEntry =>
-        "type" in e && e.type === "agent_failed" && e.agentIndex === agentIndex,
-    );
-    if (failedEntry) {
-      return undefined; // Failed agents don't have cached results
-    }
-    if (agentIndex < agentEntries.length) {
-      return agentEntries[agentIndex].result;
-    }
-    return undefined;
-  }
-
-  get length(): number {
-    return this.entries.length;
-  }
-
-  /** Count of agent entries (excluding log entries) */
-  get agentEntryCount(): number {
-    return this.entries.filter(
-      (e): e is import("./types.js").JournalEntry => !("type" in e),
-    ).length;
-  }
-
-  /** Remove the agent_failed entry for a given agent index (for retry support) */
-  removeFailedEntry(agentIndex: number): void {
-    this.entries = this.entries.filter(
-      (e) =>
-        !(
-          "type" in e &&
-          e.type === "agent_failed" &&
-          e.agentIndex === agentIndex
-        ),
-    );
-  }
-
-  async close(): Promise<void> {
-    const s = this.stream;
-    this.stream = null;
-    if (s) {
-      await new Promise<void>((resolve) => {
-        s.end(() => resolve());
-      });
-    }
-  }
-
-  static async load(filePath: string): Promise<Journal> {
-    const journal = new Journal(filePath);
-    try {
-      const content = await fs.promises.readFile(filePath, "utf-8");
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed) {
-          journal.entries.push(JSON.parse(trimmed));
-        }
-      }
-    } catch {
-      // File doesn't exist yet — empty journal
-    }
-    return journal;
-  }
-}

package/src/workflow/progressReporter.ts

@@ -1,141 +0,0 @@
-import type {
-  WorkflowPhaseState,
-  WorkflowMeta,
-  WorkflowProgressEvent,
-} from "./types.js";
-
-export class ProgressReporter {
-  private phases: WorkflowPhaseState[] = [];
-  private currentPhaseIndex = -1;
-  private agentCounter = 0;
-  private listeners: Array<(event: WorkflowProgressEvent) => void> = [];
-  private runId: string;
-
-  constructor(
-    private meta: WorkflowMeta,
-    runId?: string,
-  ) {
-    this.runId = runId || "";
-    // Pre-initialize phases from meta so they appear even if the script
-    // doesn't call phase() explicitly
-    if (meta.phases?.length) {
-      for (const p of meta.phases) {
-        this.phases.push({
-          title: p.title,
-          agentCount: 0,
-          tokens: 0,
-          elapsed: 0,
-          startTime: Date.now(),
-        });
-      }
-      // Default to the first phase so agentStarted/agentCompleted
-      // track into it even without an explicit phase() call
-      this.currentPhaseIndex = 0;
-    }
-  }
-
-  setPhase(title: string): void {
-    // Emit phase_completed for the previous phase
-    if (this.currentPhaseIndex >= 0) {
-      this.emit({
-        type: "phase_completed",
-        phaseIndex: this.currentPhaseIndex,
-      });
-    }
-
-    const existing = this.phases.findIndex((p) => p.title === title);
-    if (existing >= 0) {
-      this.currentPhaseIndex = existing;
-    } else {
-      this.phases.push({
-        title,
-        agentCount: 0,
-        tokens: 0,
-        elapsed: 0,
-        startTime: Date.now(),
-      });
-      this.currentPhaseIndex = this.phases.length - 1;
-    }
-
-    this.emit({
-      type: "phase_started",
-      phaseIndex: this.currentPhaseIndex,
-    });
-  }
-
-  agentStarted(): void {
-    this.agentCounter++;
-    if (this.currentPhaseIndex >= 0) {
-      this.phases[this.currentPhaseIndex].agentCount++;
-    }
-    this.emit({
-      type: "agent_started",
-      phaseIndex: this.currentPhaseIndex,
-      agentIndex: this.agentCounter - 1,
-    });
-  }
-
-  agentCompleted(tokens: number): void {
-    if (this.currentPhaseIndex >= 0) {
-      this.phases[this.currentPhaseIndex].tokens += tokens;
-      this.phases[this.currentPhaseIndex].elapsed =
-        Date.now() - this.phases[this.currentPhaseIndex].startTime;
-    }
-    this.emit({
-      type: "agent_completed",
-      phaseIndex: this.currentPhaseIndex,
-      agentIndex: this.agentCounter - 1,
-    });
-  }
-
-  agentFailed(agentIndex: number): void {
-    this.emit({
-      type: "agent_failed",
-      phaseIndex: this.currentPhaseIndex,
-      agentIndex,
-    });
-  }
-
-  formatSummary(): string {
-    const phaseInfo =
-      this.currentPhaseIndex >= 0
-        ? `Phase ${this.currentPhaseIndex + 1}/${this.phases.length}: ${this.phases[this.currentPhaseIndex].title}`
-        : "Initializing";
-    const totalTokens = this.phases.reduce((sum, p) => sum + p.tokens, 0);
-    const elapsed = this.phases.reduce((sum, p) => sum + p.elapsed, 0);
-    return `${phaseInfo} | ${this.agentCounter} agents | ${(totalTokens / 1000).toFixed(1)}k tokens | ${Math.round(elapsed / 1000)}s`;
-  }
-
-  getPhaseStates(): WorkflowPhaseState[] {
-    return [...this.phases];
-  }
-
-  get totalAgents(): number {
-    return this.agentCounter;
-  }
-
-  get totalTokens(): number {
-    return this.phases.reduce((sum, p) => sum + p.tokens, 0);
-  }
-
-  onEvent(listener: (event: WorkflowProgressEvent) => void): void {
-    this.listeners.push(listener);
-  }
-
-  private emit(
-    event: Omit<WorkflowProgressEvent, "runId" | "timestamp">,
-  ): void {
-    const fullEvent: WorkflowProgressEvent = {
-      ...event,
-      runId: this.runId,
-      timestamp: Date.now(),
-    };
-    for (const listener of this.listeners) {
-      try {
-        listener(fullEvent);
-      } catch {
-        // Swallow listener errors
-      }
-    }
-  }
-}

package/src/workflow/runState.ts

@@ -1,65 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import type { WorkflowRun } from "./types.js";
-
-/**
- * Persists WorkflowRun state to <runDir>/run-state.json.
- * Enables run recovery across process restarts.
- */
-export class RunStateStore {
-  constructor(private baseDir: string) {}
-
-  /** Persist a run's state to disk */
-  async save(run: WorkflowRun): Promise<void> {
-    const runDir = path.join(this.baseDir, run.runId);
-    await fs.promises.mkdir(runDir, { recursive: true });
-    const statePath = path.join(runDir, "run-state.json");
-    // Omit non-serializable fields
-    const { completionPromise, ...serializable } = run;
-    void completionPromise;
-    await fs.promises.writeFile(
-      statePath,
-      JSON.stringify(serializable, null, 2),
-      "utf-8",
-    );
-  }
-
-  /** Load a single run's state from disk */
-  async load(runId: string): Promise<WorkflowRun | null> {
-    const statePath = path.join(this.baseDir, runId, "run-state.json");
-    try {
-      const content = await fs.promises.readFile(statePath, "utf-8");
-      return JSON.parse(content) as WorkflowRun;
-    } catch {
-      return null;
-    }
-  }
-
-  /** List all persisted run IDs */
-  async listRuns(): Promise<string[]> {
-    try {
-      const entries = await fs.promises.readdir(this.baseDir, {
-        withFileTypes: true,
-      });
-      const runIds: string[] = [];
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith("wf_")) {
-          const statePath = path.join(
-            this.baseDir,
-            entry.name,
-            "run-state.json",
-          );
-          try {
-            await fs.promises.access(statePath);
-            runIds.push(entry.name);
-          } catch {
-            // Directory exists but no run-state.json — skip
-          }
-        }
-      }
-      return runIds;
-    } catch {
-      return [];
-    }
-  }
-}

package/src/workflow/scriptRuntime.ts

@@ -1,274 +0,0 @@
-import type { WorkflowMeta } from "./types.js";
-import { logger } from "../utils/globalLogger.js";
-
-/** Patterns that are banned in workflow scripts for safety and determinism */
-const BANNED_PATTERNS = [
-  {
-    pattern: /\brequire\s*\(/,
-    message: "require() is not available in workflow scripts",
-  },
-  {
-    pattern: /\bprocess\./,
-    message: "process.* is not available in workflow scripts",
-  },
-  {
-    pattern: /\beval\s*\(/,
-    message: "eval() is not available in workflow scripts",
-  },
-  {
-    pattern: /\bimport\s+/,
-    message: "import statements are not available in workflow scripts",
-  },
-  {
-    pattern: /\bDate\.now\s*\(/,
-    message: "Date.now() would break resume determinism",
-  },
-  {
-    pattern: /\bMath\.random\s*\(/,
-    message: "Math.random() would break resume determinism",
-  },
-  {
-    pattern: /\bnew\s+Date\s*\(\s*\)/,
-    message: "argless new Date() would break resume determinism",
-  },
-  {
-    pattern: /\brequire\s*\(\s*['"]fs['"]\s*\)/,
-    message: "filesystem access is not available in workflow scripts",
-  },
-  {
-    pattern: /\bfs\.\w+/,
-    message: "filesystem access is not available in workflow scripts",
-  },
-  {
-    pattern: /\bchild_process\b/,
-    message: "child_process is not available in workflow scripts",
-  },
-  {
-    pattern: /\b__dirname\b/,
-    message: "__dirname is not available in workflow scripts",
-  },
-  {
-    pattern: /\b__filename\b/,
-    message: "__filename is not available in workflow scripts",
-  },
-  {
-    pattern: /\bglobal\./,
-    message: "global.* is not available in workflow scripts",
-  },
-  {
-    pattern: /\bglobalThis\b/,
-    message: "globalThis is not available in workflow scripts",
-  },
-];
-
-export interface ParsedScript {
-  meta: WorkflowMeta;
-  body: string;
-}
-
-export interface ScriptValidationResult {
-  valid: boolean;
-  errors: string[];
-}
-
-/**
- * Validate a workflow script for banned patterns and required structure
- */
-export function validateScript(script: string): ScriptValidationResult {
-  const errors: string[] = [];
-
-  // Check for export const meta = {...}
-  if (!/export\s+const\s+meta\s*=/.test(script)) {
-    errors.push("Script must start with 'export const meta = {...}'");
-  }
-
-  // Check banned patterns
-  for (const { pattern, message } of BANNED_PATTERNS) {
-    if (pattern.test(script)) {
-      errors.push(message);
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Parse a workflow script into meta and body.
- * Extracts the `export const meta = {...}` declaration and the rest of the script.
- */
-export function parseScript(script: string): ParsedScript {
-  // Match: export const meta = { ... }
-  // We need to find the matching closing brace for the meta object
-  const metaStartMatch = script.match(/export\s+const\s+meta\s*=\s*/);
-  if (!metaStartMatch) {
-    throw new Error("Script must contain 'export const meta = {...}'");
-  }
-
-  const metaStartIndex = metaStartMatch.index! + metaStartMatch[0].length;
-
-  // Find the matching closing brace for the meta object
-  let depth = 0;
-  let metaEndIndex = -1;
-  let inString: string | null = null;
-  let escaped = false;
-
-  for (let i = metaStartIndex; i < script.length; i++) {
-    const char = script[i];
-
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-
-    if (char === "\\") {
-      escaped = true;
-      continue;
-    }
-
-    if (inString) {
-      if (char === inString) {
-        inString = null;
-      }
-      continue;
-    }
-
-    if (char === '"' || char === "'" || char === "`") {
-      inString = char;
-      continue;
-    }
-
-    if (char === "{") {
-      depth++;
-    } else if (char === "}") {
-      depth--;
-      if (depth === 0) {
-        metaEndIndex = i + 1;
-        break;
-      }
-    }
-  }
-
-  if (metaEndIndex === -1) {
-    throw new Error("Could not find matching closing brace for meta object");
-  }
-
-  const metaString = script.slice(metaStartIndex, metaEndIndex);
-
-  // Parse meta as JSON (allowing JS object syntax — unquoted keys, trailing commas)
-  // We use a safe approach: wrap in parentheses and use Function to evaluate
-  let meta: WorkflowMeta;
-  try {
-    // Remove trailing comma before closing brace/bracket (common in JS objects)
-    const cleaned = metaString.replace(/,\s*([}\]])/g, "$1");
-    // Wrap unquoted keys with double quotes
-    const quoted = cleaned.replace(/(\w+)\s*:/g, '"$1":');
-    meta = JSON.parse(quoted);
-  } catch {
-    // Fallback: use Function constructor for safe evaluation
-    try {
-      const fn = new Function(`"use strict"; return (${metaString});`);
-      meta = fn();
-    } catch (e) {
-      throw new Error(
-        `Failed to parse meta object: ${e instanceof Error ? e.message : String(e)}`,
-      );
-    }
-  }
-
-  // Validate required meta fields
-  if (!meta.name || typeof meta.name !== "string") {
-    throw new Error("meta.name is required and must be a string");
-  }
-  if (!meta.description || typeof meta.description !== "string") {
-    throw new Error("meta.description is required and must be a string");
-  }
-
-  // Body is everything after the meta declaration (and any trailing semicolons/newlines)
-  const bodyStart = metaEndIndex;
-  const body = script.slice(bodyStart).replace(/^\s*;?\s*/, "");
-
-  return { meta, body };
-}
-
-/**
- * Execute a workflow script with the given API closures.
- * The script body is wrapped in an async IIFE and executed via new Function().
- */
-export async function executeScript(
-  script: string,
-  apis: {
-    agent: (prompt: string, opts?: Record<string, unknown>) => Promise<unknown>;
-    parallel: (thunks: Array<() => Promise<unknown>>) => Promise<unknown[]>;
-    pipeline: (
-      items: unknown[],
-      ...stages: Array<
-        (prev: unknown, item: unknown, index: number) => Promise<unknown>
-      >
-    ) => Promise<unknown[]>;
-    phase: (title: string) => void;
-    log: (message: string) => void;
-    args: unknown;
-    budget: unknown;
-  },
-  abortSignal?: AbortSignal,
-): Promise<{ meta: WorkflowMeta; result: unknown }> {
-  // Validate first
-  const validation = validateScript(script);
-  if (!validation.valid) {
-    throw new Error(
-      `Script validation failed:\n${validation.errors.join("\n")}`,
-    );
-  }
-
-  // Parse script
-  const { meta, body } = parseScript(script);
-
-  logger.info(
-    `[Workflow] Executing script "${meta.name}": ${meta.description}`,
-  );
-
-  // Wrap the body in an async function and inject API closures
-  const fn = new Function(
-    "agent",
-    "parallel",
-    "pipeline",
-    "phase",
-    "log",
-    "args",
-    "budget",
-    `"use strict"; return (async () => { ${body} })();`,
-  );
-
-  // Execute with abort support
-  const scriptPromise = fn(
-    apis.agent,
-    apis.parallel,
-    apis.pipeline,
-    apis.phase,
-    apis.log,
-    apis.args,
-    apis.budget,
-  );
-
-  let result: unknown;
-  if (abortSignal) {
-    result = await Promise.race([
-      scriptPromise,
-      new Promise<never>((_, reject) => {
-        if (abortSignal.aborted) {
-          reject(new Error("Workflow aborted"));
-          return;
-        }
-        abortSignal.addEventListener(
-          "abort",
-          () => reject(new Error("Workflow aborted")),
-          { once: true },
-        );
-      }),
-    ]);
-  } else {
-    result = await scriptPromise;
-  }
-
-  return { meta, result };
-}