@anvia/durable 0.0.0-bootstrap.0 → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,182 @@
+import { D as DurableSnapshot, a as DurableEvent, b as DurableGraphSnapshot, c as DurableGraphEvent, d as DurableStore, R as RegisteredTask, e as DurableAgentRegistration, T as TaskRecord, f as DurableOperation, g as TaskGraphSnapshot, h as TaskEvent, i as DurableRuntimeOptions, j as DefinedTask, k as DurableRunScope, l as TaskListOptions, m as TaskPage, n as DurableSubmission, o as DurableSubmitOptions, p as DurableGraphSubmission, q as DurableGraphListOptions, r as DurableGraphPage, s as DurableListOptions, t as DurableRunPage, u as DurableMetrics, v as TaskDefinition } from './types-CBjKEKQ7.js';
+export { w as DurableGraphNode, x as DurableGraphRecord, y as DurableLimits, z as DurableModelRetry, A as DurableRunRecord, B as DurableRunStatus, C as DurableRunSummary, E as DurableTask, F as DurableTaskWait, G as DurableTransaction, H as TaskContext, I as TaskOutcome, J as TaskTransaction, K as TaskTransition, L as TaskWait, M as ToolRecovery } from './types-CBjKEKQ7.js';
+import { T as TaskSubmission } from './task-protocol-Cewz7y6v.js';
+import { AgentOutcome } from '@anvia/core/agent';
+import { AgentInteractionResponse } from '@anvia/core/agent/interactions';
+import { ToolResultOutput, JsonValue } from '@anvia/core/completion';
+import 'zod';
+
+type DurableStreamOptions = {
+    after?: number;
+    abortSignal?: AbortSignal;
+};
+/** An identity and subscription handle. Closing a subscription never cancels execution. */
+declare class DurableRun {
+    readonly id: string;
+    private readonly runtime;
+    constructor(id: string, runtime: DurableRuntime);
+    snapshot(): Promise<DurableSnapshot>;
+    stream(options?: DurableStreamOptions): AsyncIterable<DurableEvent>;
+    result(options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<AgentOutcome<unknown>>;
+    respond(interactionId: string, response: AgentInteractionResponse): Promise<void>;
+    resolveTool(operationId: string, output: ToolResultOutput): Promise<void>;
+    retry(): Promise<void>;
+    cancel(): Promise<void>;
+}
+
+/** A persisted static DAG. Each node is an ordinary durable agent run in an isolated session. */
+declare class DurableTaskGraph {
+    readonly id: string;
+    private readonly runtime;
+    constructor(id: string, runtime: DurableRuntime);
+    snapshot(): Promise<DurableGraphSnapshot>;
+    cancel(): Promise<void>;
+    stream(options?: DurableStreamOptions): AsyncIterable<DurableGraphEvent>;
+}
+
+/** Owns phase invocations only; DurableRuntime owns the shared database lifecycle. */
+declare class TaskScheduler {
+    private readonly store;
+    private readonly definitions;
+    private readonly capacity;
+    private readonly fatal;
+    private readonly agents;
+    private readonly agentActive;
+    private readonly syncAgents;
+    private readonly active;
+    private readonly deadlines;
+    private timer;
+    private closing;
+    constructor(store: DurableStore, definitions: ReadonlyMap<string, RegisteredTask>, capacity: number, fatal: (error: unknown) => void, agents: ReadonlyMap<string, DurableAgentRegistration>, agentActive: (id: string) => boolean, syncAgents: (root: string) => void);
+    get activeCount(): number;
+    agentChanged(id: string): void;
+    submit(name: string, version: number, input: unknown, sessionId: string, key: string): string;
+    resume(): void;
+    stop(reason: unknown): void;
+    close(): Promise<void>;
+    snapshot(id: string): {
+        task: TaskRecord;
+        operations: DurableOperation[];
+        cursor: number;
+    };
+    graph(id: string): TaskGraphSnapshot;
+    cancel(id: string, expectedTreeIds?: readonly string[]): void;
+    signal(id: string, name: string, requestId: string, value: JsonValue): void;
+    retry(id: string): void;
+    resolveEffect(id: string, key: string, value: JsonValue): void;
+    private reconcile;
+    private pump;
+    private launch;
+    private execute;
+}
+
+/** Typed output is available for submitted definitions; reacquired IDs return JSON. */
+declare class DurableTaskHandle<R = JsonValue> {
+    readonly id: string;
+    private readonly scheduler;
+    private readonly store;
+    private readonly assertOpen;
+    constructor(id: string, scheduler: TaskScheduler, store: DurableStore, assertOpen: () => void);
+    snapshot(): Promise<{
+        task: TaskRecord;
+        operations: DurableOperation[];
+        cursor: number;
+    }>;
+    graph(): Promise<TaskGraphSnapshot>;
+    /** Optional identity fence for callers authorizing a captured ownership tree. */
+    cancel(options?: {
+        expectedTreeIds?: readonly string[];
+    }): Promise<void>;
+    retry(): Promise<void>;
+    resolveEffect(key: string, value: JsonValue): Promise<void>;
+    signal(name: string, requestId: string, value: JsonValue): Promise<void>;
+    result(options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<R>;
+    /** Streams the entire owned tree, including children created after attachment. */
+    stream(options?: DurableStreamOptions): AsyncIterable<TaskEvent>;
+}
+
+declare class DurableRuntime {
+    private readonly maxConcurrentRuns;
+    private readonly onFatalError?;
+    private readonly agents;
+    private readonly active;
+    private closing;
+    private closed;
+    private readonly store;
+    private closePromise;
+    private failure;
+    private wakeTimer;
+    private readonly tasks;
+    private constructor();
+    static open(options: DurableRuntimeOptions): Promise<DurableRuntime>;
+    submitTask<I, S, R>(definition: DefinedTask<I, S, R>, input: {
+        sessionId: string;
+        requestId: string;
+        input: I;
+    }): Promise<DurableTaskHandle<R>>;
+    submitRegisteredTask(input: TaskSubmission): Promise<DurableTaskHandle>;
+    /** Owning scope for authorization without loading operation journals or graph results. */
+    runScope(runId: string): DurableRunScope;
+    getTask(id: string): Promise<DurableTaskHandle>;
+    listTasks(options?: TaskListOptions): Promise<TaskPage>;
+    taskGraph(id: string): Promise<TaskGraphSnapshot>;
+    submit(input: DurableSubmission, options?: DurableSubmitOptions): Promise<DurableRun>;
+    submitGraph(input: DurableGraphSubmission): Promise<DurableTaskGraph>;
+    getGraph(id: string): Promise<DurableTaskGraph>;
+    listGraphs(options?: DurableGraphListOptions): Promise<DurableGraphPage>;
+    graphSnapshot(id: string): DurableGraphSnapshot;
+    graphEvents(id: string, after: number): DurableEvent[];
+    cancelGraph(id: string): void;
+    listRuns(options?: DurableListOptions): Promise<DurableRunPage>;
+    getRun(id: string): Promise<DurableRun>;
+    /** Discover recoverable work. This does not wait for runs or approvals to finish. */
+    resume(): Promise<void>;
+    /** Abort in-flight attempts, retain checkpoints, and release ownership after callbacks settle. */
+    close(): Promise<void>;
+    snapshot(id: string): DurableSnapshot;
+    events(id: string, after: number): DurableEvent[];
+    respond(id: string, interactionId: string, value: AgentInteractionResponse): void;
+    resolveTool(id: string, operationId: string, output: ToolResultOutput): void;
+    retry(id: string): void;
+    cancel(id: string): void;
+    private pump;
+    private launch;
+    private execute;
+    metrics(): DurableMetrics;
+    /** Does not touch storage, so supervisors can inspect a failed owner. */
+    health(): {
+        status: "failed" | "closed" | "closing" | "ready";
+        ready: boolean;
+        activeRuns: number;
+        activeTasks: number;
+    };
+    private fail;
+    private assertOpen;
+}
+
+declare function defineTask<I, S, R>(definition: TaskDefinition<I, S, R>): DefinedTask<I, S, R>;
+
+declare class DurableRecoveryError extends Error {
+    readonly operationId?: string | undefined;
+    constructor(message: string, operationId?: string | undefined);
+}
+declare class DurableRunError extends Error {
+    readonly runId: string;
+    readonly status: "failed" | "cancelled";
+    constructor(runId: string, status: "failed" | "cancelled", message: string);
+}
+declare class DurableNotFoundError extends Error {
+}
+declare class DurableConflictError extends Error {
+}
+/** Fatal journal failure; application retries cannot repair a poisoned runtime. */
+declare class DurableStorageError extends Error {
+}
+declare class DurableLimitError extends Error {
+}
+
+export { DefinedTask, DurableAgentRegistration, DurableConflictError, DurableEvent, DurableGraphEvent, DurableGraphListOptions, DurableGraphPage, DurableGraphSnapshot, DurableGraphSubmission, DurableLimitError, DurableListOptions, DurableMetrics, DurableNotFoundError, DurableOperation, DurableRecoveryError, DurableRun, DurableRunError, DurableRunPage, DurableRunScope, DurableRuntime, DurableRuntimeOptions, DurableSnapshot, DurableStorageError, DurableStore, type DurableStreamOptions, DurableSubmission, DurableSubmitOptions, DurableTaskGraph, DurableTaskHandle, RegisteredTask, TaskDefinition, TaskEvent, TaskGraphSnapshot, TaskListOptions, TaskPage, TaskRecord, defineTask };