@elsium-ai/workflows 0.1.6

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { step, executeStep } from './step';
+export { defineWorkflow, defineParallelWorkflow, defineBranchWorkflow } from './workflow';
+export type { Workflow, ParallelWorkflowConfig, BranchConfig } from './workflow';
+export type { StepConfig, StepContext, StepResult, StepStatus, RetryConfig, WorkflowConfig, WorkflowResult, WorkflowStatus, WorkflowRunOptions, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAG1C,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACzF,YAAY,EAAE,QAAQ,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAGhF,YAAY,EACX,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,cAAc,EACd,cAAc,EACd,kBAAkB,GAClB,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,334 @@
+// @bun
+// ../core/src/errors.ts
+class ElsiumError extends Error {
+  code;
+  provider;
+  model;
+  statusCode;
+  retryable;
+  retryAfterMs;
+  cause;
+  metadata;
+  constructor(details) {
+    super(details.message);
+    this.name = "ElsiumError";
+    this.code = details.code;
+    this.provider = details.provider;
+    this.model = details.model;
+    this.statusCode = details.statusCode;
+    this.retryable = details.retryable;
+    this.retryAfterMs = details.retryAfterMs;
+    this.cause = details.cause;
+    this.metadata = details.metadata;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      provider: this.provider,
+      model: this.model,
+      statusCode: this.statusCode,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      metadata: this.metadata
+    };
+  }
+  static providerError(message, opts) {
+    return new ElsiumError({
+      code: "PROVIDER_ERROR",
+      message,
+      provider: opts.provider,
+      statusCode: opts.statusCode,
+      retryable: opts.retryable ?? false,
+      cause: opts.cause
+    });
+  }
+  static rateLimit(provider, retryAfterMs) {
+    return new ElsiumError({
+      code: "RATE_LIMIT",
+      message: `Rate limited by ${provider}`,
+      provider,
+      statusCode: 429,
+      retryable: true,
+      retryAfterMs
+    });
+  }
+  static authError(provider) {
+    return new ElsiumError({
+      code: "AUTH_ERROR",
+      message: `Authentication failed for ${provider}. Check your API key.`,
+      provider,
+      statusCode: 401,
+      retryable: false
+    });
+  }
+  static timeout(provider, timeoutMs) {
+    return new ElsiumError({
+      code: "TIMEOUT",
+      message: `Request to ${provider} timed out after ${timeoutMs}ms`,
+      provider,
+      retryable: true
+    });
+  }
+  static validation(message, metadata) {
+    return new ElsiumError({
+      code: "VALIDATION_ERROR",
+      message,
+      retryable: false,
+      metadata
+    });
+  }
+  static budgetExceeded(spent, budget) {
+    return new ElsiumError({
+      code: "BUDGET_EXCEEDED",
+      message: `Token budget exceeded: spent ${spent}, budget ${budget}`,
+      retryable: false,
+      metadata: { spent, budget }
+    });
+  }
+}
+// ../core/src/utils.ts
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// src/step.ts
+function step(name, config) {
+  return { name, ...config };
+}
+function validateInput(stepConfig, rawInput, startTime) {
+  if (!stepConfig.input)
+    return null;
+  const parsed = stepConfig.input.safeParse(rawInput);
+  if (parsed.success)
+    return null;
+  return {
+    name: stepConfig.name,
+    status: "failed",
+    error: `Input validation failed: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`,
+    durationMs: Math.round(performance.now() - startTime),
+    retryCount: 0
+  };
+}
+function checkCondition(stepConfig, input, context, startTime) {
+  if (!stepConfig.condition || stepConfig.condition(input, context))
+    return null;
+  return {
+    name: stepConfig.name,
+    status: "skipped",
+    durationMs: Math.round(performance.now() - startTime),
+    retryCount: 0
+  };
+}
+async function tryFallback(stepConfig, err2, input, startTime, retryCount) {
+  if (!stepConfig.fallback) {
+    return {
+      name: stepConfig.name,
+      status: "failed",
+      error: err2.message,
+      durationMs: Math.round(performance.now() - startTime),
+      retryCount
+    };
+  }
+  try {
+    const fallbackResult = await stepConfig.fallback(err2, input);
+    return {
+      name: stepConfig.name,
+      status: "completed",
+      data: fallbackResult,
+      durationMs: Math.round(performance.now() - startTime),
+      retryCount
+    };
+  } catch (fallbackError) {
+    return {
+      name: stepConfig.name,
+      status: "failed",
+      error: `Fallback failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`,
+      durationMs: Math.round(performance.now() - startTime),
+      retryCount
+    };
+  }
+}
+async function executeStep(stepConfig, rawInput, context) {
+  const startTime = performance.now();
+  let retryCount = 0;
+  const validationError = validateInput(stepConfig, rawInput, startTime);
+  if (validationError)
+    return validationError;
+  const input = rawInput;
+  const conditionSkip = checkCondition(stepConfig, input, context, startTime);
+  if (conditionSkip)
+    return conditionSkip;
+  const retryConfig = stepConfig.retry;
+  const maxRetries = retryConfig?.maxRetries ?? 0;
+  while (true) {
+    try {
+      const result = await executeWithTimeout(() => stepConfig.handler(input, context), stepConfig.timeoutMs, stepConfig.name);
+      return {
+        name: stepConfig.name,
+        status: "completed",
+        data: result,
+        durationMs: Math.round(performance.now() - startTime),
+        retryCount
+      };
+    } catch (error) {
+      const err2 = error instanceof Error ? error : new Error(String(error));
+      if (retryCount < maxRetries && shouldRetryError(err2, retryConfig)) {
+        retryCount++;
+        const delay = calculateBackoff(retryCount, retryConfig);
+        await sleep(delay);
+        continue;
+      }
+      return tryFallback(stepConfig, err2, input, startTime, retryCount);
+    }
+  }
+}
+async function executeWithTimeout(fn, timeoutMs, stepName) {
+  if (!timeoutMs)
+    return fn();
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await Promise.race([
+      fn(),
+      new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => {
+          reject(ElsiumError.timeout(stepName, timeoutMs));
+        });
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function shouldRetryError(error, config) {
+  if (!config)
+    return false;
+  if (config.shouldRetry)
+    return config.shouldRetry(error);
+  if (error instanceof ElsiumError)
+    return error.retryable;
+  return true;
+}
+function calculateBackoff(attempt, config) {
+  const baseDelay = config?.baseDelayMs ?? 1000;
+  const maxDelay = config?.maxDelayMs ?? 30000;
+  const delay = Math.min(baseDelay * 2 ** (attempt - 1), maxDelay);
+  return delay * (0.5 + Math.random() * 0.5);
+}
+// src/workflow.ts
+function defineWorkflow(config) {
+  return {
+    name: config.name,
+    async run(input, options) {
+      const startTime = performance.now();
+      const stepResults = [];
+      const outputs = {};
+      let currentInput = input;
+      for (let i = 0;i < config.steps.length; i++) {
+        const stepConfig = config.steps[i];
+        const context = {
+          workflowName: config.name,
+          stepIndex: i,
+          previousOutputs: { ...outputs },
+          signal: options?.signal
+        };
+        const result = await executeStep(stepConfig, currentInput, context);
+        stepResults.push(result);
+        if (result.status === "completed" && result.data !== undefined) {
+          outputs[stepConfig.name] = result.data;
+          currentInput = result.data;
+        }
+        await config.onStepComplete?.(result);
+        if (result.status === "failed") {
+          await config.onStepError?.(new Error(result.error ?? "Step failed"), stepConfig.name);
+          const workflowResult2 = {
+            name: config.name,
+            status: "failed",
+            steps: stepResults,
+            totalDurationMs: Math.round(performance.now() - startTime),
+            outputs
+          };
+          await config.onComplete?.(workflowResult2);
+          return workflowResult2;
+        }
+      }
+      const workflowResult = {
+        name: config.name,
+        status: "completed",
+        steps: stepResults,
+        totalDurationMs: Math.round(performance.now() - startTime),
+        outputs
+      };
+      await config.onComplete?.(workflowResult);
+      return workflowResult;
+    }
+  };
+}
+function defineParallelWorkflow(config) {
+  return {
+    name: config.name,
+    async run(input, options) {
+      const startTime = performance.now();
+      const resultPromises = config.steps.map((stepConfig, i) => {
+        const context = {
+          workflowName: config.name,
+          stepIndex: i,
+          previousOutputs: {},
+          signal: options?.signal
+        };
+        return executeStep(stepConfig, input, context);
+      });
+      const stepResults = await Promise.all(resultPromises);
+      const outputs = {};
+      let failed = false;
+      for (let i = 0;i < stepResults.length; i++) {
+        const result = stepResults[i];
+        if (result.status === "completed" && result.data !== undefined) {
+          outputs[config.steps[i].name] = result.data;
+        }
+        if (result.status === "failed") {
+          failed = true;
+        }
+      }
+      const workflowResult = {
+        name: config.name,
+        status: failed ? "failed" : "completed",
+        steps: stepResults,
+        totalDurationMs: Math.round(performance.now() - startTime),
+        outputs
+      };
+      await config.onComplete?.(workflowResult);
+      return workflowResult;
+    }
+  };
+}
+function defineBranchWorkflow(name, branches, fallback) {
+  return {
+    name,
+    async run(input, options) {
+      for (const branch of branches) {
+        if (branch.condition(input)) {
+          return branch.workflow.run(input, options);
+        }
+      }
+      if (fallback) {
+        return fallback.run(input, options);
+      }
+      return {
+        name,
+        status: "completed",
+        steps: [],
+        totalDurationMs: 0,
+        outputs: {}
+      };
+    }
+  };
+}
+export {
+  step,
+  executeStep,
+  defineWorkflow,
+  defineParallelWorkflow,
+  defineBranchWorkflow
+};

package/dist/step.d.ts

@@ -0,0 +1,4 @@
+import type { StepConfig, StepContext, StepResult } from './types';
+export declare function step<TInput, TOutput>(name: string, config: Omit<StepConfig<TInput, TOutput>, 'name'>): StepConfig<TInput, TOutput>;
+export declare function executeStep<TInput, TOutput>(stepConfig: StepConfig<TInput, TOutput>, rawInput: unknown, context: StepContext): Promise<StepResult<TOutput>>;
+//# sourceMappingURL=step.d.ts.map

package/dist/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../src/step.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE/E,wBAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,EACnC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,GAC/C,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,CAE7B;AA0ED,wBAAsB,WAAW,CAAC,MAAM,EAAE,OAAO,EAChD,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,WAAW,GAClB,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CA2C9B"}

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+import type { z } from 'zod';
+export type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface StepConfig<TInput = unknown, TOutput = unknown> {
+    name: string;
+    input?: z.ZodType<TInput>;
+    handler: (input: TInput, context: StepContext) => Promise<TOutput>;
+    retry?: RetryConfig;
+    condition?: (input: TInput, context: StepContext) => boolean;
+    fallback?: (error: Error, input: TInput) => Promise<TOutput>;
+    timeoutMs?: number;
+}
+export interface StepContext {
+    workflowName: string;
+    stepIndex: number;
+    previousOutputs: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface StepResult<T = unknown> {
+    name: string;
+    status: StepStatus;
+    data?: T;
+    error?: string;
+    durationMs: number;
+    retryCount: number;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    shouldRetry?: (error: Error) => boolean;
+}
+export type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface WorkflowConfig {
+    name: string;
+    steps: StepConfig[];
+    onStepComplete?: (result: StepResult) => void | Promise<void>;
+    onStepError?: (error: Error, stepName: string) => void | Promise<void>;
+    onComplete?: (result: WorkflowResult) => void | Promise<void>;
+}
+export interface WorkflowResult {
+    name: string;
+    status: WorkflowStatus;
+    steps: StepResult[];
+    totalDurationMs: number;
+    outputs: Record<string, unknown>;
+}
+export interface WorkflowRunOptions {
+    signal?: AbortSignal;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAI5B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;AAEnF,MAAM,WAAW,UAAU,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAClE,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAA;IAC5D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,WAAW;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACxC,MAAM,CAAC,EAAE,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,GAAG,OAAO;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,CAAC,EAAE,CAAC,CAAA;IACR,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CAClB;AAID,MAAM,WAAW,WAAW;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAA;CACvC;AAID,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;AAE3E,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7D,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtE,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7D;AAED,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,cAAc,CAAA;IACtB,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC;AAED,MAAM,WAAW,kBAAkB;IAClC,MAAM,CAAC,EAAE,WAAW,CAAA;CACpB"}

package/dist/workflow.d.ts

@@ -0,0 +1,18 @@
+import type { StepConfig, WorkflowConfig, WorkflowResult, WorkflowRunOptions } from './types';
+export interface Workflow {
+    readonly name: string;
+    run(input: unknown, options?: WorkflowRunOptions): Promise<WorkflowResult>;
+}
+export declare function defineWorkflow(config: WorkflowConfig): Workflow;
+export interface ParallelWorkflowConfig {
+    name: string;
+    steps: StepConfig[];
+    onComplete?: (result: WorkflowResult) => void | Promise<void>;
+}
+export declare function defineParallelWorkflow(config: ParallelWorkflowConfig): Workflow;
+export interface BranchConfig {
+    condition: (input: unknown) => boolean;
+    workflow: Workflow;
+}
+export declare function defineBranchWorkflow(name: string, branches: BranchConfig[], fallback?: Workflow): Workflow;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,UAAU,EAGV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CAC1E;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,QAAQ,CA0D/D;AAID,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7D;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,sBAAsB,GAAG,QAAQ,CA2C/E;AAID,MAAM,WAAW,YAAY;IAC5B,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAA;IACtC,QAAQ,EAAE,QAAQ,CAAA;CAClB;AAED,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,YAAY,EAAE,EACxB,QAAQ,CAAC,EAAE,QAAQ,GACjB,QAAQ,CAwBV"}

package/package.json

@@ -0,0 +1,36 @@
+{
+	"name": "@elsium-ai/workflows",
+	"version": "0.1.6",
+	"description": "Multi-step workflow pipelines and DAG execution for ElsiumAI",
+	"license": "MIT",
+	"author": "Eric Utrera <ebutrera9103@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/elsium-ai/elsium-ai",
+		"directory": "packages/workflows"
+	},
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "bun build ./src/index.ts --outdir ./dist --target bun && bun x tsc -p tsconfig.build.json --emitDeclarationOnly",
+		"dev": "bun --watch src/index.ts"
+	},
+	"dependencies": {
+		"@elsium-ai/core": "workspace:*",
+		"zod": "^3.24.0"
+	},
+	"devDependencies": {
+		"bun-types": "^1.3.0",
+		"typescript": "^5.7.0"
+	}
+}