@picoflow/ezgraph 0.0.4

package/dist/types/src/framework/model-catalog.d.ts

@@ -0,0 +1,252 @@
+import { z } from "zod";
+export declare const GRAPH_LLM_PROVIDERS: readonly ["openai", "anthropic", "google", "azure_openai", "bedrock", "ollama", "cohere", "cerebras", "deepseek", "fireworks", "groq", "mistral", "mistralai", "perplexity", "together", "xai", "scripted"];
+export type GraphLlmProvider = (typeof GRAPH_LLM_PROVIDERS)[number];
+export declare const GRAPH_LLM_FAMILIES: readonly ["chat", "reasoning", "thinking"];
+export type GraphLlmFamily = (typeof GRAPH_LLM_FAMILIES)[number];
+export declare const GRAPH_LLM_CAPABILITIES: readonly ["imageInputs", "imageUrlInputs", "pdfInputs", "audioInputs", "videoInputs", "reasoningOutput", "toolCalling", "toolChoice", "structuredOutput"];
+export type GraphLlmCapability = (typeof GRAPH_LLM_CAPABILITIES)[number];
+export type GraphLlmRequiredCapabilities = Readonly<Partial<Record<GraphLlmCapability, true>>>;
+export type CommonModelParameters = Readonly<{
+    retries: number;
+    maxOutputTokens?: number;
+    forceToolCalls?: boolean;
+    requiredCapabilities?: GraphLlmRequiredCapabilities;
+}>;
+export type OpenAIChatParameters = CommonModelParameters & Readonly<{
+    temperature?: number;
+    serviceTier?: "auto" | "default" | "flex" | "priority";
+    promptCacheKey?: string;
+}>;
+export type OpenAIReasoningParameters = CommonModelParameters & Readonly<{
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    serviceTier?: "auto" | "default" | "flex" | "priority";
+    promptCacheKey?: string;
+}>;
+export type AnthropicChatParameters = CommonModelParameters & Readonly<{
+    temperature?: number;
+    outputEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+}>;
+export type AnthropicThinkingParameters = CommonModelParameters & Readonly<{
+    thinking?: Readonly<{
+        type: "adaptive";
+    }> | Readonly<{
+        type: "disabled";
+    }> | Readonly<{
+        type: "enabled";
+        budget_tokens: number;
+    }>;
+    outputEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+}>;
+export type GoogleChatParameters = CommonModelParameters & Readonly<{
+    temperature?: number;
+    thinkingBudget?: number;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high";
+    safetySettings?: readonly Readonly<{
+        category: string;
+        threshold: string;
+    }>[];
+}>;
+export type BasicChatParameters = CommonModelParameters & Readonly<{
+    temperature?: number;
+}>;
+export type BuiltInModelParameters = Readonly<{
+    "openai:gpt-4o": OpenAIChatParameters;
+    "openai:gpt-4o-mini": OpenAIChatParameters;
+    "openai:gpt-5.1": OpenAIReasoningParameters;
+    "openai:gpt-5.4": OpenAIReasoningParameters;
+    "anthropic:claude-sonnet-4-5": AnthropicChatParameters;
+    "anthropic:claude-opus-4-1": AnthropicThinkingParameters;
+    "google:gemini-3.1-flash-lite": GoogleChatParameters;
+    "google:gemini-3.5-flash": GoogleChatParameters;
+    "scripted:scripted-model": BasicChatParameters;
+}>;
+export type BuiltInModelId = keyof BuiltInModelParameters;
+declare const builtInConfig: unique symbol;
+export type BuiltInGraphLlmConfig = {
+    readonly [Model in BuiltInModelId]: Readonly<{
+        model: Model;
+        params: BuiltInModelParameters[Model];
+        [builtInConfig]: true;
+    }>;
+}[BuiltInModelId];
+export type GraphLlmParameters = CommonModelParameters & Readonly<Record<string, unknown>>;
+export type ModelParameterProfile = Readonly<{
+    provider: string;
+    family: GraphLlmFamily;
+    paramsSchema: Readonly<Record<string, unknown>>;
+    parameterMappings: Readonly<Record<string, string | null>>;
+}>;
+export type ModelCatalogDocument = Readonly<{
+    $schema?: string;
+    version: 1;
+    profiles?: Readonly<Record<string, ModelParameterProfile>>;
+    models: Readonly<Record<string, Readonly<{
+        profile: string;
+        providerModel?: string;
+    }>>>;
+}>;
+export type ModelProviderInitialization = Readonly<{
+    model: string;
+    options: Readonly<Record<string, unknown>>;
+    cacheKey?: string;
+}>;
+export type ModelProviderAdapter = Readonly<{
+    initialize(input: Readonly<{
+        provider: string;
+        model: string;
+        options: Readonly<Record<string, unknown>>;
+    }>): ModelProviderInitialization;
+}>;
+export declare class ModelProviderRegistry {
+    private readonly adapters;
+    static create(): ModelProviderRegistry;
+    register(provider: string, adapter: ModelProviderAdapter): this;
+    adapter(provider: string): ModelProviderAdapter | undefined;
+}
+export type ResolvedModelDescriptor = Readonly<{
+    id: string;
+    providerModel: string;
+    provider: string;
+    family: GraphLlmFamily;
+    paramsSchema: z.ZodType;
+    parameterMappings: Readonly<Record<string, string | null>>;
+    providerAdapter?: ModelProviderAdapter;
+}>;
+declare const runtimeDescriptor: unique symbol;
+export type RuntimeGraphLlmConfig = Readonly<{
+    model: string;
+    params: GraphLlmParameters;
+    [runtimeDescriptor]: ResolvedModelDescriptor;
+}>;
+export type GraphLlmConfig = BuiltInGraphLlmConfig | RuntimeGraphLlmConfig;
+export declare const BUILT_IN_MODEL_CATALOG: {
+    readonly version: 1;
+    readonly profiles: {
+        readonly "openai.chat": {
+            readonly provider: "openai";
+            readonly family: "chat";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly temperature: "temperature";
+                readonly serviceTier: "service_tier";
+                readonly promptCacheKey: "promptCacheKey";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+        readonly "openai.reasoning": {
+            readonly provider: "openai";
+            readonly family: "reasoning";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly reasoningEffort: "reasoningEffort";
+                readonly serviceTier: "service_tier";
+                readonly promptCacheKey: "promptCacheKey";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+        readonly "anthropic.chat": {
+            readonly provider: "anthropic";
+            readonly family: "chat";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly temperature: "temperature";
+                readonly outputEffort: "outputConfig.effort";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+        readonly "anthropic.thinking": {
+            readonly provider: "anthropic";
+            readonly family: "thinking";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly thinking: "thinking";
+                readonly outputEffort: "outputConfig.effort";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+        readonly "google.chat": {
+            readonly provider: "google";
+            readonly family: "chat";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxOutputTokens";
+                readonly temperature: "temperature";
+                readonly thinkingBudget: "thinkingConfig.thinkingBudget";
+                readonly reasoningEffort: "thinkingConfig.reasoningEffort";
+                readonly safetySettings: "safetySettings";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+        readonly "scripted.chat": {
+            readonly provider: "scripted";
+            readonly family: "chat";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly temperature: "temperature";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
+    };
+    readonly models: {
+        readonly "openai:gpt-4o": {
+            readonly profile: "openai.chat";
+        };
+        readonly "openai:gpt-4o-mini": {
+            readonly profile: "openai.chat";
+        };
+        readonly "openai:gpt-5.1": {
+            readonly profile: "openai.reasoning";
+        };
+        readonly "openai:gpt-5.4": {
+            readonly profile: "openai.reasoning";
+        };
+        readonly "anthropic:claude-sonnet-4-5": {
+            readonly profile: "anthropic.chat";
+        };
+        readonly "anthropic:claude-opus-4-1": {
+            readonly profile: "anthropic.thinking";
+        };
+        readonly "google:gemini-3.1-flash-lite": {
+            readonly profile: "google.chat";
+        };
+        readonly "google:gemini-3.5-flash": {
+            readonly profile: "google.chat";
+        };
+        readonly "scripted:scripted-model": {
+            readonly profile: "scripted.chat";
+        };
+    };
+};
+export declare class ModelCatalog {
+    private readonly descriptors;
+    static create(document: unknown, options?: Readonly<{
+        providers?: ModelProviderRegistry;
+    }>): ModelCatalog;
+    static model<Model extends BuiltInModelId>(model: Model, params: BuiltInModelParameters[Model]): Extract<BuiltInGraphLlmConfig, {
+        readonly model: Model;
+    }>;
+    static validateConfig(config: GraphLlmConfig): GraphLlmConfig;
+    static resolveModelDescriptor(config: GraphLlmConfig): ResolvedModelDescriptor;
+    constructor(document: unknown, options?: Readonly<{
+        providers?: ModelProviderRegistry;
+    }>);
+    model(model: string, params: Readonly<Record<string, unknown>>): RuntimeGraphLlmConfig;
+}
+export {};

package/dist/types/src/framework/model-provider.d.ts

@@ -0,0 +1,19 @@
+import { type GraphLlmProvider, type ModelProviderAdapter } from "./graph-llm.config.js";
+export type ModelProviderRuntimeConfig = Readonly<Record<string, unknown>>;
+export type RegisteredModelProviderAdapter = ModelProviderAdapter & Readonly<{
+    provider: string;
+}>;
+export type BuiltInModelProviderConfigs = Readonly<Partial<Record<GraphLlmProvider, ModelProviderRuntimeConfig>>>;
+export type CustomModelProviderOptions = Readonly<{
+    provider: string;
+    runtimeProvider: string;
+    config?: ModelProviderRuntimeConfig;
+}>;
+export declare class ModelProvider {
+    private constructor();
+    static createBuiltinAdapters(configs: BuiltInModelProviderConfigs): RegisteredModelProviderAdapter[];
+    static createCustomAdapter(options: CustomModelProviderOptions): RegisteredModelProviderAdapter;
+    private static adapter;
+}
+export declare function modelProviderAdapter(provider: string, adapters: readonly RegisteredModelProviderAdapter[]): ModelProviderAdapter | undefined;
+export declare function validateModelProviderAdapters(adapters: readonly RegisteredModelProviderAdapter[]): void;

package/dist/types/src/framework/model-stop-reason.d.ts

@@ -0,0 +1,11 @@
+import { AIMessage } from '@langchain/core/messages';
+export type ModelStopCategory = 'complete' | 'blocked' | 'truncated' | 'malformed_tool_call' | 'unspecified';
+export type ModelStopReason = Readonly<{
+    category: ModelStopCategory;
+    provider?: string;
+    detail?: string;
+    ratings?: unknown;
+}>;
+export declare function isRetryableStopReason(reason: ModelStopReason): boolean;
+export declare function modelStopReason(message: AIMessage): ModelStopReason;
+export declare function describeStopReason(reason: ModelStopReason): string;

package/dist/types/src/framework/node-outcome.d.ts

@@ -0,0 +1,41 @@
+import { HumanMessage, type BaseMessage } from '@langchain/core/messages';
+import { END } from '@langchain/langgraph';
+import type { GraphState } from './graph-state.js';
+export declare const GRAPH_NODE_LOCAL_STATE: unique symbol;
+export type GraphNodeTarget<LocalState extends object = object> = {
+    readonly name: string;
+    id(): string;
+    readonly prototype: {
+        readonly [GRAPH_NODE_LOCAL_STATE]: LocalState;
+    };
+};
+export type GraphNodeLocalState<NodeClass extends GraphNodeTarget> = NodeClass['prototype'][typeof GRAPH_NODE_LOCAL_STATE];
+export type GraphNodeUpdate<State extends GraphState> = Partial<State>;
+export type OutcomeRouteTarget = GraphNodeTarget | typeof END;
+export declare const OUTCOME_ROUTE_TARGET: unique symbol;
+type OutcomeState<State extends GraphState> = Pick<State, 'histories' | 'currentNode'>;
+export type NodeOutcomeBuilder<State extends GraphState, LocalState extends object, CanForwardInput extends boolean = false> = Readonly<GraphNodeUpdate<State>> & {
+    withState(patch: Partial<LocalState>): NodeOutcomeBuilder<State, LocalState, CanForwardInput>;
+    withStateFor<NodeClass extends GraphNodeTarget>(NodeClass: NodeClass, patch: Partial<GraphNodeLocalState<NodeClass>>): NodeOutcomeBuilder<State, LocalState, CanForwardInput>;
+    withHistory(space: string, messages: BaseMessage | readonly BaseMessage[]): NodeOutcomeBuilder<State, LocalState, CanForwardInput>;
+    via<NodeClass extends GraphNodeTarget>(NodeClass: NodeClass): NodeOutcomeBuilder<State, LocalState, CanForwardInput>;
+} & (CanForwardInput extends true ? {
+    forwardInput(state: OutcomeState<State>, fallbackMessage?: string): NodeOutcomeBuilder<State, LocalState>;
+} : object);
+type BuilderOptions<State extends GraphState, LocalState extends object, CanForwardInput extends boolean> = Readonly<{
+    update: GraphNodeUpdate<State>;
+    nodeName: string;
+    saveNode: (nodeName: string, patch: Record<string, unknown>) => GraphNodeUpdate<State>;
+    forwardInput?: (state: OutcomeState<State>, fallbackMessage?: string) => GraphNodeUpdate<State>;
+    routeTarget: OutcomeRouteTarget;
+}>;
+export declare function createNodeOutcomeBuilder<State extends GraphState, LocalState extends object, CanForwardInput extends boolean>(options: BuilderOptions<State, LocalState, CanForwardInput>): NodeOutcomeBuilder<State, LocalState, CanForwardInput>;
+export declare function outcomeRouteTarget(update: GraphNodeUpdate<GraphState>): OutcomeRouteTarget | undefined;
+export declare function preserveOutcomeRouteTarget<State extends GraphState, Update extends GraphNodeUpdate<State>>(source: GraphNodeUpdate<State>, update: Update): Update;
+export declare function forwardedHistoryUpdate<State extends GraphState>(options: {
+    sourceSpace: string;
+    targetSpace: string;
+    latestInput?: HumanMessage;
+    fallbackMessage?: string;
+}): GraphNodeUpdate<State>;
+export {};

package/dist/types/src/framework/node-state.d.ts

@@ -0,0 +1,6 @@
+import type { GraphLlmModelMetadata } from './graph-llm.config.js';
+export type NodeStateValue<T extends object = Record<string, unknown>> = T & {
+    model?: GraphLlmModelMetadata | undefined;
+};
+export type GraphNodeStates = Record<string, NodeStateValue>;
+export declare function mergeNodeStates<NodeStates extends object>(current: NodeStates, update: NodeStates): NodeStates;

package/dist/types/src/framework/persistence/cosmos-session-document.container.d.ts

@@ -0,0 +1,34 @@
+import { type SessionDocument, type SessionDocumentContainer, type SessionWritePredicate, type SessionWriteResult } from './session-manager.js';
+type CosmosItem = {
+    read<T>(): Promise<{
+        resource?: T;
+        etag?: string;
+    }>;
+    delete(): Promise<unknown>;
+    replace?<T>(body: T, options?: {
+        ifMatchEtag?: string;
+        accessCondition?: {
+            type: string;
+            condition: string;
+        };
+    }): Promise<unknown>;
+};
+type CosmosLike = {
+    item(id: string, partitionKey: string): CosmosItem;
+    items: {
+        upsert<T>(document: T): Promise<unknown>;
+        create?<T>(document: T): Promise<unknown>;
+    };
+};
+export declare class CosmosSessionDocumentContainer implements SessionDocumentContainer {
+    private readonly container;
+    private readonly onClose?;
+    constructor(container: CosmosLike, onClose?: (() => void | Promise<void>) | undefined);
+    readonly items: {
+        upsert: <T>(value: T) => Promise<unknown>;
+    };
+    compareAndSwap(predicate: SessionWritePredicate, document: SessionDocument): Promise<SessionWriteResult>;
+    item(id: string, partitionKey: string): CosmosItem;
+    close(): Promise<void>;
+}
+export {};

package/dist/types/src/framework/persistence/mongodb-session-document.container.d.ts

@@ -0,0 +1,18 @@
+import type { Collection, MongoClient } from 'mongodb';
+import { type SessionDocument, type SessionDocumentContainer, type SessionWritePredicate, type SessionWriteResult } from './session-manager.js';
+export declare class MongoDbSessionDocumentContainer implements SessionDocumentContainer {
+    private readonly collection;
+    private readonly client;
+    constructor(collection: Collection<SessionDocument>, client: MongoClient);
+    readonly items: {
+        upsert: <T>(value: T) => Promise<{}>;
+    };
+    compareAndSwap(predicate: SessionWritePredicate, document: SessionDocument): Promise<SessionWriteResult>;
+    item(id: string, partitionKey: string): {
+        read: <T>() => Promise<{
+            resource: T;
+        }>;
+        delete: () => Promise<{}>;
+    };
+    close(): Promise<void>;
+}

package/dist/types/src/framework/persistence/session-manager.d.ts

@@ -0,0 +1,116 @@
+import { type StoredMessage } from '@langchain/core/messages';
+import { ConfigManager } from '../config-manager.js';
+import { type GraphState } from '../graph-state.js';
+import { type GraphLlmConfig, type GraphLlmModelMetadata } from '../graph-llm.config.js';
+import { type SessionLogs } from '../session-log.js';
+import { type TokenUsage } from '../token-usage.js';
+export declare const SESSION_DOCUMENT_VERSION = 16;
+export declare const SESSION_BUSY = "SESSION_BUSY";
+export declare const SESSION_CONFLICT = "SESSION_CONFLICT";
+export declare const SESSION_COMPLETED = "SESSION_COMPLETED";
+export type SessionTurnCode = typeof SESSION_BUSY | typeof SESSION_CONFLICT;
+export type SessionTurnLease = {
+    owner: string;
+    expiresAt: string;
+};
+export type SessionWritePredicate = {
+    expectedRevision: number | null;
+    requireFreeLease?: boolean;
+    requireOwner?: string;
+    allowOwner?: string;
+    replaceIncompatible?: boolean;
+};
+export type SessionWriteResult = 'ok' | 'conflict';
+export declare class SessionTurnError extends Error {
+    readonly code: SessionTurnCode;
+    constructor(code: SessionTurnCode, message: string);
+}
+export type BeginTurnResult<State extends GraphState = GraphState> = Readonly<{
+    kind: 'leased';
+    document: SessionDocument<State>;
+    expectedRevision: number;
+}>;
+export type SessionWriteOptions = Readonly<{
+    owner?: string;
+    expectedRevision?: number;
+}>;
+export type SessionGraphStatus = 'in_progress' | 'completed' | 'error';
+export type SessionGraphDocument<State extends GraphState = GraphState> = {
+    id: string;
+    schemaVersion: number;
+    currentNode?: State['currentNode'];
+    config?: State['config'];
+    histories: Record<string, StoredMessage[]>;
+    nodes?: State['nodes'];
+    model: GraphLlmModelMetadata;
+};
+export type SessionDocument<State extends GraphState = GraphState> = {
+    version: number;
+    id: string;
+    revision: number;
+    status: SessionGraphStatus;
+    tokens: TokenUsage;
+    errors: SessionLogs['errors'];
+    warnings: SessionLogs['warnings'];
+    graph: SessionGraphDocument<State>;
+    turn?: SessionTurnLease;
+    createdAt: string;
+    modifiedAt: string;
+};
+export type SessionGraphMetadata = {
+    graphId: string;
+    graphSchemaVersion: number;
+    llmConfig: GraphLlmConfig;
+};
+export type SessionDocumentContainer = {
+    item(id: string, partitionKey: string): {
+        read<T>(): Promise<{
+            resource?: T;
+        }>;
+        delete(): Promise<unknown>;
+    };
+    items: {
+        upsert<T>(document: T): Promise<unknown>;
+    };
+    compareAndSwap(predicate: SessionWritePredicate, document: SessionDocument): Promise<SessionWriteResult>;
+    close?(): void | Promise<void>;
+};
+export declare class SessionManager {
+    private readonly container;
+    private readonly turnLeaseMs;
+    constructor(container?: SessionDocumentContainer, turnLeaseMs?: number);
+    static fromConfig(config?: ConfigManager): Promise<SessionManager>;
+    getSession<State extends GraphState = GraphState>(sessionId: string): Promise<SessionDocument<State> | undefined>;
+    readDocument<State extends GraphState = GraphState>(sessionId: string): Promise<SessionDocument<State> | undefined>;
+    beginTurn<State extends GraphState = GraphState>(sessionId: string, owner: string, metadata: SessionGraphMetadata): Promise<BeginTurnResult<State>>;
+    restoreState<State extends GraphState = GraphState>(sessionId: string, graphId: string): Promise<State | undefined>;
+    restoreSessionDocument<State extends GraphState = GraphState>(session: SessionDocument<State>, graphId: string): State | undefined;
+    saveState<State extends GraphState>(sessionId: string, state: State, metadata: SessionGraphMetadata, logs?: SessionLogs, options?: SessionWriteOptions): Promise<SessionDocument<State>>;
+    appendLogs(sessionId: string, logs: SessionLogs, metadata: SessionGraphMetadata, options?: SessionWriteOptions): Promise<SessionDocument | undefined>;
+    endFailedTurn(sessionId: string, owner: string, metadata: SessionGraphMetadata, logs?: SessionLogs, expectedRevision?: number): Promise<void>;
+    releaseTurn(sessionId: string, owner: string, expectedRevision?: number): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    persistMigratedSession<State extends GraphState>(document: SessionDocument<State>, options?: SessionWriteOptions): Promise<void>;
+    close(): Promise<void>;
+    private placeholderDocument;
+    private commitExpectedRevision;
+    private commitPredicate;
+}
+export declare class MemorySessionDocumentContainer implements SessionDocumentContainer {
+    private readonly documents;
+    get size(): number;
+    readonly items: {
+        upsert: <T>(value: T) => Promise<{}>;
+    };
+    compareAndSwap(predicate: SessionWritePredicate, document: SessionDocument): Promise<SessionWriteResult>;
+    item(id: string, partitionKey: string): {
+        read: <T>() => Promise<{
+            resource: T;
+        }>;
+        delete: () => Promise<{}>;
+    };
+}
+export declare function sessionTurnLeaseMs(value?: string | undefined): number;
+export declare function sessionRevision(document: Pick<SessionDocument, 'revision'> | undefined): number;
+export declare function isLiveSessionTurn(turn: SessionTurnLease | undefined, now?: number): boolean;
+export declare function matchesSessionWritePredicate(current: SessionDocument | undefined, predicate: SessionWritePredicate, now?: number): boolean;

package/dist/types/src/framework/persistence/sqlite-session-document.container.d.ts

@@ -0,0 +1,19 @@
+import { type SessionDocument, type SessionDocumentContainer, type SessionWritePredicate, type SessionWriteResult } from './session-manager.js';
+export declare class SqliteSessionDocumentContainer implements SessionDocumentContainer {
+    private readonly database;
+    private closed;
+    constructor(databasePath: string);
+    readonly items: {
+        upsert: <T>(value: T) => Promise<{}>;
+    };
+    compareAndSwap(predicate: SessionWritePredicate, document: SessionDocument): Promise<SessionWriteResult>;
+    item(id: string, partitionKey: string): {
+        read: <T>() => Promise<{
+            resource: T;
+        }>;
+        delete: () => Promise<{}>;
+    };
+    close(): void;
+    private readRow;
+    private writeRow;
+}

package/dist/types/src/framework/session-log.d.ts

@@ -0,0 +1,11 @@
+export type SessionLogEntry = Record<string, unknown> & {
+    createdAt: string;
+};
+export type SessionLogs = {
+    errors: SessionLogEntry[];
+    warnings: SessionLogEntry[];
+};
+export declare function createSessionLogs(): SessionLogs;
+export declare function withSessionLogs<T>(logs: SessionLogs, callback: () => Promise<T>): Promise<T>;
+export declare function SessionLogError(tree: Record<string, unknown>, logs?: SessionLogs | undefined): void;
+export declare function SessionLogWarning(tree: Record<string, unknown>, logs?: SessionLogs | undefined): void;

package/dist/types/src/framework/stable-id.d.ts

@@ -0,0 +1,7 @@
+export type StableIdClass = {
+    readonly name: string;
+    id(): string;
+};
+export declare function assertStableId(value: string, kind: string): string;
+export declare function stableClassId(Class: StableIdClass, kind: string): string;
+export declare function assertGraphSchemaVersion(value: number): number;

package/dist/types/src/framework/state-graph-ext.d.ts

@@ -0,0 +1,58 @@
+import { END, type ExtractStateType, type ExtractUpdateType, START, type StateDefinitionInit } from '@langchain/langgraph';
+import { GRAPH_NODE_CLASS } from './graph-node.js';
+export type RegisteredNode<State, Update> = {
+    readonly id: string;
+    readonly invoke: (state: State) => Promise<Update>;
+    route(state: State): string;
+    validateTools?(): void;
+    readonly supportsAutomaticOutcomeRouting?: boolean;
+};
+export type GraphNodeClass = {
+    readonly name: string;
+    id(): string;
+    readonly [GRAPH_NODE_CLASS]: true;
+    readonly prototype: object;
+};
+export type GraphEndpoint = GraphNodeClass | typeof START | typeof END;
+export type CurrentNodeSelector = GraphNodeClass | string;
+export type CurrentNodeBranchOptions = Readonly<{
+    cases: readonly {
+        readonly when: CurrentNodeSelector;
+        readonly routeTo: GraphEndpoint;
+    }[];
+    otherwise: GraphEndpoint;
+}>;
+type RouteOf<NodeClass extends GraphNodeClass> = NodeClass['prototype'] extends {
+    route(...args: never[]): infer Route;
+} ? Extract<Route, string> : never;
+type BranchDestinations<NodeClass extends GraphNodeClass, Destinations extends Readonly<Record<RouteOf<NodeClass>, GraphEndpoint>>> = Destinations & Record<Exclude<keyof Destinations, RouteOf<NodeClass>>, never>;
+export type GraphNodeFactory<State, Update> = (NodeClass: GraphNodeClass) => RegisteredNode<State, Update>;
+export declare class StateGraphExt<StateDefinition extends StateDefinitionInit> {
+    private readonly createGraphNode?;
+    private readonly endNode;
+    private readonly graph;
+    private readonly addedNodeIds;
+    private readonly nodeClasses;
+    private readonly explicitConditionalNodeIds;
+    private readonly nodeInstances;
+    private automaticOutcomeRoutingRequested;
+    private automaticOutcomeRoutesAdded;
+    constructor(state: StateDefinition, createGraphNode?: GraphNodeFactory<ExtractStateType<StateDefinition>, ExtractUpdateType<StateDefinition>> | undefined, endNode?: string);
+    addNode(NodeClass: GraphNodeClass): this;
+    nodes(...NodeClasses: readonly GraphNodeClass[]): this;
+    registerTurnNodes(...NodeClasses: readonly GraphNodeClass[]): this;
+    addEdge(source: GraphEndpoint | readonly GraphEndpoint[], target: GraphEndpoint): this;
+    branch<NodeClass extends GraphNodeClass, Destinations extends Readonly<Record<RouteOf<NodeClass>, GraphEndpoint>>>(NodeClass: NodeClass, destinations: BranchDestinations<NodeClass, Destinations>): this;
+    branchBy(NodeClass: GraphNodeClass, options: CurrentNodeBranchOptions): this;
+    configAutoRoute(): this;
+    registerTurns(...NodeClasses: readonly GraphNodeClass[]): this;
+    compile(): import("@langchain/langgraph").CompiledStateGraph<ExtractStateType<StateDefinition, StateDefinition> extends infer T ? { [K in keyof T]: T[K]; } : never, ExtractUpdateType<StateDefinition, StateDefinition> extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never, string, StateDefinition extends import("@langchain/langgraph").AnyStateSchema ? StateDefinition : StateDefinition extends StateDefinitionInit ? import("@langchain/langgraph").ToStateDefinition<StateDefinition> : import("@langchain/langgraph").StateDefinition, StateDefinition extends import("@langchain/langgraph").AnyStateSchema ? StateDefinition : StateDefinition extends StateDefinitionInit ? import("@langchain/langgraph").ToStateDefinition<StateDefinition> : import("@langchain/langgraph").StateDefinition, import("@langchain/langgraph").StateDefinition, unknown, unknown, unknown, []>;
+    private addConditionalEdge;
+    private registerNode;
+    private addAutomaticOutcomeRoutes;
+    private assertSource;
+    private assertTarget;
+    private assertAddedNode;
+    private currentNodeSelectorName;
+}
+export {};

package/dist/types/src/framework/terminate-session.node.d.ts

@@ -0,0 +1,9 @@
+import { GraphNode, type GraphNodeUpdate, type ToolDefinition } from "./graph-node.js";
+import type { GraphState } from "./graph-state.js";
+export declare class TerminateSessionNode<State extends GraphState> extends GraphNode<State> {
+    defineTool(): readonly ToolDefinition<{
+        message?: string | undefined;
+    }>[];
+    getPrompt(_state: State): string;
+    run(state: State): Promise<GraphNodeUpdate<State>>;
+}

package/dist/types/src/framework/token-usage.d.ts

@@ -0,0 +1,24 @@
+import { ModelCatalog, type GraphLlmConfig, type GraphLlmParameters } from './graph-llm.config.js';
+export type TokenUsage = {
+    input_tokens: number;
+    output_tokens: number;
+    thinking_tokens: number;
+    tool_input_tokens: number;
+    cached_input_tokens: number;
+    total_tokens: number;
+};
+export type ModelResult<T> = {
+    value: T;
+    usage: TokenUsage;
+    execution: ModelExecution;
+};
+export type ModelExecution = {
+    model: string;
+    family: ReturnType<typeof ModelCatalog.resolveModelDescriptor>['family'];
+    parameters: GraphLlmParameters;
+};
+export declare function modelExecution(config: GraphLlmConfig): ModelExecution;
+export declare function emptyTokenUsage(): TokenUsage;
+export declare function addTokenUsage(current?: Partial<TokenUsage>, update?: Partial<TokenUsage>): TokenUsage;
+export declare function normalizeTokenUsage(usage?: Partial<TokenUsage>): TokenUsage;
+export declare function tokenUsageFromMessage(message: unknown): TokenUsage;

package/dist/types/src/framework/turn-context.d.ts

@@ -0,0 +1,7 @@
+export type TurnContext = Readonly<{
+    session: string;
+    signal?: AbortSignal;
+}>;
+export declare function withTurnContext<T>(context: TurnContext, callback: () => Promise<T>): Promise<T>;
+export declare function currentTurnContext(): TurnContext | undefined;
+export declare function currentTurnSignal(): AbortSignal | undefined;