@ferricstore/ferricstore 0.11.11 → 0.12.1

package/dist/langgraph.d.ts

@@ -0,0 +1,158 @@
+import { BaseCheckpointSaver, CheckpointTuple, Checkpoint, CheckpointMetadata, BaseStore, Operation, OperationResults, Command } from '@langchain/langgraph';
+import { RunnableConfig } from '@langchain/core/runnables';
+import { F as FerricStoreCommandClient, a as FerricStoreLockOptions } from './durability-DplL0SbW.js';
+import { O as Outcome } from './outcomes-BbFDp3AH.js';
+import './internal-lEEDZpPH.js';
+
+type LangGraphPendingWrite = [channel: string, value: unknown];
+type LangGraphChannelVersions = Record<string, string | number>;
+type SerializerProtocol = BaseCheckpointSaver["serde"];
+interface FerricStoreSaverOptions extends FerricStoreLockOptions {
+    /** FerricStore key prefix. Defaults to `langgraph:checkpoint`. */
+    keyPrefix?: string;
+    /** Number of catalog/hash entries read per page. Defaults to 256. */
+    scanCount?: number;
+    /** Optional LangGraph serializer. The framework JSON-plus serializer is used by default. */
+    serde?: SerializerProtocol;
+}
+/** Durable, epoch-fenced LangGraph.js checkpoint saver backed by FerricStore. */
+declare class FerricStoreSaver extends BaseCheckpointSaver {
+    readonly client: FerricStoreCommandClient;
+    readonly keyPrefix: string;
+    readonly scanCount: number;
+    private readonly lockOptions;
+    constructor(client: FerricStoreCommandClient, options?: FerricStoreSaverOptions);
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig, options?: {
+        limit?: number;
+        before?: RunnableConfig;
+        filter?: Record<string, unknown>;
+    }): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, _newVersions: LangGraphChannelVersions): Promise<RunnableConfig>;
+    putWrites(config: RunnableConfig, writes: LangGraphPendingWrite[], taskId: string): Promise<void>;
+    deleteThread(threadId: string): Promise<void>;
+    private catalogKey;
+    private threadCatalogKey;
+    private threadLocatorCatalogKey;
+    private threadLockKey;
+    private threadKey;
+    private checkpointIndexKey;
+    private threadEpochKey;
+    private atomicCheckpointIndexKey;
+    private atomicPendingWriteIndexKey;
+    private checkpointRecordKey;
+    private pendingWriteKey;
+    private readThreadEpoch;
+    private ensureThreadEpoch;
+    private assertCurrentEpoch;
+    private serialize;
+    private deserialize;
+    private readRecordAtEpoch;
+    private pendingWritesAtEpoch;
+    private tupleFromRecord;
+    private scanHash;
+    private threadKeys;
+    private checkpointIdsAtEpoch;
+    private collectGlobal;
+}
+
+interface FerricStoreStoreOptions extends FerricStoreLockOptions {
+    /** FerricStore key prefix. Defaults to `langgraph:store`. */
+    keyPrefix?: string;
+    /** Number of catalog entries read per page. Defaults to 256. */
+    scanCount?: number;
+}
+/**
+ * LangGraph.js long-term memory store backed by FerricStore.
+ *
+ * It implements hierarchical namespaces, exact/comparison filters, ordered
+ * pagination, batching, CAS-protected item commits, and append-only discovery
+ * indexes. Vector search is deliberately rejected until a semantic index is
+ * configured rather than silently returning an unranked result.
+ */
+declare class FerricStoreStore extends BaseStore {
+    readonly client: FerricStoreCommandClient;
+    readonly keyPrefix: string;
+    readonly scanCount: number;
+    private readonly lockOptions;
+    constructor(client: FerricStoreCommandClient, options?: FerricStoreStoreOptions);
+    batch<Op extends Operation[]>(operations: Op): Promise<OperationResults<Op>>;
+    private catalogKey;
+    private namespaceKey;
+    private itemLockKey;
+    private itemDataKey;
+    private getOperation;
+    private putOperation;
+    private searchOperation;
+    private listNamespacesOperation;
+    private readCatalogItem;
+    private readItemSnapshot;
+    private catalogLocators;
+}
+
+type LangGraphInvocationConfig = RunnableConfig & {
+    context?: unknown;
+} & Record<string, unknown>;
+interface InvokableLangGraph<Input = unknown, Output = unknown> {
+    invoke(input: Input | Command | null, options?: LangGraphInvocationConfig): Promise<Output>;
+    getState?(options: LangGraphInvocationConfig): Promise<unknown>;
+}
+/** Structural subset of WorkflowContext required by the LangGraph bridge. */
+interface FerricFlowHandlerContext {
+    readonly id: string;
+    readonly logicalState: string;
+    readonly partitionKey?: string;
+    readonly payload: unknown;
+    readonly state: string;
+    readonly type: string;
+    readonly values: Record<string, unknown>;
+}
+declare class LangGraphFlowContext {
+    readonly flow: FerricFlowHandlerContext;
+    readonly threadId: string;
+    readonly checkpointNs: string;
+    constructor(flow: FerricFlowHandlerContext, threadId: string, checkpointNs: string);
+    get id(): string;
+    get type(): string;
+    get state(): string;
+    get partitionKey(): string | undefined;
+    get payload(): unknown;
+    get values(): Record<string, unknown>;
+}
+declare class LangGraphFlowRun<Output = unknown> {
+    readonly value: Output;
+    readonly threadId: string;
+    readonly checkpointNs: string;
+    readonly interrupts: readonly unknown[];
+    constructor(value: Output, threadId: string, checkpointNs: string, interrupts: readonly unknown[]);
+    get interrupted(): boolean;
+    get interruptValues(): readonly unknown[];
+}
+type LangGraphOutcomeMapper<Output> = (run: LangGraphFlowRun<Output>, flow: FerricFlowHandlerContext) => Outcome | Promise<Outcome>;
+interface LangGraphFlowOptions<Input, Output> {
+    input?: (flow: FerricFlowHandlerContext) => Input | Promise<Input>;
+    threadId?: (flow: FerricFlowHandlerContext) => string | Promise<string>;
+    checkpointNs?: string | ((flow: FerricFlowHandlerContext) => string | Promise<string>);
+    config?: (flow: FerricFlowHandlerContext) => LangGraphInvocationConfig | undefined | Promise<LangGraphInvocationConfig | undefined>;
+    context?: (flow: FerricFlowHandlerContext) => unknown | Promise<unknown>;
+    onComplete?: LangGraphOutcomeMapper<Output>;
+    onInterrupt?: LangGraphOutcomeMapper<Output>;
+    interruptState?: string;
+    /** Resume an already-checkpointed graph with null input. Defaults to true. */
+    recoverExisting?: boolean;
+    invokeOptions?: LangGraphInvocationConfig;
+}
+/** Bind a LangGraph.js invocation to a leased FerricFlow workflow handler. */
+declare class LangGraphFlow<Input = unknown, Output = unknown> {
+    readonly graph: InvokableLangGraph<Input, Output>;
+    private readonly options;
+    constructor(graph: InvokableLangGraph<Input, Output>, options?: LangGraphFlowOptions<Input, Output>);
+    config(flow: FerricFlowHandlerContext, graphContext?: unknown): Promise<LangGraphInvocationConfig>;
+    invoke(flow: FerricFlowHandlerContext, graphInput?: Input | Command | null, graphContext?: unknown): Promise<LangGraphFlowRun<Output>>;
+    outcome(run: LangGraphFlowRun<Output>, flow: FerricFlowHandlerContext): Promise<Outcome>;
+    handle(flow: FerricFlowHandlerContext, graphInput?: Input | Command | null, graphContext?: unknown): Promise<Outcome>;
+    resume(flow: FerricFlowHandlerContext, value: unknown, graphContext?: unknown): Promise<Outcome>;
+    handler(flow: FerricFlowHandlerContext): Promise<Outcome>;
+}
+
+export { type FerricFlowHandlerContext, FerricStoreCommandClient, FerricStoreLockOptions, FerricStoreSaver, type FerricStoreSaverOptions, FerricStoreStore, type FerricStoreStoreOptions, type InvokableLangGraph, type LangGraphChannelVersions, LangGraphFlow, LangGraphFlowContext, type LangGraphFlowOptions, LangGraphFlowRun, type LangGraphInvocationConfig, type LangGraphOutcomeMapper, type LangGraphPendingWrite };