@alneas/eaos-server 0.0.0-stage → 0.1.0

package/dist/agentic/graph.d.ts

@@ -0,0 +1,524 @@
+import { BaseCheckpointSaver, RetryPolicy } from '@langchain/langgraph';
+import { ApprovalLevel, ApprovalBinding, WorkflowGraphNodeInput, WorkflowGraphEdgeInput, WorkflowGraphDescription, WorkflowGraphRuntimeSnapshot, WorkflowGraphVisualization } from '@alneas/eaos-core';
+
+/**
+ * Serializable workflow identity, history, context, and approval state persisted by the graph checkpointer.
+ * @see AgentGraphEngine.runStep for a complete usage example.
+ */
+interface AgentGraphState {
+    /** Host-authorized checkpoint thread ID. */
+    sessionId: string;
+    /** Verified tenant that owns this workflow. */
+    tenantId: string;
+    /** Verified requesting user, bound into generated approvals. */
+    userId: string;
+    /** Current node identifier used for display and approval continuation. */
+    currentStep: string;
+    /** Ordered conversation/history entries; returned history replaces rather than appends automatically. */
+    history: Array<{
+        /** Speaker/category label supplied by the host or runtime. */
+        role: string;
+        /** Human-readable history text. */
+        content: string;
+        /** ISO timestamp for runtime-generated entries; host entries are not validated here. */
+        timestamp: string;
+    }>;
+    /** Optional domain state merged by key; reserved __eaos keys belong to runtime internals. */
+    context?: Record<string, unknown>;
+    /** Optional supporting source metadata carried through state. */
+    citations?: Array<{
+        /** Display title supplied by the citing node. */
+        title: string;
+        /** Source identifier or URL supplied by the node. */
+        source: string;
+        /** Host/model relevance score; this engine imposes no numeric range. */
+        score: number;
+    }>;
+    /** Optional pending human decision, bound to tenant/user/operation before checkpointing. */
+    pendingApproval?: {
+        /** Optional ticket ID; generated when absent during binding. */
+        approvalId?: string;
+        /** Operation name bound to the approval and requested permission by default. */
+        toolName: string;
+        /** Required human-approval level for the operation. */
+        approvalLevel: ApprovalLevel;
+        /** Risk label; generated binding normalizes unknown labels to high. */
+        riskLevel: string;
+        /** Human-readable approval justification, visible in runtime overlays. */
+        reason: string;
+        /** Operation input used to construct the approval binding. */
+        args: Record<string, unknown>;
+        /** Optional prebuilt binding validated against workflow tenant/user/operation. */
+        binding?: ApprovalBinding;
+        /** Optional resource identity and revision included in generated binding. */
+        target?: {
+            /** Resource category included in the approval binding. */
+            type: string;
+            /** Resource identifier included in the approval binding. */
+            id: string;
+            /** Optional expected resource revision for host approval/admission. */
+            revision?: number;
+        };
+        /** Optional generated binding contract version; defaults to 1.0.0. */
+        contractVersion?: string;
+        /** Optional generated binding permission; defaults to toolName. */
+        permission?: string;
+    };
+    /** Optional host checkpoint revision metadata; this engine does not increment it itself. */
+    checkpointRevision?: number;
+    /** Optional last decision plus approval ID, binding hash, and ISO decision timestamp. */
+    lastApproval?: GraphApprovalDecision & {
+        /**
+         * Identity of the pending review ticket consumed by this completed approval decision.
+         */
+        approvalId: string;
+        /**
+         * Exact approved request/contract binding hash copied from the consumed pending approval.
+         */
+        bindingHash: string;
+        /**
+         * ISO timestamp generated when the graph processes the resumed review decision.
+         */
+        decidedAt: string;
+    };
+    /** True when execution has completed or a decision rejected the workflow. */
+    isComplete: boolean;
+    /** Optional domain/runtime failure description included in runtime display overlays. */
+    error?: string;
+}
+/**
+ * Async node operation receiving an isolated graph-state clone and returning partial state updates.
+ * @param state - Current graph state; mutating it alone does not persist changes unless returned.
+ * @returns Partial update; context is merged, while supplied history replaces the existing history.
+ * @throws Handler failures propagate through LangGraph retry policy and graph execution.
+ * @see AgentGraphEngine.addNode for a complete example.
+ */
+type GraphNodeHandler = (state: AgentGraphState) => Promise<Partial<AgentGraphState>>;
+/**
+ * Synchronous conditional route selector over a cloned graph state.
+ * @param state - Current state after the source node has run.
+ * @returns One exact declared destination name; undeclared destinations fail execution.
+ * @see AgentGraphEngine.addConditionalEdges for a complete example.
+ */
+type GraphRouter = (state: AgentGraphState) => string;
+/** Minimal boundary for a compiled LangGraph subgraph. The plugin owns its state schema.
+ * @see AgentGraphEngine.addSubgraph for setup and usage.
+ */
+interface GraphSubgraph {
+    /**
+     * Invokes the compiled child graph.
+     * @param input - Host-mapped child input.
+     * @param config - Parent-supplied checkpoint thread/namespace configuration.
+     * @returns Child output, interpreted by the parent mapOutput callback.
+     * @throws Child execution/checkpoint failures propagate or can be mapped for recognized interrupts.
+     
+     * @example
+     * ```typescript
+     * import type { GraphSubgraph } from "@alneas/eaos-server";
+     * export async function invokeHostSubgraph(
+     *   subgraph: GraphSubgraph,
+     *   input: Parameters<GraphSubgraph["invoke"]>[0],
+     *   config: Parameters<GraphSubgraph["invoke"]>[1],
+     * ) {
+     *   // Supply the host's admitted input and checkpoint/thread configuration.
+     *   return await subgraph.invoke(input, config);
+     * }
+     * ```
+     */
+    invoke(input: unknown, config?: unknown): Promise<unknown>;
+    /**
+   * Inspects child state when a recognized interrupt needs mapping.
+   * @param config - Child checkpoint thread/namespace configuration.
+   * @returns Host-specific child checkpoint state.
+   * @throws Inspection failures propagate to parent execution.
+   
+     * @example
+     * ```typescript
+     * import type { GraphSubgraph } from "@alneas/eaos-server";
+     * export async function inspectHostSubgraph(
+     *   subgraph: GraphSubgraph, config: Parameters<NonNullable<GraphSubgraph["getState"]>>[0],
+     * ) {
+     *   if (!subgraph.getState) throw new Error("Subgraph state inspection is unavailable");
+     *   return await subgraph.getState(config);
+     * }
+     * ```
+     */
+    getState?(config?: unknown): Promise<unknown>;
+    /**
+   * Continues a child after a verified parent approval.
+   * @param input - Host-mapped child input.
+   * @param decision - Parent-approved human decision.
+   * @param config - Child checkpoint thread/namespace configuration.
+   * @returns Resumed child output.
+   * @throws Child execution/checkpoint failures propagate.
+   
+     * @example
+     * ```typescript
+     * import type { GraphSubgraph } from "@alneas/eaos-server";
+     * export async function resumeHostSubgraph(
+     *   subgraph: GraphSubgraph,
+     *   input: Parameters<NonNullable<GraphSubgraph["resume"]>>[0],
+     *   verifiedDecision: Parameters<NonNullable<GraphSubgraph["resume"]>>[1],
+     *   config: Parameters<NonNullable<GraphSubgraph["resume"]>>[2],
+     * ) {
+     *   if (!subgraph.resume) throw new Error("Subgraph resumption is unavailable");
+     *   // The host authenticates/authorizes this decision before entering the subgraph.
+     *   return await subgraph.resume(input, verifiedDecision, config);
+     * }
+     * ```
+     */
+    resume?(input: unknown, decision: GraphApprovalDecision, config?: unknown): Promise<unknown>;
+}
+/**
+ * Host-verified human decision supplied to a pending graph approval.
+ * @see AgentGraphEngine.resumeAfterApproval.
+ */
+interface GraphApprovalDecision {
+    /** True to continue; false to finish with a rejection error. */
+    approved: boolean;
+    /** Authenticated human approver identifier. */
+    approverId: string;
+    /** Verified role associated with the decision. */
+    approverRole: string;
+    /** Optional human note; rejection uses a default description when blank. */
+    comment?: string;
+}
+/**
+ * Explicit state mapping, child-thread identity, and interrupt translation for {@link AgentGraphEngine.addSubgraph}.
+ */
+interface GraphSubgraphOptions {
+    /** Optional synchronous parent-state to child-input mapping; defaults to passing parent state. */
+    mapInput?: (state: AgentGraphState) => unknown;
+    /** Optional synchronous child-output/parent-state to update mapping; absent treats output as a partial parent state. */
+    mapOutput?: (output: unknown, state: AgentGraphState) => Partial<AgentGraphState>;
+    /** Optional synchronous child thread ID builder; defaults to sessionId:name and must be nonblank. */
+    threadId?: (state: AgentGraphState) => string;
+    /** Called for a recognized nested LangGraph interrupt with error, parent state, and optional child checkpoint; resolves a parent update, normally pendingApproval. Errors propagate. */
+    mapInterrupted?: (error: unknown, state: AgentGraphState, subgraphState: unknown) => Partial<AgentGraphState> | Promise<Partial<AgentGraphState>>;
+    /** Serializable metadata used by workflow viewers; never executed. */
+    visual?: WorkflowGraphNodeInput;
+}
+/**
+ * Checkpoint persistence, live approval authority, and workflow metadata for {@link AgentGraphEngine}.
+ */
+interface AgentGraphEngineOptions {
+    /** Host-owned live membership/lifecycle/resource re-check at resume time. */
+    authorizeResume?: (state: AgentGraphState, input: {
+        /**
+         * Nonblank authenticated approver identifier supplied by the host.
+         */
+        approverId: string;
+        /**
+         * Nonblank verified role associated with this human decision.
+         */
+        approverRole: string;
+        /**
+         * True requests continuation and requires a current authorizer; false rejects the workflow but is also checked when an authorizer exists.
+         */
+        approved: boolean;
+    }) => Promise<boolean>;
+    /** Official LangGraph checkpointer. MemorySaver is local/test-only when omitted. */
+    checkpointer?: BaseCheckpointSaver;
+    /** Stable identity shown by workflow viewers and exported graph documents. */
+    workflowId?: string;
+    /** Optional workflow version included in graph descriptions. */
+    workflowVersion?: string;
+}
+/**
+ * Execution retry and display settings for {@link AgentGraphEngine.addNode}.
+ */
+interface GraphNodeOptions {
+    /** Optional LangGraph retry settings; retries can repeat handler side effects and must be safe by host design. */
+    retryPolicy?: RetryPolicy;
+    /** Serializable metadata used by workflow viewers; never executed. */
+    visual?: WorkflowGraphNodeInput;
+}
+/**
+ * Serializable display metadata for {@link AgentGraphEngine.addEdge}.
+ */
+interface GraphEdgeOptions {
+    /** Serializable metadata used by workflow viewers; never executed. */
+    visual?: WorkflowGraphEdgeInput;
+}
+/**
+ * Display metadata for declared branches in {@link AgentGraphEngine.addConditionalEdges}.
+ */
+interface GraphConditionalEdgeOptions extends GraphEdgeOptions {
+    /** Per-destination labels such as `approved` or `needs_correction`. */
+    labels?: Readonly<Record<string, string>>;
+}
+/**
+ * EAOS workflow runtime backed by the official LangGraph StateGraph.
+ * EAOS remains responsible for authorization, approval bindings and side effects.
+ * @remarks The default MemorySaver is process-local/test storage. Production hosts must supply durable, tenant-scoped checkpoint persistence, verified initial identity, live resume authorization, and writer serialization. This class does not serialize concurrent calls for the same session or implement transactional side effects. Mutating topology invalidates the compiled graph; configure it before starting workflow sessions.
+ * @example
+ * ```typescript
+ * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+ * const graph = new AgentGraphEngine();
+ * graph.addNode("start", async () => ({ isComplete: true }));
+ * console.log(graph.describe().entryNode); // "start"
+ * ```
+ */
+declare class AgentGraphEngine {
+    private readonly nodes;
+    private readonly edges;
+    private readonly edgeVisuals;
+    private readonly nodeOptions;
+    private readonly conditionalRoutes;
+    private readonly checkpointer;
+    private readonly authorizeResume?;
+    private readonly workflowId?;
+    private readonly workflowVersion?;
+    private entryNode;
+    private compiled?;
+    private graphVersion;
+    private compiledVersion;
+    /**
+     * Creates a graph builder with a host saver or options; compilation is deferred until execution/checkpoint reads.
+     * @param checkpointerOrOptions - LangGraph saver or options; omission uses an independent MemorySaver.
+     * @param options - Additional options used only when the first argument is a saver; otherwise ignored.
+     */
+    constructor(checkpointerOrOptions?: BaseCheckpointSaver | AgentGraphEngineOptions, options?: AgentGraphEngineOptions);
+    /**
+     * Registers or replaces a named handler and invalidates compiled topology.
+     * @param name - Nonblank node name; __eaos_approval__ is reserved. Names are retained without trimming.
+     * @param handler - Async callback receiving a cloned state and resolving partial state updates.
+     * @param options - Optional LangGraph retry policy and serializable display metadata.
+     * @returns This builder for chaining.
+     * @throws For blank/reserved names; handler failures occur later during execution.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * graph.addNode("finish", async () => ({ isComplete: true }));
+     * ```
+     */
+    addNode(name: string, handler: GraphNodeHandler, options?: GraphNodeOptions): this;
+    /**
+     * Mount a plugin-owned compiled LangGraph as one parent-graph node.
+     * Input/output mapping is explicit so plugin state does not silently leak into
+     * the EAOS state, while the nested graph still gets its own checkpoint thread.
+     * @param name - Parent node identifier, subject to addNode validation.
+     * @param subgraph - Compiled graph with invoke and optional state/resume capabilities.
+     * @param options - Input/output mapping and child-thread identity; defaults pass state/output through and use sessionId:name as thread ID.
+     * @returns This graph builder.
+     * @throws If subgraph lacks invoke or the name is invalid. Execution propagates mapping/subgraph errors except recognized interrupts handled by mapInterrupted.
+     * @remarks Child config uses checkpoint_ns=name. A mapped interrupt stores resume metadata in context; host mappings must preserve tenant boundaries and avoid leaking child state.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine, type GraphSubgraph } from "@alneas/eaos-server/agentic/graph";
+     * export function nested(subgraph: GraphSubgraph) {
+     *   return new AgentGraphEngine().addSubgraph("start", subgraph, { mapOutput: output => ({ context: { child: output } }) });
+     * }
+     * ```
+     */
+    addSubgraph(name: string, subgraph: GraphSubgraph, options?: GraphSubgraphOptions): this;
+    /**
+     * Adds a declared edge and its display metadata.
+     * @param from - Nonblank source node name.
+     * @param to - Nonblank destination node name.
+     * @param options - Optional serializable display metadata, cloned on insertion.
+     * @returns This graph builder.
+     * @throws For blank endpoints or uncloneable display metadata. Missing node references can fail compilation later.
+     * @remarks Without conditional routing, execution follows only the first declared outgoing edge; describe may list additional declared edges.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * graph.addNode("finish", async () => ({}));
+     * graph.addEdge("start", "finish");
+     * ```
+     */
+    addEdge(from: string, to: string, options?: GraphEdgeOptions): this;
+    /**
+   * Sets a source node's conditional router and complete allowed destination set.
+   * @param from - Nonblank source node name.
+   * @param router - Called synchronously after the node with a state clone; must return one declared destination.
+   * @param destinations - Nonempty list of nonblank destination names; duplicates are collapsed.
+   * @param options - Cloned optional edge metadata and destination labels.
+   * @returns This graph builder.
+   * @throws For invalid source/destinations or uncloneable options; runtime routing rejects undeclared destinations and callback errors.
+   * @remarks A pending approval overrides conditional routing and enters the approval node. This replaces an existing conditional route for from.
+   * @example
+   * ```typescript
+   * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+   * const graph = new AgentGraphEngine();
+   * graph.addNode("start", async () => ({ isComplete: true }));
+   * graph.addNode("finish", async () => ({}));
+   * graph.addConditionalEdges("start", () => "finish", ["finish"]);
+   * ```
+   */
+    addConditionalEdges(from: string, router: GraphRouter, destinations: string[], options?: GraphConditionalEdgeOptions): this;
+    /**
+     * Selects the registered node where future graph execution starts.
+     * @param nodeName - Nonblank node name; existence is checked on deferred compilation.
+     * @returns This builder after invalidating compiled topology.
+     * @throws For a blank name; missing entry registration fails later on compilation.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * graph.setEntryPoint("start");
+     * ```
+     */
+    setEntryPoint(nodeName: string): this;
+    /**
+     * Reads the first statically declared outgoing edge without evaluating conditional routing.
+     * @param fromNode - Exact source node identifier.
+     * @returns First declared destination, or undefined when no static edge exists.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * console.log(graph.getNextNode("start")); // undefined
+     * ```
+     */
+    getNextNode(fromNode: string): string | undefined;
+    /**
+     * Return a serializable graph description for UI/API/diagram consumers.
+     * Handlers and router functions are intentionally omitted: this is metadata,
+     * not a remotely executable workflow definition.
+     * @returns A structured clone of versioned node/edge display metadata in insertion order; may describe an incomplete graph before compilation.
+     * @throws If retained metadata has become uncloneable.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * console.log(graph.describe().nodes.length); // 1
+     * ```
+     */
+    describe(): WorkflowGraphDescription;
+    /**
+   * Extracts runtime status and approval display metadata without history, context, or approval args.
+   * @param state - Authorized checkpoint state to summarize.
+   * @returns Status prioritized as waiting_approval, failed, completed, running, then idle, plus current node/revision and optional error/approval display details.
+   * @remarks Reasons and errors remain visible; the host must control their content and authorize access to this overlay.
+   * @example
+   * ```typescript
+   * import { AgentGraphEngine, type AgentGraphState } from "@alneas/eaos-server/agentic/graph";
+   * export function overlay(state: AgentGraphState) {
+   *   return new AgentGraphEngine().describeRuntime(state);
+   * }
+   * ```
+   */
+    describeRuntime(state: AgentGraphState): WorkflowGraphRuntimeSnapshot;
+    /**
+   * Reads a session checkpoint and combines its display overlay with the current static graph.
+   * @param sessionId - Authorized host session/thread identifier.
+   * @returns Graph description and runtime overlay when a checkpoint exists, or only graph metadata otherwise.
+   * @throws Rejects compilation, saver, or description failures.
+   * @remarks This method does not authenticate the caller or authorize session access.
+   * @example
+   * ```typescript
+   * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+   * const graph = new AgentGraphEngine();
+   * graph.addNode("start", async () => ({ isComplete: true }));
+   * const visualization = await graph.getVisualization("example-session");
+   * console.log(visualization.graph.nodes.length);
+   * ```
+   */
+    getVisualization(sessionId: string): Promise<WorkflowGraphVisualization>;
+    /**
+     * Reads the current saved state for one graph session.
+     * @param sessionId - Authorized LangGraph thread ID.
+     * @returns A structured clone of persisted state, or null when no session state exists.
+     * @throws Rejects deferred compilation, saver, or clone failures.
+     * @remarks The host authorizes tenant/session access; sessionId alone is not an authentication claim.
+     * @example
+     * ```typescript
+     * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+     * const graph = new AgentGraphEngine();
+     * graph.addNode("start", async () => ({ isComplete: true }));
+     * console.log(await graph.getCheckpoint("example-session")); // null
+     * ```
+     */
+    getCheckpoint(sessionId: string): Promise<AgentGraphState | null>;
+    /**
+   * Runs the graph until completion or a LangGraph approval interrupt.
+   * @param initialState - Verified host session/tenant/user state; a nonblank sessionId is required. Existing pendingApproval returns an immediate clone without invoking the graph.
+   * @returns Latest checkpoint state after execution, interrupted approval state, or the supplied initial state when no checkpoint is available.
+   * @throws Rejects invalid sessionId, compilation, handler/retry, saver, binding, or clone errors except recognized approval interrupts.
+   * @remarks This method runs multiple nodes, despite its name. The host must serialize writers and make retried handlers safe for side effects. It installs no timeout or cancellation itself.
+   * @example
+   * ```typescript
+   * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+   * const graph = new AgentGraphEngine();
+   * graph.addNode("start", async () => ({ isComplete: true }));
+   * const state = await graph.runStep({ sessionId: "example-session", tenantId: "example", userId: "example-user", currentStep: "start", history: [], isComplete: false });
+   * console.log(state.isComplete); // true
+   * ```
+   */
+    runStep(initialState: AgentGraphState): Promise<AgentGraphState>;
+    /**
+   * Validates a pending approval binding and host authority before resuming its LangGraph thread.
+   * @param input - Session ID, verified approver ID/role, boolean decision, optional comment, optional expected approvalId/bindingHash, and optional live authorizer overriding constructor settings.
+   * @returns Resumed state on success, or resumed:false with an error for absent/mismatched approval, denied authorization, or normalized invocation failure. A denial decision completes the graph as rejected.
+   * @throws Can reject saver/compilation errors, live authorizer rejection, or post-resume checkpoint failures.
+   * @remarks An approved decision requires a live authorizer returning exactly true; a supplied authorizer also checks rejection decisions. Host writer serialization is required: this method does not acquire an independent lock or compare-and-swap checkpoint revisions. Missing optional expected IDs skip those comparisons. Resume failures can follow side effects; no rollback or automatic retry occurs.
+   * @example
+   * ```typescript
+   * import { AgentGraphEngine } from "@alneas/eaos-server/agentic/graph";
+   * export async function decide(graph: AgentGraphEngine, input: Parameters<AgentGraphEngine["resumeAfterApproval"]>[0]) {
+   *   // Authenticate the approver and supply live authorization before approving.
+   *   return graph.resumeAfterApproval(input);
+   * }
+   * ```
+   */
+    resumeAfterApproval(input: {
+        /**
+         * LangGraph thread/session identity whose saved pending approval is loaded and resumed.
+         */
+        sessionId: string;
+        /**
+         * Optional expected ticket identity; when truthy it must equal the saved pending ticket, while omission skips this comparison.
+         */
+        approvalId?: string;
+        /**
+         * Optional expected request/contract binding hash; when truthy it must match the saved binding, while omission skips this comparison.
+         */
+        bindingHash?: string;
+        /**
+         * Verified review decision; true requires live authorization returning exactly true, while false resumes the graph as rejected.
+         */
+        approved: boolean;
+        /**
+         * Nonblank host-verified reviewer identity supplied to the live authorizer and recorded in lastApproval.
+         */
+        approverId: string;
+        /**
+         * Nonblank host-verified reviewer role supplied to the live authorizer and recorded in lastApproval.
+         */
+        approverRole: string;
+        /**
+         * Optional reviewer comment retained in the graph decision; the host owns content/privacy policy.
+         */
+        comment?: string;
+        /**
+         * Optional live reviewer-authority callback overriding the constructor authorizer for this resume attempt.
+         * @remarks Uses AgentGraphEngineOptions.authorizeResume: receives a cloned checkpoint and reviewer/decision metadata, resolves exactly true to permit resumption, and may reject. Required from either source for approved=true; when supplied it also checks rejected decisions. Omission uses the constructor callback.
+         * @see {@link AgentGraphEngineOptions.authorizeResume}
+         */
+        authorizeResume?: AgentGraphEngineOptions['authorizeResume'];
+    }): Promise<{
+        /** True when verification/resumption reaches a readable checkpoint, including a resumed rejection decision; false on normalized failures and not proof that no side effect occurred. */
+        resumed: boolean;
+        /** Graph state loaded after resumption when available; may represent completion, rejection or another pending interrupt rather than final workflow success. */
+        state?: AgentGraphState;
+        /** Optional explanation for a missing/mismatched approval, denied authority, invocation failure or disappeared checkpoint; some saver/authorizer errors reject instead. */
+        error?: string;
+    }>;
+    private invalidate;
+    private config;
+    private ensureCompiled;
+    private runNode;
+    private runApprovalNode;
+    private bindApproval;
+}
+
+export { AgentGraphEngine };
+export type { AgentGraphEngineOptions, AgentGraphState, GraphApprovalDecision, GraphConditionalEdgeOptions, GraphEdgeOptions, GraphNodeHandler, GraphNodeOptions, GraphRouter, GraphSubgraph, GraphSubgraphOptions };

package/dist/agentic/graph.js

@@ -0,0 +1,7 @@
+import {
+  AgentGraphEngine
+} from "../chunk-HXFVOR7Z.js";
+export {
+  AgentGraphEngine
+};
+//# sourceMappingURL=graph.js.map

package/dist/agentic/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agentic/index.d.ts

@@ -0,0 +1,24 @@
+export { ServerAgentDispatchMode, ServerAgentExecutionContext, ServerAgentExecutionError, ServerAgentExecutor, ServerAgentTaskRequest, ServerAgentTaskResult, ServerAgentWorkerType, ServerApprovalCallbackPayload } from './types.js';
+export { ServerAutonomousWorker, ServerRuntimeRole, ServerWorkerOptions } from './autonomous-worker.js';
+export { CommandAgentExecutorOptions, CommandAgentSandboxMode, CommandAgentSandboxOptions, buildSystemdRunArgs, createCommandAgentExecutor, validateAgentRuntimePolicy } from './executor.js';
+export { ServerWorkflowAgentRunnerOptions, createWorkflowAgentRunner } from './agent-runner.js';
+export { WorkflowAgentNodeOptions, createWorkflowAgentNode } from './agent-node.js';
+export { ServerWorkflowManager, ServerWorkflowOptions } from './workflow-manager.js';
+export { AgentGraphEngine, AgentGraphEngineOptions, AgentGraphState, GraphApprovalDecision, GraphConditionalEdgeOptions, GraphEdgeOptions, GraphNodeHandler, GraphNodeOptions, GraphRouter, GraphSubgraph, GraphSubgraphOptions } from './graph.js';
+export { AgentJobClaimFilter, AgentJobDispatchResult, AgentJobDispatcherOptions, AgentJobStore, AtomicAgentJobStoreOptions, DurableAgentJobDispatcher, cancelAgentJob, createAgentJob, createAtomicAgentJobStore, enqueueAgentJob } from './agent-jobs.js';
+export { LocalRunnerIdentity, LocalRunnerJobKind, LocalRunnerPullCoordinator, LocalRunnerPullCoordinatorOptions } from './local-runner.js';
+export { AIJobPlan, AIJobSubmission, AIJobTaskInput, DurableAIExecutionBroker, ServerAIExecutionRoute } from './ai-broker.js';
+export { GraphProjectionCoordinator, GraphProjectionCoordinatorOptions, ProjectionCursorStore } from './graph-projection.js';
+export { DurableWorkflowCoordinator, DurableWorkflowCoordinatorOptions, StoredWorkflowInstance, WorkflowInstanceStore } from './workflow-coordinator.js';
+export { EventAgentBridge, EventAgentBridgeError, EventAgentBridgeOptions, EventAgentPendingApproval, EventAgentRule, EventAgentTaskStore, InMemoryEventAgentTaskStore, QueuedEventTask } from './event-bridge.js';
+export { HttpAgentExecutorOptions, HttpAgentRuntimeRequest, HttpAgentRuntimeResponse, createHttpAgentExecutor } from './remote-executor.js';
+export { WorkflowNodeCatalog, WorkflowNodeDescriptor, WorkflowNodeRegistration, WorkflowNodeResolverInput } from './workflow-catalog.js';
+export { CompiledWorkflow, WorkflowCompilerOptions, compileWorkflowDefinition } from './workflow-compiler.js';
+export { InMemoryWorkflowDefinitionRegistry, WorkflowDefinitionRecord, WorkflowDefinitionRegistry } from './workflow-registry.js';
+import '@alneas/eaos-core';
+import '@langchain/langgraph';
+import '../plugin-data/index.js';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';

package/dist/agentic/index.js

@@ -0,0 +1,86 @@
+import "../chunk-7FTJN4SA.js";
+import {
+  InMemoryWorkflowDefinitionRegistry
+} from "../chunk-HVC7FG6B.js";
+import {
+  LocalRunnerPullCoordinator
+} from "../chunk-ZHMTD5KV.js";
+import {
+  createHttpAgentExecutor
+} from "../chunk-IJWYS2PF.js";
+import {
+  WorkflowNodeCatalog
+} from "../chunk-7AHSS7SO.js";
+import {
+  compileWorkflowDefinition
+} from "../chunk-CJ7OFEF7.js";
+import {
+  DurableWorkflowCoordinator
+} from "../chunk-EJKWDZIU.js";
+import {
+  ServerWorkflowManager
+} from "../chunk-FD6VC2NA.js";
+import {
+  createWorkflowAgentRunner
+} from "../chunk-6XZXYNJR.js";
+import {
+  DurableAIExecutionBroker
+} from "../chunk-LYPZPE53.js";
+import {
+  ServerAutonomousWorker
+} from "../chunk-THYUY5ZZ.js";
+import {
+  EventAgentBridge,
+  InMemoryEventAgentTaskStore
+} from "../chunk-3P4XTTQH.js";
+import {
+  buildSystemdRunArgs,
+  createCommandAgentExecutor,
+  validateAgentRuntimePolicy
+} from "../chunk-32746UQZ.js";
+import {
+  ServerAgentExecutionError
+} from "../chunk-YABTQZDJ.js";
+import {
+  GraphProjectionCoordinator
+} from "../chunk-W6O3LVBY.js";
+import {
+  AgentGraphEngine
+} from "../chunk-HXFVOR7Z.js";
+import {
+  DurableAgentJobDispatcher,
+  cancelAgentJob,
+  createAgentJob,
+  createAtomicAgentJobStore,
+  enqueueAgentJob
+} from "../chunk-PBC3MZUL.js";
+import {
+  createWorkflowAgentNode
+} from "../chunk-UGNTCOVR.js";
+export {
+  AgentGraphEngine,
+  DurableAIExecutionBroker,
+  DurableAgentJobDispatcher,
+  DurableWorkflowCoordinator,
+  EventAgentBridge,
+  GraphProjectionCoordinator,
+  InMemoryEventAgentTaskStore,
+  InMemoryWorkflowDefinitionRegistry,
+  LocalRunnerPullCoordinator,
+  ServerAgentExecutionError,
+  ServerAutonomousWorker,
+  ServerWorkflowManager,
+  WorkflowNodeCatalog,
+  buildSystemdRunArgs,
+  cancelAgentJob,
+  compileWorkflowDefinition,
+  createAgentJob,
+  createAtomicAgentJobStore,
+  createCommandAgentExecutor,
+  createHttpAgentExecutor,
+  createWorkflowAgentNode,
+  createWorkflowAgentRunner,
+  enqueueAgentJob,
+  validateAgentRuntimePolicy
+};
+//# sourceMappingURL=index.js.map

package/dist/agentic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}