ts-agent-lib 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1141 @@
+'use strict';
+
+var crypto = require('crypto');
+var zod = require('zod');
+
+// src/executor.ts
+
+// src/internal/async_queue.ts
+var AsyncQueue = class {
+  capacity;
+  items = [];
+  getWaiters = [];
+  putWaiters = [];
+  constructor(capacity = Infinity) {
+    if (!Number.isFinite(capacity) && capacity !== Infinity) {
+      throw new Error("capacity must be a number or Infinity");
+    }
+    if (capacity <= 0) {
+      throw new Error("capacity must be > 0");
+    }
+    this.capacity = capacity;
+  }
+  get size() {
+    return this.items.length;
+  }
+  shift() {
+    if (this.items.length === 0) {
+      return void 0;
+    }
+    const item = this.items.shift();
+    this.drainPutWaiter();
+    return item;
+  }
+  async put(item) {
+    if (this.getWaiters.length > 0) {
+      const waiter = this.getWaiters.shift();
+      if (waiter.signal && waiter.onAbort) {
+        waiter.signal.removeEventListener("abort", waiter.onAbort);
+      }
+      waiter.resolve(item);
+      return;
+    }
+    if (this.items.length < this.capacity) {
+      this.items.push(item);
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.putWaiters.push({ item, resolve, reject });
+    });
+  }
+  tryPut(item) {
+    if (this.getWaiters.length > 0) {
+      const waiter = this.getWaiters.shift();
+      if (waiter.signal && waiter.onAbort) {
+        waiter.signal.removeEventListener("abort", waiter.onAbort);
+      }
+      waiter.resolve(item);
+      return true;
+    }
+    if (this.items.length < this.capacity) {
+      this.items.push(item);
+      return true;
+    }
+    return false;
+  }
+  async get(signal) {
+    if (this.items.length > 0) {
+      const item = this.items.shift();
+      this.drainPutWaiter();
+      return item;
+    }
+    if (signal?.aborted) {
+      throw abortError();
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        reject,
+        signal
+      };
+      if (signal) {
+        const onAbort = () => {
+          this.removeGetWaiter(waiter);
+          reject(abortError());
+        };
+        waiter.onAbort = onAbort;
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      this.getWaiters.push(waiter);
+    });
+  }
+  removeGetWaiter(waiter) {
+    const idx = this.getWaiters.indexOf(waiter);
+    if (idx >= 0) {
+      this.getWaiters.splice(idx, 1);
+    }
+    if (waiter.signal && waiter.onAbort) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+    }
+  }
+  drainPutWaiter() {
+    if (this.items.length >= this.capacity) {
+      return;
+    }
+    if (this.putWaiters.length === 0) {
+      return;
+    }
+    const waiter = this.putWaiters.shift();
+    this.items.push(waiter.item);
+    waiter.resolve();
+  }
+};
+function abortError() {
+  const error = new Error("aborted");
+  error.name = "AbortError";
+  return error;
+}
+var stepStatusValues = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "blocked",
+  "cancelled"
+];
+var StepStatus = {
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  BLOCKED: "blocked",
+  CANCELLED: "cancelled"
+};
+var StepStatusSchema = zod.z.enum(stepStatusValues);
+var executionStatusValues = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var ExecutionStatus = {
+  PENDING: "pending",
+  RUNNING: "running",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  CANCELLED: "cancelled"
+};
+var ExecutionStatusSchema = zod.z.enum(executionStatusValues);
+var depsSchema = zod.z.array(zod.z.string()).optional().transform((val) => val ?? []);
+var StepSchema = zod.z.object({
+  id: zod.z.string(),
+  action: zod.z.string(),
+  deps: depsSchema,
+  payload: zod.z.unknown().optional()
+});
+function utcNow() {
+  return /* @__PURE__ */ new Date();
+}
+var ErrorInfoSchema = zod.z.object({
+  message: zod.z.string(),
+  type: zod.z.string().optional(),
+  traceback: zod.z.string().optional()
+});
+var StepResultSchema = zod.z.object({
+  stepId: zod.z.string(),
+  status: StepStatusSchema.default(StepStatus.PENDING),
+  output: zod.z.unknown().optional(),
+  error: ErrorInfoSchema.optional(),
+  startedAt: zod.z.coerce.date().optional(),
+  finishedAt: zod.z.coerce.date().optional()
+});
+var stepResultMapSchema = zod.z.preprocess(
+  (val) => {
+    if (val instanceof Map) {
+      return val;
+    }
+    if (val && typeof val === "object") {
+      return new Map(Object.entries(val));
+    }
+    return val;
+  },
+  zod.z.map(zod.z.string(), StepResultSchema)
+);
+var ExecutionStateSchema = zod.z.object({
+  executionId: zod.z.string(),
+  status: ExecutionStatusSchema.default(ExecutionStatus.PENDING),
+  steps: stepResultMapSchema,
+  startedAt: zod.z.coerce.date().optional(),
+  finishedAt: zod.z.coerce.date().optional()
+});
+var ExecutionEventSchema = zod.z.object({
+  executionId: zod.z.string(),
+  ts: zod.z.coerce.date(),
+  type: zod.z.string()
+});
+var ExecutionStartedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("execution_started"),
+  startedAt: zod.z.coerce.date()
+});
+var ExecutionCompletedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("execution_completed"),
+  status: ExecutionStatusSchema,
+  finishedAt: zod.z.coerce.date()
+});
+var ExecutionCancelledSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("execution_cancelled"),
+  finishedAt: zod.z.coerce.date()
+});
+var StepScheduledSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_scheduled"),
+  stepId: zod.z.string()
+});
+var StepStartedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_started"),
+  stepId: zod.z.string()
+});
+var StepCompletedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_completed"),
+  stepId: zod.z.string()
+});
+var StepFailedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_failed"),
+  stepId: zod.z.string(),
+  error: ErrorInfoSchema
+});
+var StepBlockedSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_blocked"),
+  stepId: zod.z.string()
+});
+var StepCancelledSchema = ExecutionEventSchema.extend({
+  type: zod.z.literal("step_cancelled"),
+  stepId: zod.z.string()
+});
+var ExecutionEventTypeSchema = zod.z.union([
+  ExecutionStartedSchema,
+  ExecutionCompletedSchema,
+  ExecutionCancelledSchema,
+  StepScheduledSchema,
+  StepStartedSchema,
+  StepCompletedSchema,
+  StepFailedSchema,
+  StepBlockedSchema,
+  StepCancelledSchema
+]);
+var stepMapSchema = zod.z.preprocess(
+  (val) => {
+    if (val instanceof Map) {
+      return val;
+    }
+    if (val && typeof val === "object") {
+      return new Map(Object.entries(val));
+    }
+    return val;
+  },
+  zod.z.map(zod.z.string(), StepSchema)
+);
+var PlanSchema = zod.z.object({
+  steps: stepMapSchema
+});
+var Plan = class {
+  _steps;
+  constructor(steps) {
+    const parsedSteps = stepMapSchema.parse(steps);
+    const normalized = /* @__PURE__ */ new Map();
+    for (const [key, step] of parsedSteps.entries()) {
+      if (key !== step.id) {
+        throw new Error(`step key '${key}' does not match step.id '${step.id}'`);
+      }
+      normalized.set(step.id, freezeStep(step));
+    }
+    this._steps = normalized;
+  }
+  [Symbol.iterator]() {
+    return this._steps.values();
+  }
+  get steps() {
+    return this._steps;
+  }
+  getStep(stepId) {
+    const step = this._steps.get(stepId);
+    if (!step) {
+      throw new Error(`unknown step '${stepId}'`);
+    }
+    return step;
+  }
+};
+function freezeStep(step) {
+  const deps = Array.isArray(step.deps) ? [...step.deps] : [];
+  Object.freeze(deps);
+  const frozen = {
+    id: step.id,
+    action: step.action,
+    deps,
+    payload: step.payload
+  };
+  return Object.freeze(frozen);
+}
+
+// src/executor.ts
+var StepContext = class {
+  _executionId;
+  _stepId;
+  _signal;
+  _plan;
+  _getResult;
+  constructor(params) {
+    this._executionId = params.executionId;
+    this._stepId = params.stepId;
+    this._signal = params.signal;
+    this._plan = params.plan;
+    this._getResult = params.getResult;
+  }
+  get executionId() {
+    return this._executionId;
+  }
+  get stepId() {
+    return this._stepId;
+  }
+  get signal() {
+    return this._signal;
+  }
+  isCancelled() {
+    return this._signal?.aborted ?? false;
+  }
+  getStep(stepId) {
+    return this._plan.getStep(stepId);
+  }
+  getResult(stepId) {
+    const res = this._getResult(stepId);
+    return res ? cloneStepResult(res) : void 0;
+  }
+  requireResult(stepId) {
+    const res = this.getResult(stepId);
+    if (!res) {
+      throw new Error(`missing result for step '${stepId}'`);
+    }
+    return res;
+  }
+  getDependencyResults() {
+    const step = this._plan.getStep(this._stepId);
+    const deps = {};
+    for (const depId of step.deps) {
+      const res = this._getResult(depId);
+      if (res && res.status === StepStatus.COMPLETED) {
+        deps[depId] = cloneStepResult(res);
+      }
+    }
+    return deps;
+  }
+  getDependencyOutputs() {
+    const results = this.getDependencyResults();
+    const outputs = {};
+    for (const [depId, res] of Object.entries(results)) {
+      outputs[depId] = res.output;
+    }
+    return outputs;
+  }
+};
+var DagExecutor = class {
+  maxParallelSteps;
+  failFast;
+  constructor(params = {}) {
+    const { maxParallelSteps = 8, failFast = false } = params;
+    if (maxParallelSteps <= 0) {
+      throw new Error("maxParallelSteps must be > 0");
+    }
+    this.maxParallelSteps = maxParallelSteps;
+    this.failFast = failFast;
+  }
+  async executeAsync(plan, handlers, options = {}) {
+    const execId = options.executionId ?? crypto.randomUUID();
+    const state = {
+      executionId: execId,
+      status: ExecutionStatus.RUNNING,
+      steps: /* @__PURE__ */ new Map(),
+      startedAt: utcNow()
+    };
+    const allSteps = /* @__PURE__ */ new Map();
+    for (const step of plan) {
+      allSteps.set(step.id, step);
+      state.steps.set(step.id, {
+        stepId: step.id,
+        status: StepStatus.PENDING
+      });
+    }
+    const emit = async (event) => {
+      if (options.onEvent) {
+        await options.onEvent(event);
+      }
+    };
+    await emit({
+      type: "execution_started",
+      executionId: execId,
+      ts: state.startedAt ?? utcNow(),
+      startedAt: state.startedAt ?? utcNow()
+    });
+    const ready = [];
+    const readySet = /* @__PURE__ */ new Set();
+    const schedState = {
+      running: /* @__PURE__ */ new Map(),
+      failFast: this.failFast,
+      stopScheduling: false
+    };
+    const isCancelled = () => options.cancelSignal?.aborted ?? false;
+    const canRun = (step) => {
+      const res = state.steps.get(step.id);
+      if (!res || res.status !== StepStatus.PENDING) {
+        return false;
+      }
+      for (const depId of step.deps) {
+        const depRes = state.steps.get(depId);
+        if (!depRes) {
+          throw new Error(`unknown dependency '${depId}' for step '${step.id}'`);
+        }
+        if (depRes.status !== StepStatus.COMPLETED) {
+          return false;
+        }
+      }
+      return true;
+    };
+    const refreshReady = () => {
+      for (const step of allSteps.values()) {
+        if (readySet.has(step.id)) {
+          continue;
+        }
+        if (canRun(step)) {
+          ready.push(step.id);
+          readySet.add(step.id);
+        }
+      }
+    };
+    const cancelStep = async (stepId, res) => {
+      res.status = StepStatus.CANCELLED;
+      if (!res.finishedAt) {
+        res.finishedAt = utcNow();
+      }
+      await emit({
+        type: "step_cancelled",
+        executionId: execId,
+        ts: utcNow(),
+        stepId
+      });
+    };
+    const failStep = async (stepId, res, err) => {
+      res.status = StepStatus.FAILED;
+      res.error = err;
+      if (!res.finishedAt) {
+        res.finishedAt = utcNow();
+      }
+      await emit({
+        type: "step_failed",
+        executionId: execId,
+        ts: utcNow(),
+        stepId,
+        error: err
+      });
+      if (schedState.failFast) {
+        schedState.stopScheduling = true;
+      }
+    };
+    const blockStep = async (stepId, res) => {
+      res.status = StepStatus.BLOCKED;
+      if (!res.finishedAt) {
+        res.finishedAt = utcNow();
+      }
+      await emit({
+        type: "step_blocked",
+        executionId: execId,
+        ts: utcNow(),
+        stepId
+      });
+    };
+    const runStep = async (stepId) => {
+      const step = allSteps.get(stepId);
+      const res = state.steps.get(stepId);
+      if (isCancelled()) {
+        await cancelStep(stepId, res);
+        return;
+      }
+      res.status = StepStatus.RUNNING;
+      res.startedAt = utcNow();
+      await emit({
+        type: "step_started",
+        executionId: execId,
+        ts: utcNow(),
+        stepId
+      });
+      const handler = handlers[step.action];
+      if (!handler) {
+        await failStep(stepId, res, {
+          message: `no handler for action '${step.action}'`,
+          type: "MissingHandler"
+        });
+        return;
+      }
+      const ctx = new StepContext({
+        executionId: execId,
+        stepId,
+        signal: options.cancelSignal,
+        plan,
+        getResult: (id) => state.steps.get(id)
+      });
+      let result;
+      try {
+        result = StepResultSchema.parse(await handler(step, ctx));
+      } catch (err) {
+        if (isAbortError(err)) {
+          await cancelStep(stepId, res);
+          return;
+        }
+        const errorInfo = {
+          message: err instanceof Error ? err.message : String(err),
+          type: err instanceof Error ? err.name : "Error",
+          traceback: err instanceof Error ? err.stack : void 0
+        };
+        await failStep(stepId, res, errorInfo);
+        return;
+      }
+      let status = result.status;
+      if (status === StepStatus.PENDING || status === StepStatus.RUNNING) {
+        status = result.error ? StepStatus.FAILED : StepStatus.COMPLETED;
+      } else if (status === StepStatus.COMPLETED && result.error) {
+        status = StepStatus.FAILED;
+      }
+      res.status = status;
+      res.output = result.output;
+      res.error = result.error;
+      res.startedAt = res.startedAt ?? result.startedAt ?? utcNow();
+      res.finishedAt = result.finishedAt ?? utcNow();
+      if (res.status === StepStatus.COMPLETED) {
+        await emit({
+          type: "step_completed",
+          executionId: execId,
+          ts: utcNow(),
+          stepId
+        });
+      } else if (res.status === StepStatus.FAILED) {
+        await failStep(
+          stepId,
+          res,
+          res.error ?? { message: "step failed", type: "Unknown" }
+        );
+      } else if (res.status === StepStatus.CANCELLED) {
+        await cancelStep(stepId, res);
+      } else if (res.status === StepStatus.BLOCKED) {
+        await blockStep(stepId, res);
+      }
+    };
+    refreshReady();
+    while (true) {
+      if (isCancelled()) {
+        schedState.stopScheduling = true;
+      }
+      while (!schedState.stopScheduling && schedState.running.size < this.maxParallelSteps) {
+        if (ready.length === 0) {
+          break;
+        }
+        const stepId = ready.shift();
+        readySet.delete(stepId);
+        const stepRes = state.steps.get(stepId);
+        if (!stepRes || stepRes.status !== StepStatus.PENDING) {
+          continue;
+        }
+        await emit({
+          type: "step_scheduled",
+          executionId: execId,
+          ts: utcNow(),
+          stepId
+        });
+        const task = runStep(stepId);
+        schedState.running.set(task, stepId);
+      }
+      if (schedState.running.size === 0) {
+        if (schedState.stopScheduling || ready.length === 0) {
+          break;
+        }
+      }
+      if (schedState.running.size > 0) {
+        try {
+          const { task: finished } = await waitForAny(schedState.running.keys());
+          schedState.running.delete(finished);
+        } catch (err) {
+          if (isTaskError(err)) {
+            schedState.running.delete(err.task);
+            throw err.error;
+          }
+          throw err;
+        }
+      }
+      refreshReady();
+    }
+    if (isCancelled()) {
+      for (const [stepId, res] of state.steps.entries()) {
+        if (res.status === StepStatus.PENDING) {
+          await cancelStep(stepId, res);
+        }
+      }
+      state.status = ExecutionStatus.CANCELLED;
+      state.finishedAt = utcNow();
+      await emit({
+        type: "execution_cancelled",
+        executionId: execId,
+        ts: utcNow(),
+        finishedAt: state.finishedAt
+      });
+      return state;
+    }
+    for (const [stepId, res] of state.steps.entries()) {
+      if (res.status === StepStatus.PENDING) {
+        await blockStep(stepId, res);
+      }
+    }
+    const allCompleted = Array.from(state.steps.values()).every(
+      (res) => res.status === StepStatus.COMPLETED
+    );
+    state.status = allCompleted ? ExecutionStatus.COMPLETED : ExecutionStatus.FAILED;
+    state.finishedAt = utcNow();
+    await emit({
+      type: "execution_completed",
+      executionId: execId,
+      ts: utcNow(),
+      status: state.status,
+      finishedAt: state.finishedAt
+    });
+    return state;
+  }
+  execute(plan, handlers, options = {}) {
+    return this.executeAsync(plan, handlers, options);
+  }
+  async *streamExecute(plan, handlers, options = {}) {
+    const queue = new AsyncQueue(Infinity);
+    const controller = new AbortController();
+    const signal = mergeAbortSignals(options.cancelSignal, controller.signal);
+    let execError;
+    const task = this.executeAsync(plan, handlers, {
+      ...options,
+      cancelSignal: signal,
+      onEvent: async (event) => {
+        await queue.put(event);
+      }
+    }).catch((err) => {
+      execError = err;
+    }).finally(async () => {
+      await queue.put(null);
+    });
+    try {
+      while (true) {
+        const event = await queue.get();
+        if (event === null) {
+          break;
+        }
+        yield event;
+      }
+    } finally {
+      controller.abort();
+      await task;
+      if (execError) {
+        throw execError;
+      }
+    }
+  }
+};
+function isAbortError(err) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const name = "name" in err ? String(err.name) : "";
+  return name === "AbortError";
+}
+function isTaskError(err) {
+  return typeof err === "object" && err !== null && "task" in err && "error" in err;
+}
+async function waitForAny(tasks) {
+  const list = Array.from(tasks);
+  if (list.length === 0) {
+    throw new Error("waitForAny called with no tasks");
+  }
+  return Promise.race(
+    list.map(
+      (task) => task.then(
+        () => ({ task }),
+        (error) => {
+          const taskError = { task, error };
+          throw taskError;
+        }
+      )
+    )
+  );
+}
+function mergeAbortSignals(...signals) {
+  const active = signals.filter(Boolean);
+  if (active.length === 0) {
+    return void 0;
+  }
+  if (active.length === 1) {
+    return active[0];
+  }
+  const controller = new AbortController();
+  const onAbort = () => {
+    controller.abort();
+  };
+  for (const signal of active) {
+    if (signal.aborted) {
+      controller.abort();
+      break;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+function cloneStepResult(res) {
+  return {
+    ...res,
+    error: res.error ? { ...res.error } : void 0,
+    startedAt: res.startedAt ? new Date(res.startedAt) : void 0,
+    finishedAt: res.finishedAt ? new Date(res.finishedAt) : void 0
+  };
+}
+
+// src/errors.ts
+var ExecutionError = class _ExecutionError extends Error {
+  executionId;
+  status;
+  errors;
+  constructor(params) {
+    const { executionId, status, errors } = params;
+    const prefix = `Execution ${executionId} ended with status ${status}`;
+    const detail = errors.length > 0 ? `${errors[0].type ?? "Error"}: ${errors[0].message}` : "";
+    super(detail ? `${prefix}: ${detail}` : prefix);
+    this.executionId = executionId;
+    this.status = status;
+    this.errors = errors;
+  }
+  static fromState(state) {
+    const errors = [];
+    for (const result of state.steps.values()) {
+      if (result.error) {
+        errors.push(result.error);
+      } else if (result.status === StepStatus.BLOCKED || result.status === StepStatus.CANCELLED) {
+        errors.push({
+          message: `step ${result.stepId} ended with status ${result.status}`,
+          type: "ExecutionStatus"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      errors.push({ message: "execution failed without detailed errors", type: "ExecutionError" });
+    }
+    return new _ExecutionError({
+      executionId: state.executionId,
+      status: state.status,
+      errors
+    });
+  }
+};
+function raiseIfFailed(state) {
+  if (state.status !== ExecutionStatus.COMPLETED) {
+    throw ExecutionError.fromState(state);
+  }
+}
+
+// src/planning.ts
+var PlanBuilder = class {
+  steps = /* @__PURE__ */ new Map();
+  addStep(params) {
+    const { id, action, deps, payload } = params;
+    if (this.steps.has(id)) {
+      throw new Error(`step id '${id}' already exists in plan`);
+    }
+    const depsList = deps ? Array.from(deps) : [];
+    const step = {
+      id,
+      action,
+      deps: depsList,
+      payload
+    };
+    this.steps.set(id, step);
+    return this;
+  }
+  addStepObj(step) {
+    StepSchema.parse(step);
+    if (this.steps.has(step.id)) {
+      throw new Error(`step id '${step.id}' already exists in plan`);
+    }
+    this.steps.set(step.id, step);
+    return this;
+  }
+  build() {
+    const stepsCopy = new Map(this.steps);
+    this.validateDependencies(stepsCopy);
+    this.validateAcyclic(stepsCopy);
+    return new Plan(stepsCopy);
+  }
+  validateDependencies(steps) {
+    const ids = new Set(steps.keys());
+    for (const step of steps.values()) {
+      for (const dep of step.deps) {
+        if (!ids.has(dep)) {
+          throw new Error(`step '${step.id}' depends on unknown step '${dep}'`);
+        }
+        if (dep === step.id) {
+          throw new Error(`step '${step.id}' cannot depend on itself`);
+        }
+      }
+    }
+  }
+  validateAcyclic(steps) {
+    const cycle = findCycle(steps);
+    if (cycle) {
+      throw new Error(`cycle detected in plan: ${cycle.join(" -> ")}`);
+    }
+  }
+};
+function findCycle(steps) {
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const visit = (node) => {
+    const current = state.get(node);
+    if (current === "visiting") {
+      const idx = stack.indexOf(node);
+      return idx >= 0 ? stack.slice(idx).concat(node) : [node, node];
+    }
+    if (current === "visited") {
+      return null;
+    }
+    state.set(node, "visiting");
+    stack.push(node);
+    const step = steps.get(node);
+    if (step) {
+      for (const dep of step.deps) {
+        const cycle = visit(dep);
+        if (cycle) {
+          return cycle;
+        }
+      }
+    }
+    stack.pop();
+    state.set(node, "visited");
+    return null;
+  };
+  for (const id of steps.keys()) {
+    if (!state.has(id)) {
+      const cycle = visit(id);
+      if (cycle) {
+        return cycle;
+      }
+    }
+  }
+  return null;
+}
+
+// src/observers.ts
+var ObserverFailurePolicy = {
+  LENIENT: "lenient",
+  STRICT: "strict"
+};
+async function callObserverErrorHandler(handler, observer, event, error) {
+  if (!handler) {
+    return;
+  }
+  await handler(observer, event, error);
+}
+function composeObservers(observers, options = {}) {
+  const list = Array.from(observers);
+  const failurePolicy = options.failurePolicy ?? ObserverFailurePolicy.LENIENT;
+  return async (event) => {
+    for (const obs of list) {
+      try {
+        await obs.onEvent(event);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        await callObserverErrorHandler(options.onError, obs, event, error);
+        if (failurePolicy === ObserverFailurePolicy.STRICT) {
+          throw error;
+        }
+      }
+    }
+  };
+}
+function composeObserversParallel(observers, options = {}) {
+  const list = Array.from(observers);
+  const failurePolicy = options.failurePolicy ?? ObserverFailurePolicy.LENIENT;
+  return async (event) => {
+    const results = await Promise.allSettled(list.map((obs) => obs.onEvent(event)));
+    const errors = [];
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+        errors.push({ observer: list[index], error });
+      }
+    });
+    if (errors.length === 0) {
+      return;
+    }
+    for (const entry of errors) {
+      await callObserverErrorHandler(options.onError, entry.observer, event, entry.error);
+    }
+    if (failurePolicy === ObserverFailurePolicy.STRICT) {
+      throw errors[0].error;
+    }
+  };
+}
+var OverflowPolicy = {
+  BLOCK: "block",
+  DROP_NEW: "drop_new",
+  DROP_OLDEST: "drop_oldest"
+};
+var BufferedObserver = class {
+  maxQueueSize;
+  overflowPolicy;
+  onError;
+  queue;
+  task = null;
+  started = false;
+  abortController = null;
+  dropped = 0;
+  failed = false;
+  lastError = null;
+  constructor(params = {}) {
+    this.maxQueueSize = params.maxQueueSize ?? 1e3;
+    this.overflowPolicy = params.overflowPolicy ?? OverflowPolicy.BLOCK;
+    this.onError = params.onError;
+    this.queue = new AsyncQueue(this.maxQueueSize);
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    this.abortController = new AbortController();
+    this.task = this.run(this.abortController.signal);
+  }
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    this.started = false;
+    this.abortController?.abort();
+    if (this.task) {
+      try {
+        await this.task;
+      } catch {
+      }
+    }
+  }
+  async onEvent(event) {
+    if (this.failed) {
+      if (this.lastError) {
+        throw this.lastError;
+      }
+      throw new Error("buffered observer worker has failed");
+    }
+    if (!this.started) {
+      await this.process(event);
+      return;
+    }
+    if (this.overflowPolicy === OverflowPolicy.BLOCK) {
+      await this.queue.put(event);
+      return;
+    }
+    if (this.queue.tryPut(event)) {
+      return;
+    }
+    this.dropped += 1;
+    if (this.overflowPolicy === OverflowPolicy.DROP_NEW) {
+      return;
+    }
+    if (this.overflowPolicy === OverflowPolicy.DROP_OLDEST) {
+      this.queue.shift();
+      if (!this.queue.tryPut(event)) {
+        return;
+      }
+    }
+  }
+  async run(signal) {
+    while (!signal.aborted) {
+      let event;
+      try {
+        event = await this.queue.get(signal);
+      } catch (err) {
+        if (isAbortError2(err)) {
+          break;
+        }
+        throw err;
+      }
+      try {
+        await this.process(event);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.failed = true;
+        this.lastError = error;
+        if (this.onError) {
+          await this.onError(event, error);
+        }
+        break;
+      }
+    }
+  }
+};
+function isAbortError2(err) {
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  const name = "name" in err ? String(err.name) : "";
+  return name === "AbortError";
+}
+
+// src/usage.ts
+var Usage = class _Usage {
+  provider;
+  model;
+  metrics;
+  constructor(params = {}) {
+    this.provider = params.provider;
+    this.model = params.model;
+    this.metrics = { ...params.metrics ?? {} };
+  }
+  add(other) {
+    const provider = this.provider === other.provider ? this.provider : void 0;
+    const model = this.model === other.model ? this.model : void 0;
+    const merged = { ...this.metrics };
+    for (const [key, value] of Object.entries(other.metrics)) {
+      merged[key] = (merged[key] ?? 0) + Number(value);
+    }
+    return new _Usage({ provider, model, metrics: merged });
+  }
+};
+function aggregateUsage(state, extract) {
+  let total = new Usage();
+  let first = true;
+  for (const res of state.steps.values()) {
+    const usage = extract(res);
+    if (!usage) {
+      continue;
+    }
+    if (first) {
+      total = usage;
+      first = false;
+    } else {
+      total = total.add(usage);
+    }
+  }
+  return total;
+}
+function estimateCost(usage, rules) {
+  const costs = {};
+  for (const rule of rules) {
+    const value = Number(usage.metrics[rule.metric] ?? 0);
+    if (!value) {
+      continue;
+    }
+    const scale = rule.scale ?? 1;
+    const cost = value / scale * rule.perUnit;
+    costs[rule.metric] = (costs[rule.metric] ?? 0) + cost;
+  }
+  const total = Object.values(costs).reduce((sum, value) => sum + value, 0);
+  return { byMetric: costs, total };
+}
+
+// src/runner.ts
+var TaskOutput = class {
+  value;
+  usage;
+  meta;
+  constructor(params) {
+    this.value = params.value;
+    this.usage = params.usage;
+    this.meta = params.meta ?? {};
+  }
+};
+function defaultUsageExtractor(res) {
+  const out = res.output;
+  if (out instanceof TaskOutput) {
+    return out.usage;
+  }
+  return void 0;
+}
+async function runPlan(plan, handlers, options = {}) {
+  const execImpl = options.executor ?? new DagExecutor();
+  const state = await execImpl.executeAsync(plan, handlers);
+  if (options.failOnError ?? true) {
+    raiseIfFailed(state);
+  }
+  let usage;
+  let costs;
+  const extractor = options.usageExtractor === void 0 ? defaultUsageExtractor : options.usageExtractor;
+  if (extractor) {
+    const aggregated = aggregateUsage(state, extractor);
+    if (!aggregated.provider && !aggregated.model && Object.keys(aggregated.metrics).length === 0) {
+      usage = void 0;
+    } else {
+      usage = aggregated;
+    }
+  }
+  if (usage && options.pricingRules && options.pricingRules.length > 0) {
+    costs = estimateCost(usage, options.pricingRules);
+  }
+  return [state, usage, costs];
+}
+
+exports.BufferedObserver = BufferedObserver;
+exports.DagExecutor = DagExecutor;
+exports.ErrorInfoSchema = ErrorInfoSchema;
+exports.ExecutionCancelledSchema = ExecutionCancelledSchema;
+exports.ExecutionCompletedSchema = ExecutionCompletedSchema;
+exports.ExecutionError = ExecutionError;
+exports.ExecutionEventSchema = ExecutionEventSchema;
+exports.ExecutionEventTypeSchema = ExecutionEventTypeSchema;
+exports.ExecutionStartedSchema = ExecutionStartedSchema;
+exports.ExecutionStateSchema = ExecutionStateSchema;
+exports.ExecutionStatus = ExecutionStatus;
+exports.ExecutionStatusSchema = ExecutionStatusSchema;
+exports.ObserverFailurePolicy = ObserverFailurePolicy;
+exports.OverflowPolicy = OverflowPolicy;
+exports.Plan = Plan;
+exports.PlanBuilder = PlanBuilder;
+exports.PlanSchema = PlanSchema;
+exports.StepBlockedSchema = StepBlockedSchema;
+exports.StepCancelledSchema = StepCancelledSchema;
+exports.StepCompletedSchema = StepCompletedSchema;
+exports.StepContext = StepContext;
+exports.StepFailedSchema = StepFailedSchema;
+exports.StepResultSchema = StepResultSchema;
+exports.StepScheduledSchema = StepScheduledSchema;
+exports.StepSchema = StepSchema;
+exports.StepStartedSchema = StepStartedSchema;
+exports.StepStatus = StepStatus;
+exports.StepStatusSchema = StepStatusSchema;
+exports.TaskOutput = TaskOutput;
+exports.Usage = Usage;
+exports.aggregateUsage = aggregateUsage;
+exports.composeObservers = composeObservers;
+exports.composeObserversParallel = composeObserversParallel;
+exports.defaultUsageExtractor = defaultUsageExtractor;
+exports.estimateCost = estimateCost;
+exports.raiseIfFailed = raiseIfFailed;
+exports.runPlan = runPlan;
+exports.utcNow = utcNow;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map