export declare const START: "__start__";
export declare const END: "__end__";
export type StartNode = typeof START;
export type EndNode = typeof END;
export type NodeName = string | StartNode | EndNode;
export type Annotated<T, _Reducer> = T;
export interface Channel<T> {
    reducer: (current: T, update: T) => T;
    default: () => T;
    /** If true, resets to default() at the start of every superstep */
    ephemeral?: boolean;
}
export declare function lastValue<T>(defaultVal: () => T): Channel<T>;
export declare function appendList<T>(defaultVal?: () => T[]): Channel<T[]>;
export declare function mergeObject<T extends Record<string, unknown>>(defaultVal: () => T): Channel<T>;
/** Resets to default at the start of every superstep — good for per-step scratch data */
export declare function ephemeralValue<T>(defaultVal: () => T): Channel<T>;
export type ChannelSchema<S> = {
    [K in keyof S]: Channel<S[K]>;
};
export declare class Send {
    readonly node: string;
    readonly args: Record<string, unknown>;
    constructor(node: string, args: Record<string, unknown>);
}
export interface CommandOptions<S> {
    /** State update to apply */
    update?: Partial<S>;
    /** Go to a specific node (or END) */
    goto?: NodeName | NodeName[];
    /** Dynamic fan-out sends */
    send?: Send[];
    /** Emit a resume value for human-in-the-loop */
    resume?: unknown;
    /** Target graph for the update — use Command.PARENT to push to parent */
    graph?: typeof Command.PARENT;
}
export declare class Command<S> {
    static readonly PARENT: "__parent__";
    readonly update?: Partial<S>;
    readonly goto?: NodeName | NodeName[];
    readonly send?: Send[];
    readonly resume?: unknown;
    readonly graph?: typeof Command.PARENT | undefined;
    constructor(opts: CommandOptions<S>);
}
export type NodeReturn<S> = Partial<S> | Command<S> | void;
export type NodeFn<S> = (state: S, config?: ONIConfig) => Promise<NodeReturn<S>> | NodeReturn<S>;
export interface NodeDefinition<S> {
    name: string;
    fn: NodeFn<S>;
    retry?: RetryPolicy;
    /** If set, this node IS a compiled subgraph */
    subgraph?: ONISkeleton<S>;
    cache?: boolean | CachePolicy;
    /** Hard timeout in ms — node is aborted if it exceeds this */
    timeout?: number;
    circuitBreaker?: {
        threshold: number;
        resetAfter: number;
        fallback?: (state: S, error: Error) => NodeReturn<S>;
    };
}
export interface RetryPolicy {
    maxAttempts: number;
    /** Initial delay in ms */
    initialDelay?: number;
    /** Multiplier for exponential backoff (default 2) */
    backoffMultiplier?: number;
    /** Max delay cap in ms (default 30_000) */
    maxDelay?: number;
    /** Predicate: only retry if this returns true */
    retryOn?: (error: Error) => boolean;
    /** Whether to add random jitter to backoff delay (default true) */
    jitter?: boolean;
}
export interface CachePolicy {
    /** Cache key function — defaults to JSON.stringify(state) */
    key?: (state: unknown) => string;
    /** TTL in ms — cache entries expire after this. Default: Infinity (per-invocation) */
    ttl?: number;
}
export interface StaticEdge {
    type: "static";
    from: NodeName;
    to: NodeName;
}
export interface ConditionalEdge<S> {
    type: "conditional";
    from: NodeName;
    condition: (state: S, config?: ONIConfig) => NodeName | NodeName[] | Send[];
    pathMap?: Record<string, NodeName>;
}
export type Edge<S> = StaticEdge | ConditionalEdge<S>;
export interface DynamicInterrupt<S> {
    node: string;
    timing: "before" | "after";
    condition: (state: S) => boolean;
}
export interface InterruptConfig {
    interruptBefore?: string[];
    interruptAfter?: string[];
}
export interface ONIConfig {
    threadId?: string;
    recursionLimit?: number;
    metadata?: Record<string, unknown>;
    tags?: string[];
    agentId?: string;
    parentRunId?: string;
    /** Abort signal — propagated to LLM calls and async operations inside nodes */
    signal?: AbortSignal;
    /** Dynamic runtime interrupt conditions */
    dynamicInterrupts?: DynamicInterrupt<unknown>[];
}
export interface ONICheckpoint<S> {
    threadId: string;
    step: number;
    state: S;
    nextNodes: string[];
    timestamp: number;
    agentId?: string;
    /** Pending Send queue at time of checkpoint */
    pendingSends?: Array<{
        node: string;
        args: Record<string, unknown>;
    }>;
    /** Arbitrary metadata from config — useful for filtering and debugging */
    metadata?: Record<string, unknown>;
    /** Per-node channel writes from the last superstep */
    pendingWrites?: Array<{
        nodeId: string;
        writes: Record<string, unknown>;
    }>;
}
export interface CheckpointListOptions {
    limit?: number;
    before?: number;
    filter?: Record<string, unknown>;
}
export interface ONICheckpointer<S> {
    get(threadId: string): Promise<ONICheckpoint<S> | null>;
    put(checkpoint: ONICheckpoint<S>): Promise<void>;
    list(threadId: string, opts?: CheckpointListOptions): Promise<ONICheckpoint<S>[]>;
    delete(threadId: string): Promise<void>;
}
export type StreamMode = "values" | "updates" | "debug" | "messages" | "custom";
export interface ONIStreamEvent<S> {
    event: "node_start" | "node_end" | "state_update" | "error" | "interrupt" | "send";
    node?: string;
    data: Partial<S> | S | Error | ONIInterruptEvent | Send;
    step: number;
    timestamp: number;
    agentId?: string;
    /** Set when using multiple stream modes — indicates which mode produced this event */
    mode?: StreamMode;
}
export interface ONIInterruptEvent {
    node: string;
    timing: "before" | "after";
    state: unknown;
}
export interface CustomStreamEvent {
    event: "custom";
    node: string;
    name: string;
    data: unknown;
    step: number;
    timestamp: number;
    agentId?: string;
    mode?: StreamMode;
}
export interface MessageStreamEvent {
    event: "messages" | "messages/complete" | "messages/metadata";
    node: string;
    data: {
        chunk: string;
        content: string;
        role: "assistant";
        id: string;
    };
    step: number;
    timestamp: number;
    agentId?: string;
    mode?: StreamMode;
}
export interface ONISkeleton<S> {
    invoke(input: Partial<S>, config?: ONIConfig): Promise<S>;
    stream(input: Partial<S>, config?: ONIConfig & {
        streamMode?: StreamMode | StreamMode[];
    }): AsyncGenerator<ONIStreamEvent<S> | CustomStreamEvent | MessageStreamEvent>;
    batch(inputs: Partial<S>[], config?: ONIConfig): Promise<S[]>;
    getState(config: {
        threadId: string;
    }): Promise<S | null>;
    updateState(config: {
        threadId: string;
    }, update: Partial<S>): Promise<void>;
    /** Time-travel: get state as it was at a specific superstep */
    getStateAt(config: {
        threadId: string;
        step: number;
    }): Promise<S | null>;
    /** Get full checkpoint history for a thread */
    getHistory(config: {
        threadId: string;
    }): Promise<ONICheckpoint<S>[]>;
    /** Fork: replay execution from a historical checkpoint */
    forkFrom(config: {
        threadId: string;
        step: number;
        newThreadId: string;
    }): Promise<void>;
}
//# sourceMappingURL=types.d.ts.map