@anvia/durable 0.0.0-bootstrap.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1930 @@
+import {
+  parseTaskSubmission
+} from "./chunk-ETGANBD4.js";
+import {
+  errorMessage,
+  graphListSchema,
+  json,
+  listOptionsSchema,
+  modelRetrySchema,
+  nonblank,
+  parseDurableGraphSubmission,
+  sameJson,
+  taskListSchema,
+  taskWaitSchema
+} from "./chunk-KIMHK6CE.js";
+
+// src/errors.ts
+var DurableRecoveryError = class extends Error {
+  constructor(message, operationId) {
+    super(message);
+    this.operationId = operationId;
+    this.name = "DurableRecoveryError";
+  }
+  operationId;
+};
+var DurableRunError = class extends Error {
+  constructor(runId, status, message) {
+    super(message);
+    this.runId = runId;
+    this.status = status;
+    this.name = "DurableRunError";
+  }
+  runId;
+  status;
+};
+var DurableNotFoundError = class extends Error {
+};
+var DurableConflictError = class extends Error {
+};
+var DurableModelError = class extends Error {
+  constructor(operationId, attempts, cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.operationId = operationId;
+    this.attempts = attempts;
+  }
+  operationId;
+  attempts;
+};
+var DurableStorageError = class extends Error {
+};
+var DurableLimitError = class extends Error {
+};
+
+// src/limits.ts
+function durableLimits(input = {}) {
+  const limits = {
+    maxPendingRuns: 1e4,
+    maxPendingTasks: 1e4,
+    maxPayloadBytes: 1048576,
+    maxOperations: 1e4,
+    ...input
+  };
+  for (const [name, value] of Object.entries(limits))
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new TypeError(`Invalid durable limit: ${name}`);
+  return limits;
+}
+function limitedTransaction(tx, limits) {
+  const payload = (value) => {
+    if (value !== void 0 && new TextEncoder().encode(JSON.stringify(value)).byteLength > limits.maxPayloadBytes)
+      throw new DurableLimitError("Durable payload byte limit exceeded.");
+  };
+  const terminal2 = (status) => ["completed", "failed", "cancelled"].includes(status);
+  return {
+    ...tx,
+    putRun(run) {
+      const previous = tx.getRun(run.id);
+      if (!terminal2(run.status) && (previous === void 0 || terminal2(previous.status)) && tx.pendingCounts().runs >= limits.maxPendingRuns)
+        throw new DurableLimitError("Pending durable run limit reached.");
+      if (previous === void 0) payload(run.prompt);
+      for (const key of ["input", "history", "responses", "outcome"])
+        if (JSON.stringify(previous?.[key]) !== JSON.stringify(run[key])) payload(run[key]);
+      tx.putRun(run);
+    },
+    putTask(task) {
+      const previous = tx.getTask(task.id);
+      if (!terminal2(task.status) && (previous === void 0 || terminal2(previous.status)) && tx.pendingCounts().tasks >= limits.maxPendingTasks)
+        throw new DurableLimitError("Pending durable task limit reached.");
+      for (const key of ["input", "checkpoint", "signals"])
+        if (JSON.stringify(previous?.[key]) !== JSON.stringify(task[key])) payload(task[key]);
+      if (task.agentRunId === void 0 && task.outcome?.status === "completed" && JSON.stringify(previous?.outcome) !== JSON.stringify(task.outcome))
+        payload(task.outcome.output);
+      tx.putTask(task);
+    },
+    putOperation(id, operation) {
+      const previous = tx.getOperation(id, operation.key);
+      if (previous === void 0 && tx.operationCount(id) >= limits.maxOperations)
+        throw new DurableLimitError("Durable operation count limit reached.");
+      if (JSON.stringify(previous?.input) !== JSON.stringify(operation.input))
+        payload(operation.input);
+      if (JSON.stringify(previous?.result) !== JSON.stringify(operation.result))
+        payload(operation.result);
+      tx.putOperation(id, operation);
+    }
+  };
+}
+
+// src/storage-guard.ts
+function guardStore(store, onFailure, limits) {
+  let failure;
+  const fail = (cause) => {
+    if (failure === void 0) {
+      failure = new DurableStorageError("Durable storage failed; close and reopen the runtime.", {
+        cause
+      });
+      onFailure(failure);
+    }
+    return failure;
+  };
+  const check = () => {
+    if (failure !== void 0) throw failure;
+  };
+  const transaction = (callback) => {
+    check();
+    let callbackFailed = false;
+    let callbackError;
+    try {
+      return store.transaction((tx) => {
+        const guarded = new Proxy(tx, {
+          get(target, key) {
+            const method = Reflect.get(target, key);
+            if (typeof method !== "function") return method;
+            return (...args) => {
+              check();
+              try {
+                return Reflect.apply(method, target, args);
+              } catch (error) {
+                throw fail(error);
+              }
+            };
+          }
+        });
+        try {
+          const result = callback(limitedTransaction(guarded, limits));
+          check();
+          return result;
+        } catch (error) {
+          callbackFailed = true;
+          callbackError = error;
+          throw error;
+        }
+      });
+    } catch (error) {
+      if (!callbackFailed || error !== callbackError) throw fail(error);
+      throw failure ?? error;
+    }
+  };
+  return new Proxy(store, {
+    get(target, key) {
+      if (key === "transaction") return transaction;
+      const method = Reflect.get(target, key);
+      if (typeof method !== "function") return method;
+      if (key === "close") return method.bind(target);
+      return (...args) => {
+        check();
+        try {
+          return Reflect.apply(method, target, args);
+        } catch (error) {
+          throw fail(error);
+        }
+      };
+    }
+  });
+}
+
+// src/wait.ts
+function delay(signal) {
+  return new Promise((resolve, reject) => {
+    signal?.throwIfAborted();
+    const done = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const timer = setTimeout(done, 25);
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+// src/task-graph.ts
+var DurableTaskGraph = class {
+  constructor(id, runtime) {
+    this.id = id;
+    this.runtime = runtime;
+  }
+  id;
+  runtime;
+  async snapshot() {
+    return this.runtime.graphSnapshot(this.id);
+  }
+  async cancel() {
+    this.runtime.cancelGraph(this.id);
+  }
+  async *stream(options = {}) {
+    let cursor = options.after ?? 0;
+    const initial = await this.snapshot();
+    if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > initial.cursor)
+      throw new TypeError("Invalid graph event cursor.");
+    const taskIds = new Map(initial.nodes.map((node) => [node.runId, node.id]));
+    while (true) {
+      options.abortSignal?.throwIfAborted();
+      const events = this.runtime.graphEvents(this.id, cursor);
+      for (const event of events) {
+        options.abortSignal?.throwIfAborted();
+        const taskId = taskIds.get(event.runId);
+        if (taskId === void 0) throw new Error("Graph event belongs to an unknown task.");
+        cursor = event.sequence;
+        yield { ...event, graphId: this.id, taskId };
+      }
+      if (events.length > 0) continue;
+      const snapshot = await this.snapshot();
+      if (snapshot.status === "completed" || snapshot.status === "cancelled") return;
+      await delay(options.abortSignal);
+    }
+  }
+};
+
+// src/tasks/state.ts
+function taskKey(value) {
+  nonblank(value, "Task key");
+  if (value.length > 256 || value !== value.trim())
+    throw new TypeError("Task keys must be trimmed and at most 256 characters.");
+  if (value === "__proto__") throw new TypeError("Reserved task key.");
+}
+function requireTask(tx, id) {
+  const task = tx.getTask(id);
+  if (task === void 0) throw new DurableNotFoundError(`Unknown durable task: ${id}`);
+  return task;
+}
+function terminal(task) {
+  return ["completed", "failed", "cancelled"].includes(task.status);
+}
+function saveTask(tx, task) {
+  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  tx.putTask(task);
+  tx.appendEvent(
+    task.id,
+    "status",
+    json({
+      status: task.status,
+      wait: task.wait,
+      outcome: task.outcome,
+      error: task.error,
+      blockedOperation: task.blockedOperation
+    })
+  );
+}
+function createTask(tx, definition, input, sessionId, key, parentId) {
+  taskKey(key);
+  taskKey(sessionId);
+  let parsed;
+  try {
+    parsed = definition.parseInput(input);
+  } catch (cause) {
+    if (cause instanceof TypeError) throw cause;
+    throw new TypeError("Invalid task input.", { cause });
+  }
+  const parent = parentId === void 0 ? void 0 : requireTask(tx, parentId);
+  if (parent !== void 0 && parent.status !== "running")
+    throw new DurableConflictError("Parent task is no longer running.");
+  const existing = tx.findTask(sessionId, parentId, key);
+  if (existing !== void 0) {
+    if (existing.name !== definition.name || existing.submissionVersion !== definition.version || !sameJson(existing.submissionInput, parsed))
+      throw new DurableConflictError("Task key already belongs to a different submission.");
+    return existing;
+  }
+  if (parent !== void 0 && (parent.depth >= 32 || tx.taskTree(parent.rootId).length >= 1e3))
+    throw new DurableConflictError("Task trees support at most 1000 nodes and depth 32.");
+  const id = globalThis.crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const task = {
+    id,
+    rootId: parent?.rootId ?? id,
+    ...parentId === void 0 ? {} : { parentId },
+    depth: parent === void 0 ? 0 : parent.depth + 1,
+    sessionId,
+    key,
+    name: definition.name,
+    version: definition.version,
+    submissionVersion: definition.version,
+    submissionInput: parsed,
+    input: parsed,
+    checkpoint: definition.initial(parsed),
+    status: "pending",
+    signals: {},
+    createdAt: now,
+    updatedAt: now
+  };
+  tx.putTask(task);
+  tx.appendEvent(id, "submitted", json({ name: task.name, parentId, rootId: task.rootId }));
+  return task;
+}
+function cancelTree(tx, id, error) {
+  const ids = [];
+  const pending = [requireTask(tx, id)];
+  for (const task of pending) {
+    if (terminal(task)) continue;
+    ids.push(task.id);
+    pending.push(...tx.taskChildren(task.id));
+    task.status = "cancelling";
+    task.outcome = { status: "cancelled", error };
+    if (task.agentRunId !== void 0) {
+      const run = tx.getRun(task.agentRunId);
+      if (!["completed", "failed", "cancelled"].includes(run.status)) {
+        run.status = "cancelled";
+        run.error = error;
+        run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        delete run.nextAttemptAt;
+        tx.putRun(run);
+        tx.appendEvent(run.id, "status", { status: "cancelled", error });
+      }
+    }
+    delete task.wait;
+    delete task.error;
+    delete task.blockedOperation;
+    saveTask(tx, task);
+  }
+  return ids;
+}
+function reconcileTree(tx, rootId, active, agentActive) {
+  const abort = [];
+  let deadline;
+  const nodes = tx.taskTree(rootId).reverse();
+  for (const node of nodes) {
+    const task = requireTask(tx, node.id);
+    if (terminal(task)) continue;
+    if (task.status === "waiting") {
+      const wait = task.wait;
+      let ready = false;
+      if (wait.type === "children") {
+        const children = wait.ids.map((id) => requireTask(tx, id));
+        if (wait.policy === "failFast" && children.some((child) => terminal(child) && child.status !== "completed")) {
+          for (const child of children)
+            if (!terminal(child) && child.status !== "cancelling")
+              abort.push(...cancelTree(tx, child.id, "Sibling task failed."));
+        }
+        ready = children.every(terminal);
+      } else if (wait.type === "agent") {
+        const run = tx.getRun(wait.runId);
+        if (run === void 0) throw new Error("Owned agent run is missing.");
+        if (wait.status !== run.status) {
+          wait.status = run.status;
+          saveTask(tx, task);
+        }
+        if (["completed", "failed", "cancelled"].includes(run.status)) {
+          task.outcome = run.status === "completed" && run.outcome?.type === "response" ? { status: "completed", output: json(run.outcome.output) } : {
+            status: run.status === "cancelled" ? "cancelled" : "failed",
+            error: run.error ?? "Agent did not return a successful response."
+          };
+          task.status = "completing";
+          delete task.wait;
+          saveTask(tx, task);
+        }
+      } else if (wait.type === "signal") ready = Object.hasOwn(task.signals, wait.name);
+      else {
+        const until = Date.parse(wait.until);
+        ready = until <= Date.now();
+        if (!ready) deadline = Math.min(deadline ?? Infinity, until);
+      }
+      if (ready) {
+        task.status = "pending";
+        delete task.wait;
+        saveTask(tx, task);
+      }
+    }
+    if (["completing", "cancelling"].includes(task.status) && !active.has(task.id) && (task.agentRunId === void 0 || !agentActive(task.agentRunId)) && tx.taskChildren(task.id).every(terminal)) {
+      task.status = task.outcome.status;
+      saveTask(tx, task);
+    }
+  }
+  return { abort, ...deadline === void 0 ? {} : { deadline } };
+}
+
+// src/tasks/invocation.ts
+function taskInvocation(store, task, definitions, controller, changed, spawnAgent2) {
+  let open = true;
+  let fatal;
+  const transaction = (callback) => {
+    try {
+      return store.transaction(callback);
+    } catch (error) {
+      if (error instanceof DurableStorageError) fatal = error;
+      throw error;
+    }
+  };
+  const effects = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  const assertActive = () => {
+    if (fatal !== void 0) throw fatal;
+    controller.signal.throwIfAborted();
+    if (!open) throw new DurableConflictError("Task invocation has finished.");
+    transaction((tx) => {
+      if (requireTask(tx, task.id).status !== "running")
+        throw new DurableConflictError("Task is no longer running.");
+    });
+  };
+  const effect = async (key, input, execute, recovery = "manual") => {
+    assertActive();
+    taskKey(key);
+    if (!["manual", "safe", "idempotent"].includes(recovery))
+      throw new TypeError("Invalid effect recovery policy.");
+    if (keys.has(key))
+      throw new DurableConflictError("Concurrent use of one effect key is not allowed.");
+    keys.add(key);
+    try {
+      const saved = transaction((tx) => {
+        const existing = tx.getOperation(task.id, key);
+        if (existing !== void 0) {
+          if (!sameJson(existing.input, input) || existing.recovery !== recovery)
+            throw new DurableRecoveryError("Effect input or recovery policy changed.", key);
+          return existing;
+        }
+        const operation = {
+          key,
+          kind: "effect",
+          input: json(input),
+          status: "started",
+          recovery
+        };
+        tx.putOperation(task.id, operation);
+        return void 0;
+      });
+      if (saved?.status === "completed") return json(saved.result);
+      if (saved?.recovery === "manual")
+        throw new DurableRecoveryError("Effect requires external reconciliation.", key);
+      const output = await execute(`${task.id}/${key}`, controller.signal);
+      let result;
+      try {
+        result = json(output);
+      } catch {
+        throw new DurableRecoveryError(
+          "Effect returned non-JSON output; reconcile its external result.",
+          key
+        );
+      }
+      assertActive();
+      try {
+        transaction((tx) => {
+          const operation = tx.getOperation(task.id, key);
+          tx.putOperation(task.id, { ...operation, status: "completed", result });
+        });
+      } catch (error) {
+        if (error instanceof DurableLimitError)
+          throw new DurableRecoveryError(
+            "Effect result exceeds the payload limit; reconcile its external result.",
+            key
+          );
+        throw error;
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof DurableRecoveryError) fatal ??= error;
+      throw error;
+    } finally {
+      keys.delete(key);
+    }
+  };
+  const context = {
+    id: task.id,
+    input: json(task.input),
+    checkpoint: json(task.checkpoint),
+    signal: controller.signal,
+    spawn: (key, definition, input) => {
+      assertActive();
+      const registered = definitions.get(definition.name);
+      if (registered === void 0 || registered.version !== definition.version)
+        throw new DurableRecoveryError(`Task definition is not registered: ${definition.name}`);
+      const child = transaction(
+        (tx) => createTask(tx, registered, input, task.sessionId, key, task.id)
+      );
+      changed();
+      return child.id;
+    },
+    spawnAgent: (key, input) => {
+      assertActive();
+      const id = transaction((tx) => spawnAgent2(tx, task, key, input));
+      changed();
+      return id;
+    },
+    children: () => {
+      assertActive();
+      return transaction((tx) => tx.taskChildren(task.id));
+    },
+    signalValue: (name) => {
+      assertActive();
+      const signals = transaction((tx) => requireTask(tx, task.id).signals);
+      return Object.hasOwn(signals, name) ? json(signals[name].value) : void 0;
+    },
+    effect: (key, input, execute, recovery) => {
+      const pending = effect(key, input, execute, recovery);
+      effects.add(pending);
+      void pending.then(
+        () => effects.delete(pending),
+        () => effects.delete(pending)
+      );
+      return pending;
+    }
+  };
+  return {
+    context,
+    async finish() {
+      open = false;
+      if (effects.size > 0) {
+        controller.abort(new Error("Task returned before its effects settled."));
+        await Promise.allSettled(effects);
+        if (fatal !== void 0) throw fatal;
+        throw new Error("Task returned before its effects settled.");
+      }
+      if (fatal !== void 0) throw fatal;
+    }
+  };
+}
+
+// src/tasks/agent.ts
+import { z } from "zod";
+import { isJsonValue } from "@anvia/core/completion";
+
+// src/run-record.ts
+import { Usage } from "@anvia/core/completion";
+var GRAPH_SESSION_PREFIX = "__anvia_graph__:";
+function createRunRecord(submission, registration) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...submission,
+    id: globalThis.crypto.randomUUID(),
+    version: registration.version,
+    status: "queued",
+    createdAt: now,
+    updatedAt: now,
+    epoch: 0,
+    modelTurns: 0,
+    maxModelTurns: (registration.agent.defaultMaxTurns ?? 0) + 1,
+    usage: Usage.empty(),
+    history: [],
+    responses: {},
+    ...registration.modelRetry === void 0 ? {} : { modelRetry: { ...registration.modelRetry } },
+    input: { messages: [{ role: "user", content: submission.prompt }] }
+  };
+}
+
+// src/tasks/definition.ts
+function defineTask(definition) {
+  return { ...definition, registration: registerTask(definition) };
+}
+function registerTask(task) {
+  nonblank(task.name, "Task name");
+  taskKey(task.name);
+  if (!Number.isSafeInteger(task.version) || task.version < 1)
+    throw new TypeError("Task version must be a positive integer.");
+  const parse = (schema, value) => {
+    const result = json(schema.parse(json(value)));
+    if (!sameJson(result, schema.parse(json(result))))
+      throw new TypeError("Task schemas must round-trip persisted JSON without changing it.");
+    return result;
+  };
+  const input = (value) => parse(task.input, value);
+  const checkpoint = (value) => parse(task.checkpoint, value);
+  return {
+    name: task.name,
+    version: task.version,
+    parseInput: input,
+    parseCheckpoint: checkpoint,
+    parseOutput: (value) => parse(task.output, value),
+    initial: (value) => checkpoint(task.initial(value)),
+    // Both values came through the registered schemas before this invocation.
+    run: async (context) => await task.run(context),
+    ...task.migrate === void 0 ? {} : {
+      migrate: (value, state, version) => {
+        const result = task.migrate(value, state, version);
+        return { input: input(result.input), checkpoint: checkpoint(result.checkpoint) };
+      }
+    }
+  };
+}
+
+// src/tasks/agent.ts
+var TASK_SESSION_PREFIX = "__anvia_task__:";
+var agentTask = defineTask({
+  name: "anvia.agent",
+  version: 1,
+  input: z.object({ agentId: z.string().min(1), prompt: z.string().min(1) }).strict(),
+  checkpoint: z.null(),
+  output: z.custom(isJsonValue),
+  initial: () => null,
+  run: async () => {
+    throw new Error("Agent task is advanced by its owned run.");
+  }
+});
+function spawnAgent(tx, agents, parent, key, input) {
+  const registration = agents.get(input.agentId);
+  if (registration === void 0)
+    throw new DurableNotFoundError(`Unknown durable agent: ${input.agentId}`);
+  const child = createTask(tx, agentTask.registration, input, parent.sessionId, key, parent.id);
+  if (child.agentRunId !== void 0) return child.id;
+  const run = createRunRecord(
+    {
+      agentId: input.agentId,
+      prompt: input.prompt,
+      sessionId: `${TASK_SESSION_PREFIX}${child.id}`,
+      requestId: child.id
+    },
+    registration
+  );
+  tx.putRun(run);
+  tx.appendEvent(run.id, "submitted", json({ taskId: child.id, prompt: input.prompt }));
+  child.agentRunId = run.id;
+  child.status = "waiting";
+  child.wait = { type: "agent", runId: run.id, status: run.status };
+  saveTask(tx, child);
+  return child.id;
+}
+
+// src/tasks/scheduler.ts
+var TaskScheduler = class {
+  constructor(store, definitions, capacity, fatal, agents, agentActive, syncAgents) {
+    this.store = store;
+    this.definitions = definitions;
+    this.capacity = capacity;
+    this.fatal = fatal;
+    this.agents = agents;
+    this.agentActive = agentActive;
+    this.syncAgents = syncAgents;
+  }
+  store;
+  definitions;
+  capacity;
+  fatal;
+  agents;
+  agentActive;
+  syncAgents;
+  active = /* @__PURE__ */ new Map();
+  deadlines = /* @__PURE__ */ new Map();
+  timer;
+  closing = false;
+  get activeCount() {
+    return this.active.size;
+  }
+  agentChanged(id) {
+    if (this.closing) return;
+    this.reconcile(this.snapshot(id).task.rootId);
+    this.pump();
+  }
+  submit(name, version, input, sessionId, key) {
+    const definition = this.definitions.get(name);
+    if (definition === void 0 || definition.version !== version)
+      throw new DurableConflictError(`Task definition/version is not registered: ${name}`);
+    const task = this.store.transaction((tx) => createTask(tx, definition, input, sessionId, key));
+    this.pump();
+    return task.id;
+  }
+  resume() {
+    let cursor = 0;
+    while (cursor !== void 0) {
+      const page = this.store.unsettledTaskRoots(cursor);
+      for (const root of page.ids) this.reconcile(root);
+      cursor = page.cursor;
+    }
+    this.pump();
+  }
+  stop(reason) {
+    this.closing = true;
+    clearTimeout(this.timer);
+    for (const invocation of this.active.values()) invocation.controller.abort(reason);
+  }
+  async close() {
+    this.stop(new Error("Durable runtime closed."));
+    await Promise.all([...this.active.values()].map((value) => value.promise));
+  }
+  snapshot(id) {
+    return this.store.transaction((tx) => ({
+      task: requireTask(tx, id),
+      operations: tx.operations(id),
+      cursor: tx.cursor()
+    }));
+  }
+  graph(id) {
+    return this.store.transaction((tx) => {
+      const rootId = requireTask(tx, id).rootId;
+      const nodes = tx.taskTree(rootId);
+      const edges = [];
+      for (const task of nodes) {
+        if (task.parentId !== void 0)
+          edges.push({ source: task.parentId, target: task.id, type: "owns" });
+        if (task.wait?.type === "children")
+          for (const child of task.wait.ids)
+            edges.push({ source: task.id, target: child, type: "waits" });
+      }
+      return { rootId, nodes, edges, cursor: tx.cursor() };
+    });
+  }
+  cancel(id, expectedTreeIds) {
+    const root = this.snapshot(id).task.rootId;
+    const ids = this.store.transaction((tx) => {
+      if (expectedTreeIds !== void 0) {
+        const current = tx.taskTree(root);
+        const expected = new Set(expectedTreeIds);
+        if (current.length !== expected.size || current.some((task) => !expected.has(task.id)))
+          throw new DurableConflictError(
+            "Task tree changed during authorization; retry cancellation."
+          );
+      }
+      return cancelTree(tx, id, "Durable task cancelled.");
+    });
+    for (const task of ids)
+      this.active.get(task)?.controller.abort(new Error("Durable task cancelled."));
+    this.reconcile(root);
+    this.pump();
+  }
+  signal(id, name, requestId, value) {
+    taskKey(name);
+    taskKey(requestId);
+    const root = this.store.transaction((tx) => {
+      const task = requireTask(tx, id);
+      if (Object.hasOwn(task.signals, name)) {
+        if (!sameJson(task.signals[name], { requestId, value: json(value) }))
+          throw new DurableConflictError("Signal already has a different delivery.");
+        return task.rootId;
+      }
+      if (terminal(task) || ["completing", "cancelling"].includes(task.status))
+        throw new DurableConflictError("Task cannot receive a signal.");
+      if (Object.keys(task.signals).length >= 1e3)
+        throw new DurableConflictError("Task signal limit reached.");
+      Object.defineProperty(task.signals, name, {
+        value: { requestId, value: json(value) },
+        enumerable: true
+      });
+      saveTask(tx, task);
+      return task.rootId;
+    });
+    this.reconcile(root);
+    this.pump();
+  }
+  retry(id) {
+    if (this.active.has(id)) throw new DurableConflictError("Task invocation is still settling.");
+    this.store.transaction((tx) => {
+      const task = requireTask(tx, id);
+      if (task.status !== "needs_attention")
+        throw new DurableConflictError(
+          "Only tasks needing attention can resume; terminal outcomes are immutable."
+        );
+      delete task.error;
+      delete task.blockedOperation;
+      task.status = "pending";
+      saveTask(tx, task);
+    });
+    this.pump();
+  }
+  resolveEffect(id, key, value) {
+    if (this.active.has(id)) throw new DurableConflictError("Task invocation is still settling.");
+    this.store.transaction((tx) => {
+      const task = requireTask(tx, id);
+      const operation = tx.getOperation(id, key);
+      if (task.status !== "needs_attention" || task.blockedOperation !== key || operation?.status !== "started" || operation.kind !== "effect")
+        throw new DurableConflictError("No matching effect awaiting reconciliation.");
+      tx.putOperation(id, { ...operation, status: "completed", result: json(value) });
+      task.status = "pending";
+      delete task.blockedOperation;
+      delete task.error;
+      saveTask(tx, task);
+    });
+    this.pump();
+  }
+  reconcile(root) {
+    for (let pass = 0; pass < 2; pass++) {
+      const result = this.store.transaction(
+        (tx) => reconcileTree(tx, root, new Set(this.active.keys()), this.agentActive)
+      );
+      for (const id of result.abort)
+        this.active.get(id)?.controller.abort(new Error("Sibling task failed."));
+      if (result.deadline === void 0) this.deadlines.delete(root);
+      else this.deadlines.set(root, result.deadline);
+    }
+    this.syncAgents(root);
+  }
+  pump() {
+    if (this.closing) return;
+    clearTimeout(this.timer);
+    for (const [root, deadline] of this.deadlines) if (deadline <= Date.now()) this.reconcile(root);
+    const capacity = this.capacity - this.active.size;
+    if (capacity > 0)
+      for (const id of this.store.scheduleTasks([...this.active.keys()], capacity)) this.launch(id);
+    if (this.deadlines.size > 0) {
+      const deadline = Math.min(...this.deadlines.values());
+      this.timer = setTimeout(
+        () => {
+          try {
+            this.pump();
+          } catch (error) {
+            this.stop(error);
+            this.fatal(error);
+          }
+        },
+        Math.max(1, Math.min(2147483647, deadline - Date.now()))
+      );
+      this.timer.unref();
+    }
+  }
+  launch(id) {
+    const controller = new AbortController();
+    const promise = new Promise((resolve) => setTimeout(resolve, 0)).then(() => this.execute(id, controller)).catch((error) => {
+      if (!(error instanceof DurableLimitError)) throw error;
+      this.store.transaction((tx) => {
+        const task = requireTask(tx, id);
+        delete task.wait;
+        delete task.outcome;
+        task.status = "needs_attention";
+        task.error = error.message;
+        saveTask(tx, task);
+      });
+    }).finally(() => {
+      this.active.delete(id);
+      if (!this.closing) {
+        this.reconcile(this.snapshot(id).task.rootId);
+        this.pump();
+      }
+    }).catch((error) => {
+      this.stop(error);
+      this.fatal(error);
+    });
+    this.active.set(id, { controller, promise });
+  }
+  async execute(id, controller) {
+    if (controller.signal.aborted) return;
+    const task = this.store.transaction((tx) => {
+      const saved = requireTask(tx, id);
+      if (!["pending", "running"].includes(saved.status)) return void 0;
+      const definition2 = this.definitions.get(saved.name);
+      try {
+        if (definition2 === void 0 || definition2.version < saved.version)
+          throw new Error("Task definition/version is unavailable.");
+        if (definition2.version !== saved.version) {
+          if (definition2.migrate === void 0)
+            throw new Error("Task checkpoint requires a migration.");
+          const migrated = definition2.migrate(saved.input, saved.checkpoint, saved.version);
+          saved.input = migrated.input;
+          saved.checkpoint = migrated.checkpoint;
+          saved.version = definition2.version;
+        }
+        saved.input = definition2.parseInput(saved.input);
+        saved.checkpoint = definition2.parseCheckpoint(saved.checkpoint);
+        saved.status = "running";
+        delete saved.error;
+      } catch (error) {
+        saved.status = "needs_attention";
+        saved.error = errorMessage(error);
+      }
+      saveTask(tx, saved);
+      return saved;
+    });
+    if (task?.status !== "running") return;
+    const definition = this.definitions.get(task.name);
+    const invocation = taskInvocation(
+      this.store,
+      task,
+      this.definitions,
+      controller,
+      () => {
+        this.syncAgents(task.rootId);
+        this.pump();
+      },
+      (tx, parent, key, input) => spawnAgent(tx, this.agents, parent, key, input)
+    );
+    let transition;
+    let failure;
+    try {
+      transition = await definition.run(invocation.context);
+    } catch (error) {
+      failure = error;
+    }
+    try {
+      await invocation.finish();
+    } catch (error) {
+      failure = error;
+    }
+    if (failure instanceof DurableStorageError) throw failure;
+    if (this.closing) return;
+    const abort = this.store.transaction((tx) => {
+      const current = requireTask(tx, id);
+      if (current.status !== "running") return [];
+      let cancelChildren = false;
+      try {
+        if (failure !== void 0) throw failure;
+        if (transition === void 0) throw new TypeError("Task must return a transition.");
+        switch (transition.status) {
+          case "pending":
+            current.checkpoint = definition.parseCheckpoint(transition.checkpoint);
+            current.status = "pending";
+            break;
+          case "waiting": {
+            const wait = taskWaitSchema.parse(transition.wait);
+            if (wait.type === "agent")
+              throw new TypeError("Agent waits are managed by spawnAgent().");
+            if (wait.type === "children" && (new Set(wait.ids).size !== wait.ids.length || wait.ids.some((child) => requireTask(tx, child).parentId !== id)))
+              throw new TypeError("Tasks may wait only on distinct direct children.");
+            current.checkpoint = definition.parseCheckpoint(transition.checkpoint);
+            current.wait = wait;
+            current.status = "waiting";
+            break;
+          }
+          case "completed":
+            current.outcome = {
+              status: "completed",
+              output: definition.parseOutput(transition.output)
+            };
+            current.status = "completing";
+            break;
+          case "failed":
+          case "cancelled":
+            current.outcome = { status: transition.status, error: errorMessage(transition.error) };
+            current.status = "cancelling";
+            cancelChildren = true;
+            break;
+          default:
+            throw new TypeError("Invalid task transition.");
+        }
+      } catch (error) {
+        delete current.wait;
+        delete current.outcome;
+        current.error = errorMessage(error);
+        if (error instanceof DurableRecoveryError || error instanceof DurableLimitError) {
+          current.status = "needs_attention";
+          if (error instanceof DurableRecoveryError && error.operationId !== void 0)
+            current.blockedOperation = error.operationId;
+        } else {
+          current.status = "cancelling";
+          current.outcome = { status: "failed", error: current.error };
+          cancelChildren = true;
+        }
+      }
+      const ids = cancelChildren ? tx.taskChildren(id).flatMap((child) => cancelTree(tx, child.id, "Owner task failed or was cancelled.")) : [];
+      saveTask(tx, current);
+      return ids;
+    });
+    for (const child of abort)
+      this.active.get(child)?.controller.abort(new Error("Owner task ended."));
+  }
+};
+
+// src/tasks/handle.ts
+var DurableTaskHandle = class {
+  constructor(id, scheduler, store, assertOpen) {
+    this.id = id;
+    this.scheduler = scheduler;
+    this.store = store;
+    this.assertOpen = assertOpen;
+  }
+  id;
+  scheduler;
+  store;
+  assertOpen;
+  async snapshot() {
+    this.assertOpen();
+    return this.scheduler.snapshot(this.id);
+  }
+  async graph() {
+    this.assertOpen();
+    return this.scheduler.graph(this.id);
+  }
+  /** Optional identity fence for callers authorizing a captured ownership tree. */
+  async cancel(options = {}) {
+    this.assertOpen();
+    this.scheduler.cancel(this.id, options.expectedTreeIds);
+  }
+  async retry() {
+    this.assertOpen();
+    this.scheduler.retry(this.id);
+  }
+  async resolveEffect(key, value) {
+    this.assertOpen();
+    this.scheduler.resolveEffect(this.id, key, value);
+  }
+  async signal(name, requestId, value) {
+    this.assertOpen();
+    this.scheduler.signal(this.id, name, requestId, value);
+  }
+  async result(options = {}) {
+    while (true) {
+      options.abortSignal?.throwIfAborted();
+      const { task } = await this.snapshot();
+      if (terminal(task)) {
+        const outcome = task.outcome;
+        if (outcome.status === "completed") return outcome.output;
+        throw new DurableRunError(task.id, outcome.status, outcome.error);
+      }
+      await delay(options.abortSignal);
+    }
+  }
+  /** Streams the entire owned tree, including children created after attachment. */
+  async *stream(options = {}) {
+    let cursor = options.after ?? 0;
+    const initial = await this.snapshot();
+    if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > initial.cursor)
+      throw new TypeError("Invalid task event cursor.");
+    while (true) {
+      this.assertOpen();
+      options.abortSignal?.throwIfAborted();
+      const events = this.store.taskEvents(initial.task.rootId, cursor, 100);
+      for (const event of events) {
+        options.abortSignal?.throwIfAborted();
+        if (event.type !== "submitted" && event.type !== "status")
+          throw new Error("Invalid task event type.");
+        cursor = event.sequence;
+        yield {
+          rootId: initial.task.rootId,
+          sequence: event.sequence,
+          taskId: event.runId,
+          createdAt: event.createdAt,
+          type: event.type,
+          data: event.data
+        };
+      }
+      if (events.length > 0) continue;
+      if (terminal(this.scheduler.snapshot(initial.task.rootId).task)) return;
+      await delay(options.abortSignal);
+    }
+  }
+};
+
+// src/graph-state.ts
+function createGraph(tx, submission, agents) {
+  const existing = tx.findGraphRequest(submission.sessionId, submission.requestId);
+  if (existing !== void 0) {
+    if (!sameJson(existing.submission, submission))
+      throw new DurableConflictError("Graph requestId already belongs to a different submission.");
+    return existing.id;
+  }
+  const id = globalThis.crypto.randomUUID();
+  const runs = submission.tasks.map((task) => {
+    const registration = agents.get(task.agentId);
+    if (registration === void 0)
+      throw new DurableNotFoundError(`Unknown durable agent: ${task.agentId}`);
+    return {
+      task,
+      run: createRunRecord(
+        {
+          agentId: task.agentId,
+          sessionId: `${GRAPH_SESSION_PREFIX}${id}:${task.id}`,
+          requestId: task.id,
+          prompt: task.prompt
+        },
+        registration
+      )
+    };
+  });
+  const runIds = Object.fromEntries(runs.map(({ task, run }) => [task.id, run.id]));
+  const graph = {
+    id,
+    submission,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cancelled: false,
+    runIds
+  };
+  tx.putGraph(graph);
+  for (const { task, run } of runs) {
+    run.graphId = id;
+    run.taskId = task.id;
+    run.dependencies = (task.dependsOn ?? []).map((dependency) => runIds[dependency]);
+    tx.putRun(run);
+    tx.appendEvent(
+      run.id,
+      "submitted",
+      json({ graphId: id, taskId: task.id, prompt: task.prompt })
+    );
+  }
+  return id;
+}
+function requireGraph(tx, id) {
+  const graph = tx.getGraph(id);
+  if (graph === void 0) throw new DurableNotFoundError(`Unknown durable graph: ${id}`);
+  return graph;
+}
+function graphSnapshot(tx, id) {
+  const graph = requireGraph(tx, id);
+  const runs = new Map(
+    graph.submission.tasks.map((task) => [task.id, tx.getRun(graph.runIds[task.id])])
+  );
+  const nodes = graph.submission.tasks.map((task) => {
+    const run = runs.get(task.id);
+    if (run === void 0 || run.graphId !== id || run.taskId !== task.id)
+      throw new Error("Graph task/run mapping changed.");
+    let wait;
+    if (run.status === "queued") {
+      const incomplete = (task.dependsOn ?? []).filter(
+        (dependency) => !successful(runs.get(dependency))
+      );
+      const failed = incomplete.filter((dependency) => dependencyFailed(runs.get(dependency)));
+      wait = failed.length > 0 ? { type: "dependency_failed", taskIds: failed } : incomplete.length > 0 ? { type: "dependencies", taskIds: incomplete } : { type: "capacity" };
+    } else if (run.status === "retry_wait") wait = { type: "retry", until: run.nextAttemptAt };
+    else if (run.status === "waiting" && run.outcome?.type === "interaction")
+      wait = { type: "interaction", interactionId: run.outcome.interaction.id };
+    else if (run.status === "needs_attention")
+      wait = {
+        type: "recovery",
+        ...run.blockedOperation === void 0 ? {} : { operationId: run.blockedOperation }
+      };
+    return {
+      id: task.id,
+      agentId: task.agentId,
+      runId: run.id,
+      status: run.status,
+      ...wait === void 0 ? {} : { wait },
+      ...run.error === void 0 ? {} : { error: run.error },
+      ...run.outcome?.type === "response" ? { output: json(run.outcome.output) } : {},
+      ...run.outcome?.type === "interaction" ? { interaction: run.outcome.interaction } : {}
+    };
+  });
+  const all = [...runs.values()];
+  const status = graph.cancelled ? "cancelled" : all.every(successful) ? "completed" : nodes.some(
+    (node) => node.status === "running" || node.status === "pending" || node.wait?.type === "capacity"
+  ) ? "running" : all.some((run) => dependencyFailed(run) || run.status === "needs_attention") ? "blocked" : "waiting";
+  return {
+    id,
+    sessionId: graph.submission.sessionId,
+    requestId: graph.submission.requestId,
+    createdAt: graph.createdAt,
+    status,
+    nodes,
+    edges: graph.submission.tasks.flatMap(
+      (task) => (task.dependsOn ?? []).map((source) => ({ source, target: task.id }))
+    ),
+    cursor: tx.cursor()
+  };
+}
+function successful(run) {
+  return run.status === "completed" && run.outcome?.type === "response";
+}
+function dependencyFailed(run) {
+  return run.status === "failed" || run.status === "cancelled" || run.status === "completed" && !successful(run);
+}
+function graphInput(tx, run) {
+  const values = {};
+  for (const dependency of run.dependencies ?? []) {
+    const prerequisite = tx.getRun(dependency);
+    if (prerequisite === void 0 || prerequisite.graphId !== run.graphId || !successful(prerequisite) || prerequisite.outcome?.type !== "response")
+      throw new DurableConflictError("Task dependencies are not successful.");
+    values[prerequisite.taskId] = json(prerequisite.outcome.output);
+  }
+  return Object.keys(values).length === 0 ? run.prompt : `${run.prompt}
+
+Task dependency results (JSON):
+${JSON.stringify(values)}`;
+}
+
+// src/runtime.ts
+import {
+  assertAgentInteractionResponse,
+  parseAgentInteractionResponse
+} from "@anvia/core/agent/interactions";
+import { parseMessage } from "@anvia/core/completion";
+import { withInternalAgentRunOptions } from "@anvia/core/internal/agent";
+
+// src/execution.ts
+import { Usage as Usage2 } from "@anvia/core/completion";
+function createExecution(store, run, registration, signal) {
+  const prefix = `${run.epoch}:`;
+  let modelPhase = 0;
+  const check = () => signal.throwIfAborted();
+  function start(key, kind, input, recovery) {
+    check();
+    return store.transaction((tx) => {
+      const previous = tx.getOperation(run.id, key);
+      if (previous !== void 0) {
+        if (!sameJson(previous.input, input) || previous.kind !== kind) {
+          throw new DurableRecoveryError(
+            "Execution changed at a saved checkpoint; restore the registered agent version.",
+            key
+          );
+        }
+        if (previous.status === "started" && previous.recovery === "manual") {
+          throw new DurableRecoveryError(
+            "An interrupted tool has an uncertain outcome and requires reconciliation.",
+            key
+          );
+        }
+        return previous;
+      }
+      const current = tx.getRun(run.id);
+      if (kind === "model") {
+        if (current.modelTurns >= current.maxModelTurns) {
+          throw new Error("Durable run exhausted its model-turn budget.");
+        }
+        current.modelTurns += 1;
+        tx.putRun(current);
+      }
+      const operation = { key, kind, input, recovery, status: "started" };
+      tx.putOperation(run.id, operation);
+      tx.appendEvent(run.id, kind === "model" ? "model_started" : "tool_started", {
+        operationId: key,
+        input
+      });
+      return operation;
+    });
+  }
+  function complete(operation, result, usage) {
+    check();
+    store.transaction((tx) => {
+      const current = tx.getRun(run.id);
+      if (current.status !== "running") throw new Error("Durable run is no longer running.");
+      tx.putOperation(run.id, { ...operation, status: "completed", result });
+      if (usage !== void 0) {
+        current.usage = Usage2.add(current.usage, usage);
+        tx.putRun(current);
+      }
+      tx.appendEvent(run.id, operation.kind === "model" ? "model_completed" : "tool_completed", {
+        operationId: operation.key,
+        result
+      });
+    });
+  }
+  return {
+    async completion(turn, request, execute) {
+      modelPhase = turn;
+      const operation = start(
+        `${prefix}model:${turn}`,
+        "model",
+        json({
+          provider: registration.agent.model.provider,
+          modelId: registration.agent.model.modelId,
+          request
+        }),
+        "safe"
+      );
+      if (operation.status === "completed")
+        return operation.result;
+      if (run.modelRetry !== void 0 && (operation.attempts ?? 0) >= run.modelRetry.maxAttempts) {
+        throw new DurableModelError(
+          operation.key,
+          operation.attempts,
+          new Error("Durable model attempt budget exhausted; retry explicitly to reset it.")
+        );
+      }
+      const attempts = (operation.attempts ?? 0) + 1;
+      operation.attempts = attempts;
+      store.transaction((tx) => tx.putOperation(run.id, operation));
+      let response;
+      try {
+        response = await execute();
+      } catch (error) {
+        check();
+        throw new DurableModelError(operation.key, attempts, error);
+      }
+      const { rawResponse: _raw, ...normalized } = response;
+      const saved = json({ ...normalized, rawResponse: null });
+      complete(operation, saved, response.usage);
+      return saved;
+    },
+    async tool(call, execute) {
+      const key = `${prefix}tool:${modelPhase === 0 ? "resume" : modelPhase}:${call.toolCall.toolCallId}`;
+      const operation = start(
+        key,
+        "tool",
+        json(call),
+        registration.toolRecovery?.[call.toolCall.toolName] ?? "manual"
+      );
+      if (operation.status === "completed") return restoreToolResult(operation.result);
+      const result = await execute({ operationId: `${run.id}/${key}` });
+      check();
+      try {
+        const saved = json(
+          result.failed ? { output: result.output, failed: true, error: errorMessage(result.error) } : result
+        );
+        complete(operation, saved);
+        return restoreToolResult(saved);
+      } catch (error) {
+        if (error instanceof DurableStorageError) throw error;
+        throw new DurableRecoveryError(
+          `Could not record the tool result: ${errorMessage(error)}`,
+          key
+        );
+      }
+    }
+  };
+}
+function restoreToolResult(value) {
+  const result = value;
+  return result.failed ? { ...result, error: new Error(String(result.error)) } : result;
+}
+
+// src/registration.ts
+import { AGENT_RUN_EXECUTION_VERSION, getResolvedAgentOptions } from "@anvia/core/internal/agent";
+function registrations(values) {
+  if (AGENT_RUN_EXECUTION_VERSION !== 1) throw new Error("Unsupported core execution protocol.");
+  const result = /* @__PURE__ */ new Map();
+  for (const registration of values) {
+    nonblank(registration.version, "Agent version");
+    const { agent } = registration;
+    const options = getResolvedAgentOptions(agent);
+    if (result.has(agent.id)) throw new TypeError(`Duplicate durable agent: ${agent.id}`);
+    if (agent.memory !== void 0 || agent.lifecycle !== void 0 || agent.middlewares.length > 0 || agent.guardrails.length > 0 || agent.context.length > 0 || agent.mcpServers.length > 0 || (options.providerTools?.length ?? 0) > 0 || (options.toolIndexes?.length ?? 0) > 0) {
+      throw new TypeError(
+        "Durable agents currently support static local tools and instructions; memory, lifecycle, middleware, guardrails, context, MCP, provider tools, and tool indexes require additional checkpoint support."
+      );
+    }
+    for (const [name, policy] of Object.entries(registration.toolRecovery ?? {})) {
+      if (agent.getTool(name) === void 0) throw new TypeError(`Unknown recovery tool: ${name}`);
+      if (policy !== "safe" && policy !== "idempotent" && policy !== "manual")
+        throw new TypeError(`Invalid recovery policy for ${name}`);
+    }
+    result.set(agent.id, {
+      agent,
+      version: registration.version,
+      toolRecovery: { ...registration.toolRecovery },
+      ...registration.modelRetry === void 0 ? {} : { modelRetry: modelRetrySchema.parse(registration.modelRetry) }
+    });
+  }
+  return result;
+}
+
+// src/run.ts
+var DurableRun = class {
+  constructor(id, runtime) {
+    this.id = id;
+    this.runtime = runtime;
+  }
+  id;
+  runtime;
+  async snapshot() {
+    return this.runtime.snapshot(this.id);
+  }
+  async *stream(options = {}) {
+    let cursor = options.after ?? 0;
+    if (!Number.isSafeInteger(cursor) || cursor < 0) throw new TypeError("Invalid event cursor.");
+    if (cursor > (await this.snapshot()).cursor)
+      throw new TypeError("Event cursor is ahead of the store.");
+    while (true) {
+      options.abortSignal?.throwIfAborted();
+      const events = this.runtime.events(this.id, cursor);
+      for (const event of events) {
+        options.abortSignal?.throwIfAborted();
+        cursor = event.sequence;
+        yield event;
+      }
+      if (events.length > 0) continue;
+      const { run } = await this.snapshot();
+      if (run.status === "completed" || run.status === "failed" || run.status === "cancelled")
+        return;
+      await delay(options.abortSignal);
+    }
+  }
+  async result(options = {}) {
+    while (true) {
+      options.abortSignal?.throwIfAborted();
+      const { run } = await this.snapshot();
+      if (run.status === "failed" || run.status === "cancelled") {
+        throw new DurableRunError(run.id, run.status, run.error ?? run.status);
+      }
+      if (run.status === "completed") {
+        if (run.outcome === void 0) throw new Error("Completed durable run has no outcome.");
+        return run.outcome;
+      }
+      await delay(options.abortSignal);
+    }
+  }
+  async respond(interactionId, response) {
+    this.runtime.respond(this.id, interactionId, response);
+  }
+  async resolveTool(operationId, output) {
+    this.runtime.resolveTool(this.id, operationId, output);
+  }
+  async retry() {
+    this.runtime.retry(this.id);
+  }
+  async cancel() {
+    this.runtime.cancel(this.id);
+  }
+};
+
+// src/runtime.ts
+var DurableRuntime = class _DurableRuntime {
+  constructor(store, agents, maxConcurrentRuns, definitions, maxConcurrentTasks, limits, onFatalError) {
+    this.maxConcurrentRuns = maxConcurrentRuns;
+    this.onFatalError = onFatalError;
+    this.agents = agents;
+    this.store = guardStore(store, (error) => this.fail(error), limits);
+    this.tasks = new TaskScheduler(
+      this.store,
+      definitions,
+      maxConcurrentTasks,
+      (error) => this.fail(error),
+      agents,
+      (id) => this.active.has(id),
+      (root) => {
+        const tasks = this.store.transaction((tx) => tx.taskTree(root));
+        for (const task of tasks)
+          if (task.agentRunId !== void 0 && task.status === "cancelling")
+            this.active.get(task.agentRunId)?.controller.abort(new Error("Owner task cancelled."));
+        this.pump();
+      }
+    );
+  }
+  maxConcurrentRuns;
+  onFatalError;
+  agents;
+  active = /* @__PURE__ */ new Map();
+  closing = false;
+  closed = false;
+  store;
+  closePromise;
+  failure;
+  wakeTimer;
+  tasks;
+  static async open(options) {
+    const maxConcurrentRuns = options.maxConcurrentRuns ?? 4;
+    if (!Number.isSafeInteger(maxConcurrentRuns) || maxConcurrentRuns < 1 || maxConcurrentRuns > 1e3)
+      throw new TypeError("maxConcurrentRuns must be an integer between 1 and 1000.");
+    const maxConcurrentTasks = options.maxConcurrentTasks ?? 4;
+    if (!Number.isSafeInteger(maxConcurrentTasks) || maxConcurrentTasks < 1 || maxConcurrentTasks > 1e3)
+      throw new TypeError("maxConcurrentTasks must be an integer between 1 and 1000.");
+    const definitions = /* @__PURE__ */ new Map();
+    for (const { registration } of options.tasks ?? []) {
+      if (registration.name === agentTask.name)
+        throw new TypeError("Reserved task name: anvia.agent");
+      if (definitions.has(registration.name))
+        throw new TypeError(`Duplicate task definition: ${registration.name}`);
+      definitions.set(registration.name, registration);
+    }
+    const agents = registrations(options.agents ?? []);
+    const limits = durableLimits(options.limits);
+    options.store.acquire();
+    return new _DurableRuntime(
+      options.store,
+      agents,
+      maxConcurrentRuns,
+      definitions,
+      maxConcurrentTasks,
+      limits,
+      options.onFatalError
+    );
+  }
+  async submitTask(definition, input) {
+    this.assertOpen();
+    const id = this.tasks.submit(
+      definition.name,
+      definition.version,
+      input.input,
+      input.sessionId,
+      input.requestId
+    );
+    return new DurableTaskHandle(id, this.tasks, this.store, () => this.assertOpen());
+  }
+  async submitRegisteredTask(input) {
+    this.assertOpen();
+    const submission = parseTaskSubmission(input);
+    const id = this.tasks.submit(
+      submission.name,
+      submission.version,
+      submission.input,
+      submission.sessionId,
+      submission.requestId
+    );
+    return new DurableTaskHandle(id, this.tasks, this.store, () => this.assertOpen());
+  }
+  /** Owning scope for authorization without loading operation journals or graph results. */
+  runScope(runId) {
+    this.assertOpen();
+    return this.store.transaction((tx) => {
+      const run = requireRun(tx, runId);
+      const base = { runId, agentId: run.agentId, sessionId: run.sessionId };
+      if (run.graphId !== void 0)
+        return {
+          ...base,
+          sessionId: requireGraph(tx, run.graphId).submission.sessionId,
+          graphId: run.graphId,
+          taskId: run.taskId
+        };
+      if (!run.sessionId.startsWith(TASK_SESSION_PREFIX)) return base;
+      const task = tx.getTask(run.sessionId.slice(TASK_SESSION_PREFIX.length));
+      if (task === void 0 || task.agentRunId !== runId)
+        throw new DurableNotFoundError("Owned task is missing.");
+      return {
+        ...base,
+        sessionId: task.sessionId,
+        taskId: task.id,
+        rootTaskId: task.rootId,
+        taskName: task.name
+      };
+    });
+  }
+  async getTask(id) {
+    this.assertOpen();
+    this.tasks.snapshot(id);
+    return new DurableTaskHandle(id, this.tasks, this.store, () => this.assertOpen());
+  }
+  async listTasks(options = {}) {
+    this.assertOpen();
+    return this.store.listTasks(taskListSchema.parse(options));
+  }
+  async taskGraph(id) {
+    this.assertOpen();
+    return this.tasks.graph(id);
+  }
+  async submit(input, options = {}) {
+    this.assertOpen();
+    if (options.enqueue !== void 0 && typeof options.enqueue !== "boolean")
+      throw new TypeError("enqueue must be a boolean.");
+    for (const key of ["agentId", "sessionId", "requestId", "prompt"])
+      nonblank(input[key], key);
+    if (input.sessionId.startsWith(GRAPH_SESSION_PREFIX) || input.sessionId.startsWith(TASK_SESSION_PREFIX))
+      throw new TypeError("Reserved durable session ID.");
+    const submission = {
+      agentId: input.agentId,
+      sessionId: input.sessionId,
+      requestId: input.requestId,
+      prompt: input.prompt
+    };
+    const registration = this.agents.get(input.agentId);
+    if (registration === void 0)
+      throw new DurableNotFoundError(`Unknown durable agent: ${input.agentId}`);
+    const id = this.store.transaction((tx) => {
+      const existing = tx.findRequest(input.sessionId, input.requestId);
+      if (existing !== void 0) {
+        if (existing.agentId !== input.agentId || existing.prompt !== input.prompt) {
+          throw new DurableConflictError("requestId already belongs to a different submission.");
+        }
+        return existing.id;
+      }
+      if (!options.enqueue && tx.activeRun(input.sessionId) !== void 0)
+        throw new DurableConflictError("Session already has unfinished work.");
+      if (!options.enqueue && [...this.active.values()].some((active) => active.sessionId === input.sessionId)) {
+        throw new DurableConflictError("Previous session execution is still settling.");
+      }
+      const run = createRunRecord(submission, registration);
+      tx.putRun(run);
+      tx.appendEvent(run.id, "submitted", json(submission));
+      return run.id;
+    });
+    this.pump();
+    return new DurableRun(id, this);
+  }
+  async submitGraph(input) {
+    this.assertOpen();
+    const submission = parseDurableGraphSubmission(input);
+    const id = this.store.transaction((tx) => createGraph(tx, submission, this.agents));
+    this.pump();
+    return new DurableTaskGraph(id, this);
+  }
+  async getGraph(id) {
+    this.graphSnapshot(id);
+    return new DurableTaskGraph(id, this);
+  }
+  async listGraphs(options = {}) {
+    this.assertOpen();
+    return this.store.listGraphs(graphListSchema.parse(options));
+  }
+  graphSnapshot(id) {
+    this.assertOpen();
+    return this.store.transaction((tx) => graphSnapshot(tx, id));
+  }
+  graphEvents(id, after) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(after) || after < 0) throw new TypeError("Invalid event cursor.");
+    return this.store.graphEvents(id, after, 100);
+  }
+  cancelGraph(id) {
+    this.assertOpen();
+    const ids = this.store.transaction((tx) => {
+      const graph = requireGraph(tx, id);
+      if (graph.cancelled || graphSnapshot(tx, id).status === "completed") return [];
+      graph.cancelled = true;
+      tx.putGraph(graph);
+      const runIds = Object.values(graph.runIds);
+      for (const runId of runIds) {
+        const run = requireRun(tx, runId);
+        if (["completed", "failed", "cancelled"].includes(run.status)) continue;
+        delete run.nextAttemptAt;
+        run.error = "Durable graph cancelled.";
+        setStatus(tx, run, "cancelled");
+      }
+      tx.appendEvent(runIds[0], "status", { graphCancelled: true });
+      return runIds;
+    });
+    for (const runId of ids)
+      this.active.get(runId)?.controller.abort(new Error("Durable graph cancelled."));
+    this.pump();
+  }
+  async listRuns(options = {}) {
+    this.assertOpen();
+    return this.store.list(listOptionsSchema.parse(options));
+  }
+  async getRun(id) {
+    this.snapshot(id);
+    return new DurableRun(id, this);
+  }
+  /** Discover recoverable work. This does not wait for runs or approvals to finish. */
+  async resume() {
+    this.assertOpen();
+    this.pump();
+    this.tasks.resume();
+  }
+  /** Abort in-flight attempts, retain checkpoints, and release ownership after callbacks settle. */
+  close() {
+    if (this.closePromise !== void 0) return this.closePromise;
+    this.closing = true;
+    clearTimeout(this.wakeTimer);
+    for (const { controller } of this.active.values())
+      controller.abort(new Error("Durable runtime closed."));
+    this.closePromise = Promise.all([
+      this.tasks.close(),
+      ...[...this.active.values()].map(({ task }) => task)
+    ]).then(() => {
+      try {
+        this.store.close();
+      } finally {
+        this.closed = true;
+      }
+    });
+    return this.closePromise;
+  }
+  snapshot(id) {
+    this.assertOpen();
+    return this.store.transaction((tx) => ({
+      run: requireRun(tx, id),
+      operations: tx.operations(id),
+      cursor: tx.cursor()
+    }));
+  }
+  events(id, after) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(after) || after < 0) throw new TypeError("Invalid event cursor.");
+    return this.store.events(id, after, 100);
+  }
+  respond(id, interactionId, value) {
+    this.assertOpen();
+    nonblank(interactionId, "Interaction ID");
+    const response = parseAgentInteractionResponse(value);
+    this.store.transaction((tx) => {
+      const run = requireRun(tx, id);
+      if (run.graphId !== void 0 && requireGraph(tx, run.graphId).cancelled)
+        throw new DurableConflictError("Graph is cancelled.");
+      if (Object.hasOwn(run.responses, interactionId)) {
+        if (!sameJson(run.responses[interactionId], response))
+          throw new DurableConflictError("Interaction already received a different response.");
+        return;
+      }
+      assertOwnedTaskMutable(tx, run);
+      if (run.status !== "waiting" || run.outcome?.type !== "interaction" || run.outcome.interaction.id !== interactionId) {
+        throw new DurableConflictError("No matching pending interaction.");
+      }
+      try {
+        assertAgentInteractionResponse(run.outcome.interaction, response);
+      } catch (error) {
+        throw new DurableConflictError(errorMessage(error));
+      }
+      run.responses[interactionId] = json(response);
+      const continuation = run.outcome.continuation;
+      run.history = [...run.history, ...run.outcome.messages];
+      run.input = { continuation, response };
+      run.epoch += 1;
+      delete run.outcome;
+      setStatus(tx, run, "pending");
+    });
+    this.pump();
+  }
+  resolveTool(id, operationId, output) {
+    this.assertOpen();
+    this.store.transaction((tx) => {
+      const run = requireRun(tx, id);
+      assertOwnedTaskMutable(tx, run);
+      if (run.graphId !== void 0 && requireGraph(tx, run.graphId).cancelled)
+        throw new DurableConflictError("Graph is cancelled.");
+      if (run.status !== "needs_attention" || run.blockedOperation !== operationId) {
+        throw new DurableConflictError("No matching tool awaiting reconciliation.");
+      }
+      const operation = tx.getOperation(id, operationId);
+      if (operation?.kind !== "tool" || operation.status !== "started")
+        throw new DurableConflictError("Operation cannot be reconciled.");
+      const checked = parseMessage({
+        role: "tool",
+        content: [{ type: "tool-result", toolCallId: operationId, toolName: "reconciled", output }]
+      });
+      if (checked.role !== "tool" || checked.content[0]?.type !== "tool-result")
+        throw new TypeError("Invalid tool result.");
+      const result = json({ output: checked.content[0].output, failed: false });
+      tx.putOperation(id, { ...operation, status: "completed", result });
+      tx.appendEvent(id, "tool_completed", { operationId, result, reconciled: true });
+      delete run.blockedOperation;
+      delete run.error;
+      setStatus(tx, run, "pending");
+    });
+    this.pump();
+  }
+  retry(id) {
+    this.assertOpen();
+    if (this.active.has(id)) throw new DurableConflictError("Run is still settling.");
+    this.store.transaction((tx) => {
+      const run = requireRun(tx, id);
+      assertOwnedTaskMutable(tx, run);
+      if (run.graphId !== void 0 && requireGraph(tx, run.graphId).cancelled)
+        throw new DurableConflictError("Graph is cancelled.");
+      if (run.status !== "failed" && run.status !== "needs_attention")
+        throw new DurableConflictError("Only failed or blocked runs can be retried.");
+      const other = tx.activeRun(run.sessionId);
+      if (other !== void 0 && other.id !== id && other.status !== "queued")
+        throw new DurableConflictError("Session already has unfinished work.");
+      if (tx.hasLaterStartedRun(id))
+        throw new DurableConflictError("Session has advanced; create a new submission.");
+      for (const operation of tx.operations(id)) {
+        if (operation.kind === "model" && operation.status === "started")
+          tx.putOperation(id, { ...operation, attempts: 0 });
+      }
+      delete run.error;
+      delete run.blockedOperation;
+      setStatus(tx, run, "pending");
+    });
+    this.pump();
+  }
+  cancel(id) {
+    this.assertOpen();
+    const sessionId = this.store.transaction((tx) => {
+      const run = requireRun(tx, id);
+      if (["completed", "failed", "cancelled"].includes(run.status)) return run.sessionId;
+      delete run.nextAttemptAt;
+      run.error = "Durable run cancelled.";
+      setStatus(tx, run, "cancelled");
+      return run.sessionId;
+    });
+    this.active.get(id)?.controller.abort(new Error("Durable run cancelled."));
+    if (sessionId.startsWith(TASK_SESSION_PREFIX))
+      this.tasks.agentChanged(sessionId.slice(TASK_SESSION_PREFIX.length));
+    this.pump();
+  }
+  pump() {
+    if (this.closing || this.failure !== void 0) return;
+    clearTimeout(this.wakeTimer);
+    const capacity = this.maxConcurrentRuns - this.active.size;
+    if (capacity <= 0) return;
+    const candidates = this.store.schedule(
+      (/* @__PURE__ */ new Date()).toISOString(),
+      capacity,
+      [...this.active.values()].map((active) => active.sessionId)
+    );
+    for (const id of candidates.ids) this.launch(id);
+    if (candidates.nextAttemptAt !== void 0) {
+      this.wakeTimer = setTimeout(
+        () => {
+          try {
+            this.pump();
+          } catch (error) {
+            this.fail(error);
+          }
+        },
+        Math.max(1, Math.min(2147483647, Date.parse(candidates.nextAttemptAt) - Date.now()))
+      );
+      this.wakeTimer.unref();
+    }
+  }
+  launch(id) {
+    if (this.active.has(id) || this.closing) return;
+    const { status, sessionId } = this.snapshot(id).run;
+    if (!["queued", "pending", "running", "retry_wait"].includes(status)) return;
+    const controller = new AbortController();
+    const task = Promise.resolve().then(() => this.execute(id, controller.signal)).catch((error) => {
+      if (!(error instanceof DurableLimitError)) throw error;
+      this.store.transaction((tx) => {
+        const run = requireRun(tx, id);
+        run.error = error.message;
+        setStatus(tx, run, "needs_attention");
+      });
+    }).finally(() => {
+      this.active.delete(id);
+      if (!this.closing && this.failure === void 0 && sessionId.startsWith(TASK_SESSION_PREFIX))
+        this.tasks.agentChanged(sessionId.slice(TASK_SESSION_PREFIX.length));
+      if (!this.closing && this.failure === void 0) this.pump();
+    }).catch((error) => {
+      if (controller.signal.aborted) return;
+      this.fail(error);
+    });
+    this.active.set(id, { sessionId, controller, task });
+  }
+  async execute(id, signal) {
+    signal.throwIfAborted();
+    const run = this.store.transaction((tx) => {
+      const current = requireRun(tx, id);
+      if (!["queued", "pending", "running", "retry_wait"].includes(current.status))
+        return void 0;
+      if (current.status === "queued") {
+        if (current.graphId !== void 0) {
+          current.input = { messages: [{ role: "user", content: graphInput(tx, current) }] };
+        } else {
+          const previous = tx.latestCompleted(current.sessionId);
+          current.history = previous === void 0 ? [] : [...previous.history, ...previous.outcome?.messages ?? []];
+          current.input = {
+            messages: [...current.history, { role: "user", content: current.prompt }]
+          };
+        }
+      }
+      current.startedAt ??= (/* @__PURE__ */ new Date()).toISOString();
+      delete current.nextAttemptAt;
+      delete current.error;
+      setStatus(tx, current, "running");
+      return current;
+    });
+    if (run === void 0) return;
+    if (run.sessionId.startsWith(TASK_SESSION_PREFIX))
+      this.tasks.agentChanged(run.sessionId.slice(TASK_SESSION_PREFIX.length));
+    try {
+      const registration = this.agents.get(run.agentId);
+      if (registration === void 0 || registration.version !== run.version) {
+        throw new DurableRecoveryError(
+          "The saved agent version is not registered. Restore it before retrying."
+        );
+      }
+      const outcome = await registration.agent.generate(
+        withInternalAgentRunOptions(
+          {
+            ...run.input,
+            abortSignal: signal,
+            retries: false
+          },
+          { runId: id, execution: createExecution(this.store, run, registration, signal) }
+        )
+      );
+      signal.throwIfAborted();
+      this.store.transaction((tx) => {
+        const current = requireRun(tx, id);
+        current.outcome = { ...outcome, usage: current.usage };
+        setStatus(tx, current, outcome.type === "interaction" ? "waiting" : "completed");
+      });
+    } catch (error) {
+      if (error instanceof DurableStorageError) throw error;
+      if (signal.aborted) return;
+      this.store.transaction((tx) => {
+        const current = requireRun(tx, id);
+        current.error = errorMessage(error);
+        if (error instanceof DurableRecoveryError && error.operationId !== void 0)
+          current.blockedOperation = error.operationId;
+        if (error instanceof DurableModelError && current.modelRetry !== void 0 && error.attempts < current.modelRetry.maxAttempts) {
+          const delay2 = Math.min(
+            current.modelRetry.maxDelayMs,
+            current.modelRetry.initialDelayMs * 2 ** (error.attempts - 1)
+          );
+          current.nextAttemptAt = new Date(Date.now() + delay2).toISOString();
+          setStatus(tx, current, "retry_wait");
+        } else {
+          setStatus(
+            tx,
+            current,
+            error instanceof DurableRecoveryError ? "needs_attention" : "failed"
+          );
+        }
+      });
+    }
+  }
+  metrics() {
+    this.assertOpen();
+    return this.store.metrics();
+  }
+  /** Does not touch storage, so supervisors can inspect a failed owner. */
+  health() {
+    return {
+      status: this.closed ? "closed" : this.closing ? "closing" : this.failure !== void 0 ? "failed" : "ready",
+      ready: !this.closing && this.failure === void 0,
+      activeRuns: this.active.size,
+      activeTasks: this.tasks.activeCount
+    };
+  }
+  fail(error) {
+    if (this.failure !== void 0) return;
+    this.failure = error;
+    clearTimeout(this.wakeTimer);
+    this.tasks?.stop(error);
+    for (const active of this.active.values()) active.controller.abort(error);
+    try {
+      void Promise.resolve(this.onFatalError?.(error)).catch(() => {
+      });
+    } catch {
+    }
+  }
+  assertOpen() {
+    if (this.closing) throw new Error("Durable runtime is closed.");
+    if (this.failure !== void 0) throw this.failure;
+  }
+};
+function requireRun(tx, id) {
+  const run = tx.getRun(id);
+  if (run === void 0) throw new DurableNotFoundError(`Unknown durable run: ${id}`);
+  return run;
+}
+function setStatus(tx, run, status) {
+  run.status = status;
+  run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  tx.putRun(run);
+  tx.appendEvent(
+    run.id,
+    "status",
+    json({
+      status,
+      error: run.error,
+      blockedOperation: run.blockedOperation,
+      nextAttemptAt: run.nextAttemptAt,
+      outcome: run.outcome
+    })
+  );
+}
+function assertOwnedTaskMutable(tx, run) {
+  if (!run.sessionId.startsWith(TASK_SESSION_PREFIX)) return;
+  const task = tx.getTask(run.sessionId.slice(TASK_SESSION_PREFIX.length));
+  if (task === void 0 || ["completing", "cancelling", "completed", "failed", "cancelled"].includes(task.status))
+    throw new DurableConflictError(
+      "Owned task outcomes are immutable; create a new task submission."
+    );
+}
+export {
+  DurableConflictError,
+  DurableLimitError,
+  DurableNotFoundError,
+  DurableRecoveryError,
+  DurableRun,
+  DurableRunError,
+  DurableRuntime,
+  DurableStorageError,
+  DurableTaskGraph,
+  DurableTaskHandle,
+  defineTask
+};
+//# sourceMappingURL=index.js.map