@picoflow/ezgraph 0.0.7 → 0.0.8

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

@@ -1,20 +1,22 @@
-import type { GraphState } from './graph-state.js';
-import type { LlmCallOptions, LlmGateway, LlmGatewayTool } from './llm-gateway.js';
-import 'reflect-metadata';
-import { type BaseMessage } from '@langchain/core/messages';
-import type { ToolCall } from '@langchain/core/messages/tool';
-import { Command } from '@langchain/langgraph';
-import { type GraphLlmConfig, type GraphLlmConfigOverride } from './graph-llm.config.js';
-import type { NodeStateValue } from './node-state.js';
-import { GraphStateSupport } from './graph-state-support.js';
-import { type ConversationPolicy, type ConversationRunResult } from './conversation-runner.js';
-import type { ModelStopReason } from './model-stop-reason.js';
-import { GRAPH_NODE_LOCAL_STATE, type GraphNodeLocalState, type GraphNodeTarget, type GraphNodeUpdate } from './node-outcome.js';
-import { type ToolResponse } from './tool-response.js';
-export { GRAPH_NODE_LOCAL_STATE, type GraphNodeLocalState, type GraphNodeTarget, type GraphNodeUpdate, } from './node-outcome.js';
+import type { GraphState } from "./graph-state.js";
+import type { LlmCallOptions, LlmGateway, LlmGatewayTool } from "./llm-gateway.js";
+import "reflect-metadata";
+import { type BaseMessage } from "@langchain/core/messages";
+import type { ToolCall } from "@langchain/core/messages/tool";
+import { Command } from "@langchain/langgraph";
+import { type GraphLlmConfig, type GraphLlmConfigOverride } from "./graph-llm.config.js";
+import type { NodeStateValue } from "./node-state.js";
+import { GraphStateSupport } from "./graph-state-support.js";
+import { type ConversationPolicy, type ConversationRunResult } from "./conversation-runner.js";
+import type { ModelStopReason } from "./model-stop-reason.js";
+import { GRAPH_NODE_LOCAL_STATE, type GraphNodeLocalState, type GraphNodeTarget, type GraphNodeUpdate } from "./node-outcome.js";
+import { type ToolResponse } from "./tool-response.js";
+import { type DecisionConversation, type DecisionErrorContext, type DecisionOptions, type DecisionProviderAdapter, type ResolvedDecisionOptions } from "./decision/decision-types.js";
+export { GRAPH_NODE_LOCAL_STATE, type GraphNodeLocalState, type GraphNodeTarget, type GraphNodeUpdate, } from "./node-outcome.js";
 export type ToolDefinition<Input extends Record<string, unknown> = Record<string, unknown>> = Readonly<LlmGatewayTool<Input>>;
 export type ToolInput<Tool extends ToolDefinition<any>> = Tool extends ToolDefinition<infer Input> ? Input : never;
 export type GraphNodeResult<State extends GraphState> = GraphNodeUpdate<State> | Command<unknown, GraphNodeUpdate<State>, string>;
+export type GraphNodeResponse<State extends GraphState> = GraphNodeResult<State> | ToolResponse;
 export type InvalidJsonResponseContext<State extends GraphState> = Readonly<{
     state: Readonly<State>;
     update: Readonly<GraphNodeUpdate<State>>;
@@ -45,7 +47,8 @@ export declare abstract class GraphNode<State extends GraphState, LocalState ext
     route(_state: State): string;
     protected handleTool(state: State, call: ToolCall, context: ToolContext): Promise<ToolResponse>;
     private rejectToolCall;
-    abstract run(state: State): GraphNodeResult<State> | Promise<GraphNodeResult<State>>;
+    abstract run(state: State): GraphNodeResponse<State> | Promise<GraphNodeResponse<State>>;
+    protected usesChatModel(): boolean;
     protected onInvalidJsonResponse(context: InvalidJsonResponseContext<State>): GraphNodeUpdate<State> | Promise<GraphNodeUpdate<State>>;
     protected onEmptyModelResponse(context: EmptyModelResponseContext<State>): string | Promise<string>;
     readonly invoke: (state: State) => Promise<GraphNodeResult<State>>;
@@ -56,11 +59,12 @@ export declare abstract class GraphNode<State extends GraphState, LocalState ext
     protected runConversation(state: State, context: ToolContext): Promise<ConversationRunResult>;
     private runAgentLoop;
     protected historySpace(): string;
-    protected history(state: Pick<State, 'histories'>): BaseMessage[];
-    protected historyUpdate(messages: BaseMessage[]): Pick<State, 'histories'>;
+    protected history(state: Pick<State, "histories">): BaseMessage[];
+    protected historyUpdate(messages: BaseMessage[]): Pick<State, "histories">;
     protected respond(message: string): GraphNodeUpdate<State>;
     protected complete(message: string): GraphNodeUpdate<State>;
-    protected state(state: Pick<State, 'nodes'>): NodeStateValue<LocalState>;
+    protected resolveNodeResponse(result: GraphNodeResponse<State>): GraphNodeResult<State>;
+    protected state(state: Pick<State, "nodes">): NodeStateValue<LocalState>;
     protected getState(): Readonly<NodeStateValue<LocalState>>;
     protected saveState(patch: Partial<LocalState>): void;
     protected save(patch: Partial<LocalState>): GraphNodeUpdate<State>;
@@ -69,22 +73,30 @@ export declare abstract class GraphNode<State extends GraphState, LocalState ext
     private resolveJsonResponse;
     private toolHandlers;
 }
-export declare class GraphNodeRuntime<State extends GraphState> extends GraphStateSupport<State['currentNode'], State['nodes']> {
+export declare class GraphNodeRuntime<State extends GraphState> extends GraphStateSupport<State["currentNode"], State["nodes"]> {
     private readonly defaultLlmConfig;
     private readonly historySpaces;
     private readonly initialHistorySpace;
     private readonly responseMode;
     readonly maxAgentRounds: number;
     readonly conversationPolicy: ConversationPolicy;
+    private readonly decisionOptions;
+    private readonly decisionErrorHandler?;
     private readonly tools;
-    constructor(endNode: State['currentNode'], defaultLlmConfig: GraphLlmConfig, historySpaces?: Readonly<Record<string, string>>, initialHistorySpace?: string, responseMode?: 'chat' | 'json', maxAgentRounds?: number, conversationPolicy?: ConversationPolicy);
+    constructor(endNode: State["currentNode"], defaultLlmConfig: GraphLlmConfig, historySpaces?: Readonly<Record<string, string>>, initialHistorySpace?: string, responseMode?: "chat" | "json", maxAgentRounds?: number, conversationPolicy?: ConversationPolicy, decisionOptions?: DecisionOptions, decisionErrorHandler?: ((context: DecisionErrorContext<State>) => GraphNodeResponse<State> | null | Promise<GraphNodeResponse<State> | null>) | undefined);
     llmCallOptions(): LlmCallOptions;
     expectsJsonResponse(): boolean;
     historySpace(currentNode?: string): string;
     resolveLlmConfig(override?: GraphLlmConfigOverride): GraphLlmConfig;
+    resolveDecisionOptions(override?: DecisionOptions): ResolvedDecisionOptions;
+    private decisionProviderResolver?;
+    attachDecisionProviderResolver(resolve: (id: string) => DecisionProviderAdapter): void;
+    resolveDecisionProvider(id: string): DecisionProviderAdapter;
+    handleDecisionError(context: DecisionErrorContext<State>): Promise<GraphNodeResponse<State> | null>;
     registerTools(owner: string, definitions: readonly ToolDefinition[]): void;
     requireTool(name: string): ToolDefinition;
-    input(state: Pick<State, 'histories' | 'currentNode'>): string;
+    input(state: Pick<State, "histories" | "currentNode">): string;
+    getConversation(space: string): DecisionConversation;
     respond(message: string): {
         response: string;
         inputConsumed: boolean;
@@ -102,7 +114,7 @@ export declare class GraphNodeRuntime<State extends GraphState> extends GraphSta
     appendHistory(space: string, messages: readonly BaseMessage[]): void;
     invocationHistory(space: string): BaseMessage[];
     stagedUpdate(): GraphNodeUpdate<State>;
-    stageNodeEntries(nodes: State['nodes'] | undefined): void;
+    stageNodeEntries(nodes: State["nodes"] | undefined): void;
     saveNode(nodeName: string, values: NodeStateValue): GraphNodeUpdate<State>;
     saveNodeState<NodeClass extends GraphNodeTarget>(NodeClass: NodeClass, patch: Partial<GraphNodeLocalState<NodeClass>>): void;
     removeNode(nodeName: string, ...keys: string[]): Partial<State>;

package/dist/types/src/framework/graph-registry.d.ts

@@ -1,21 +1,23 @@
-import type { GraphState } from './graph-state.js';
-import type { GraphLlmConfig } from './graph-llm.config.js';
-import type { HumanMessage } from '@langchain/core/messages';
-import type { SessionDocument } from './persistence/session-manager.js';
+import type { GraphState } from "./graph-state.js";
+import type { GraphLlmConfig } from "./graph-llm.config.js";
+import type { HumanMessage } from "@langchain/core/messages";
+import type { SessionDocument } from "./persistence/session-manager.js";
+import type { DecisionProviderAdapter } from "./decision/decision-types.js";
 export interface RegisteredGraph<State extends GraphState = GraphState> {
     readonly id?: string;
     readonly name: string;
     readonly schemaVersion?: number;
     readonly llmConfig: GraphLlmConfig;
     readonly requiresUserMessage?: boolean;
-    readonly responseMode?: 'chat' | 'json';
+    readonly responseMode?: "chat" | "json";
     readonly graph: {
         invoke(input: any): Promise<State>;
         stream?(input: any, options?: {
-            streamMode?: 'values';
+            streamMode?: "values";
         }): Promise<AsyncIterable<State>>;
     };
     prepareInput(state: State | undefined, message: HumanMessage): Partial<State>;
+    attachDecisionProviderResolver?(resolve: (id: string) => DecisionProviderAdapter): void;
     restoreSessionDoc?(sessionDoc: SessionDocument<State>): Promise<SessionDocument<State> | null>;
 }
 export declare class GraphRegistry {

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

@@ -1,4 +1,4 @@
-import { type BaseMessage } from '@langchain/core/messages';
+import { type BaseMessage } from "@langchain/core/messages";
 type MessageState = {
     messages: BaseMessage[];
 };

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

@@ -1,6 +1,7 @@
-import type { BaseMessage } from '@langchain/core/messages';
-import { type GraphNodeStates } from './node-state.js';
-import { type TokenUsage } from './token-usage.js';
+import type { BaseMessage } from "@langchain/core/messages";
+import { type GraphNodeStates } from "./node-state.js";
+import { type TokenUsage } from "./token-usage.js";
+import { type DecisionUsage } from "./decision/decision-types.js";
 export declare const GRAPH_END_NODE: "end";
 export type GraphState<CurrentNode extends string = string, Nodes extends object = GraphNodeStates> = {
     histories: Record<string, BaseMessage[]>;
@@ -8,6 +9,7 @@ export type GraphState<CurrentNode extends string = string, Nodes extends object
     config: Record<string, unknown>;
     nodes: Nodes;
     tokens: TokenUsage;
+    decisionUsage?: DecisionUsage;
     inputConsumed: boolean;
     response: string;
     completed: boolean;
@@ -18,6 +20,7 @@ export declare function createGraphStateAnnotation<CurrentNode extends string =
     config: import("@langchain/langgraph").BaseChannel<Record<string, unknown>, Record<string, unknown> | import("@langchain/langgraph").OverwriteValue<Record<string, unknown>>, unknown>;
     nodes: import("@langchain/langgraph").BaseChannel<Nodes, Nodes | import("@langchain/langgraph").OverwriteValue<Nodes>, unknown>;
     tokens: import("@langchain/langgraph").BaseChannel<TokenUsage, TokenUsage | import("@langchain/langgraph").OverwriteValue<TokenUsage>, unknown>;
+    decisionUsage: import("@langchain/langgraph").BaseChannel<DecisionUsage, DecisionUsage | import("@langchain/langgraph").OverwriteValue<DecisionUsage>, unknown>;
     inputConsumed: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
     response: import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
     completed: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;

package/dist/types/src/framework/langchain-provider.adapter.d.ts

@@ -1,4 +1,4 @@
-import type { GraphLlmConfig, ModelProviderInitialization } from './graph-llm.config.js';
-import { type RegisteredModelProviderAdapter } from './model-provider.js';
+import type { GraphLlmConfig, ModelProviderInitialization } from "./graph-llm.config.js";
+import { type RegisteredModelProviderAdapter } from "./model-provider.js";
 export type LangChainModelInitialization = ModelProviderInitialization;
 export declare function langChainModelInitialization(config: GraphLlmConfig, providers?: readonly RegisteredModelProviderAdapter[]): LangChainModelInitialization;

package/dist/types/src/framework/llm-gateway.d.ts

@@ -1,7 +1,7 @@
-import type { ZodType } from 'zod';
-import type { AIMessage, BaseMessage } from '@langchain/core/messages';
-import type { GraphLlmConfig } from './graph-llm.config.js';
-import type { ModelResult } from './token-usage.js';
+import type { ZodType } from "zod";
+import type { AIMessage, BaseMessage } from "@langchain/core/messages";
+import type { GraphLlmConfig } from "./graph-llm.config.js";
+import type { ModelResult } from "./token-usage.js";
 export declare const LLM_GATEWAY_FACTORY: unique symbol;
 export type LlmCallOptions = Readonly<{
     signal?: AbortSignal;

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

@@ -1,5 +1,5 @@
-import { AIMessage } from '@langchain/core/messages';
-export type ModelStopCategory = 'complete' | 'blocked' | 'truncated' | 'malformed_tool_call' | 'unspecified';
+import { AIMessage } from "@langchain/core/messages";
+export type ModelStopCategory = "complete" | "blocked" | "truncated" | "malformed_tool_call" | "unspecified";
 export type ModelStopReason = Readonly<{
     category: ModelStopCategory;
     provider?: string;

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

@@ -1,5 +1,5 @@
-import type { BaseMessage } from '@langchain/core/messages';
-import type { GraphState } from './graph-state.js';
+import type { BaseMessage } from "@langchain/core/messages";
+import type { GraphState } from "./graph-state.js";
 export declare function hasNodeInvocation(owner: object): boolean;
 export declare function withNodeInvocation<State extends GraphState, Result>(owner: object, nodeId: string, state: State, run: () => Promise<Result>): Promise<Result>;
 export declare function invocationNodeId(owner: object): string;

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

@@ -1,4 +1,4 @@
-import type { GraphState } from './graph-state.js';
+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;
@@ -7,6 +7,6 @@ export type GraphNodeTarget<LocalState extends object = object> = {
         readonly [GRAPH_NODE_LOCAL_STATE]: LocalState;
     };
 };
-export type GraphNodeLocalState<NodeClass extends GraphNodeTarget> = NodeClass['prototype'][typeof GRAPH_NODE_LOCAL_STATE];
+export type GraphNodeLocalState<NodeClass extends GraphNodeTarget> = NodeClass["prototype"][typeof GRAPH_NODE_LOCAL_STATE];
 export type GraphNodeUpdate<State extends GraphState> = Partial<State>;
 export declare function combineGraphNodeUpdates<State extends GraphState>(current: GraphNodeUpdate<State>, addition: GraphNodeUpdate<State>): GraphNodeUpdate<State>;

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

@@ -1,4 +1,4 @@
-import type { GraphLlmModelMetadata } from './graph-llm.config.js';
+import type { GraphLlmModelMetadata } from "./graph-llm.config.js";
 export type NodeStateValue<T extends object = Record<string, unknown>> = T & {
     model?: GraphLlmModelMetadata | undefined;
 };

package/dist/types/src/framework/openai-auth-provider.d.ts

@@ -1,4 +1,4 @@
-import type { GraphLlmConfig, ModelProviderInitialization } from './graph-llm.config.js';
+import type { GraphLlmConfig, ModelProviderInitialization } from "./graph-llm.config.js";
 export declare const OPENAI_AUTH_PROVIDER = "openai-auth";
 export type OpenAIAuthCredentials = Readonly<{
     accessToken: string;

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

@@ -4,6 +4,7 @@ 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';
+import { type DecisionUsage } from '../decision/decision-types.js';
 export declare const SESSION_DOCUMENT_VERSION = 16;
 export declare const SESSION_BUSY = "SESSION_BUSY";
 export declare const SESSION_CONFLICT = "SESSION_CONFLICT";
@@ -51,8 +52,10 @@ export type SessionDocument<State extends GraphState = GraphState> = {
     revision: number;
     status: SessionGraphStatus;
     tokens: TokenUsage;
+    decisionUsage?: DecisionUsage;
     errors: SessionLogs['errors'];
     warnings: SessionLogs['warnings'];
+    decisions?: SessionLogs['decisions'];
     graph: SessionGraphDocument<State>;
     turn?: SessionTurnLease;
     createdAt: string;

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

@@ -1,11 +1,41 @@
+import type { DecisionFailure, DecisionUsage } from "./decision/decision-types.js";
 export type SessionLogEntry = Record<string, unknown> & {
     createdAt: string;
 };
 export type SessionLogs = {
     errors: SessionLogEntry[];
     warnings: SessionLogEntry[];
+    decisions: DecisionAuditEntry[];
+};
+export type DecisionAuditOutcome = "success" | "fallback" | "decision_handler_failed" | "fallback_handler_failed";
+export type DecisionAuditEntry = SessionLogEntry & {
+    node: string;
+    provider: string;
+    configuredModel: string;
+    actualModel?: string;
+    outcome: DecisionAuditOutcome;
+    failure?: DecisionFailure;
+    attempts: number;
+    durationMs: number;
+    requestId?: string;
+    usage: DecisionUsage;
+};
+export type DecisionAuditInput = {
+    node: string;
+    provider: string;
+    configuredModel: string;
+    actualModel?: string;
+    outcome: DecisionAuditOutcome;
+    failure?: DecisionFailure;
+    attempts: number;
+    durationMs: number;
+    requestId?: string;
+    usage: DecisionUsage;
 };
 export declare function createSessionLogs(): SessionLogs;
+export declare function drainSessionLogs(logs: SessionLogs): SessionLogs;
+export declare function restoreSessionLogs(logs: SessionLogs, drained: SessionLogs): void;
 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;
+export declare function SessionLogDecision(entry: DecisionAuditInput, logs?: SessionLogs | undefined): DecisionAuditEntry | undefined;

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

@@ -1,5 +1,5 @@
-import { type Command, END, type ExtractStateType, type ExtractUpdateType, START, type StateDefinitionInit } from '@langchain/langgraph';
-import { GRAPH_NODE_CLASS } from './graph-node.js';
+import { type Command, 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 | Command<unknown, Update & Record<string, unknown>, string>>;
@@ -21,7 +21,7 @@ export type CurrentNodeBranchOptions = Readonly<{
     }[];
     otherwise: GraphEndpoint;
 }>;
-type RouteOf<NodeClass extends GraphNodeClass> = NodeClass['prototype'] extends {
+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>;

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

@@ -1,4 +1,4 @@
-import { ModelCatalog, type GraphLlmConfig, type GraphLlmParameters } from './graph-llm.config.js';
+import { ModelCatalog, type GraphLlmConfig, type GraphLlmParameters } from "./graph-llm.config.js";
 export type TokenUsage = {
     input_tokens: number;
     output_tokens: number;
@@ -14,7 +14,7 @@ export type ModelResult<T> = {
 };
 export type ModelExecution = {
     model: string;
-    family: ReturnType<typeof ModelCatalog.resolveModelDescriptor>['family'];
+    family: ReturnType<typeof ModelCatalog.resolveModelDescriptor>["family"];
     parameters: GraphLlmParameters;
 };
 export declare function modelExecution(config: GraphLlmConfig): ModelExecution;

package/dist/types/src/framework/tool-response.d.ts

@@ -1,6 +1,7 @@
-import type { BaseMessage } from '@langchain/core/messages';
-import type { GraphNodeLocalState, GraphNodeTarget } from './node-outcome.js';
-export type ToolResponseKind = 'go' | 'stay' | 'direct' | 'finish';
+import type { BaseMessage } from "@langchain/core/messages";
+import type { GraphNodeLocalState, GraphNodeTarget } from "./node-outcome.js";
+import type { TokenUsage } from "./token-usage.js";
+export type ToolResponseKind = "go" | "stay" | "direct" | "directTo" | "finish";
 export type ToolResponse = Readonly<{
     kind: ToolResponseKind;
     target?: GraphNodeTarget;
@@ -10,6 +11,7 @@ export type ToolResponse = Readonly<{
     messages?: readonly BaseMessage[];
     cleanup?: () => Promise<void>;
     response?: string;
+    usage?: TokenUsage;
 }>;
 export type ToolResponseBuilder<NodeClass extends GraphNodeTarget> = ToolResponse & {
     withState(state: Partial<GraphNodeLocalState<NodeClass>>): ToolResponseBuilder<NodeClass>;
@@ -17,9 +19,11 @@ export type ToolResponseBuilder<NodeClass extends GraphNodeTarget> = ToolRespons
     withMessages(messages: readonly BaseMessage[]): ToolResponseBuilder<NodeClass>;
     withCleanup(cleanup: () => Promise<void>): ToolResponseBuilder<NodeClass>;
     withToolFeedback(feedback: string): ToolResponseBuilder<NodeClass>;
+    withUsage(usage: TokenUsage): ToolResponseBuilder<NodeClass>;
 };
 export declare function go<NodeClass extends GraphNodeTarget>(target: NodeClass): ToolResponseBuilder<NodeClass>;
 export declare function stay(feedback?: string): ToolResponseBuilder<GraphNodeTarget>;
 export declare function direct(content: string | object): ToolResponseBuilder<GraphNodeTarget>;
+export declare function directTo<NodeClass extends GraphNodeTarget>(target: NodeClass, content: string | object): ToolResponseBuilder<NodeClass>;
 export declare function finish(content: string | object): ToolResponseBuilder<GraphNodeTarget>;
 export declare function isToolResponse(value: unknown): value is ToolResponse;

package/dist/types/src/testing/scripted-decisions.d.ts

@@ -0,0 +1,24 @@
+import type { DecisionAnswer, DecisionCallOptions, DecisionProviderAdapter, DecisionRequest, DecisionResult, DecisionTokenUsage } from '../framework/decision/decision-types.js';
+export type ScriptedDecisionCall = Readonly<{
+    request: DecisionRequest;
+    options: DecisionCallOptions;
+}>;
+export declare class ScriptedDecisions implements DecisionProviderAdapter {
+    readonly id: string;
+    private readonly turns;
+    private consumed;
+    readonly calls: ScriptedDecisionCall[];
+    constructor(id?: string);
+    answers(answers: Record<string, DecisionAnswer>, options?: Readonly<{
+        model?: string;
+        usage?: DecisionTokenUsage;
+        requestId?: string;
+    }>): this;
+    result(result: DecisionResult): this;
+    fail(error: Error | string): this;
+    get drained(): boolean;
+    get remaining(): number;
+    decide(request: DecisionRequest, options: DecisionCallOptions): Promise<DecisionResult>;
+    shouldRetry(error: Error): boolean;
+}
+export declare function scriptedDecisions(id?: string): ScriptedDecisions;

package/dist/types/src/testing/turn-harness.d.ts

@@ -2,6 +2,7 @@ import { GraphEngine, type GraphConstructor, type RunResult } from '../framework
 import type { GraphState } from '../framework/graph-state.js';
 import type { LlmGateway } from '../framework/llm-gateway.js';
 import type { SessionLogs } from '../framework/session-log.js';
+import type { DecisionProviderAdapter } from '../framework/decision/decision-types.js';
 import { SessionManager, type SessionDocument } from '../framework/persistence/session-manager.js';
 export type HarnessTurn<State extends GraphState> = Readonly<{
     status: number;
@@ -30,6 +31,7 @@ export type TurnHarness<State extends GraphState> = Readonly<{
 export declare function createTurnHarness<State extends GraphState = GraphState>(options: Readonly<{
     graph: GraphConstructor;
     gateway?: LlmGateway;
+    decisions?: DecisionProviderAdapter | readonly DecisionProviderAdapter[];
     sessionManager?: SessionManager;
     sessionId?: string;
 }>): TurnHarness<State>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@picoflow/ezgraph",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Provider-neutral graph primitives built on LangGraph and LangChain.",
   "type": "module",
   "main": "./dist/index.js",
@@ -37,18 +37,19 @@
     "@azure/identity": "4.13.1",
     "@google/genai": "2.14.0",
     "dotenv": "17.4.2",
-    "@langchain/core": "1.2.3",
-    "@langchain/langgraph": "1.4.8",
-    "langchain": "1.5.4",
+    "@langchain/core": "1.2.12",
+    "@langchain/langgraph": "1.4.17",
+    "langchain": "1.5.12",
     "mongodb": "6.21.0",
     "openai": "7.1.0",
     "reflect-metadata": "0.2.2",
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "@langchain/anthropic": ">=1.5.2",
-    "@langchain/google": ">=0.2.1",
-    "@langchain/openai": ">=1.5.5"
+    "@langchain/anthropic": ">=1.5.11",
+    "@langchain/google": ">=0.2.7",
+    "@langchain/openai": ">=1.5.13",
+    "@langchain/typesafe": ">=0.0.1"
   },
   "peerDependenciesMeta": {
     "@langchain/anthropic": {
@@ -59,6 +60,9 @@
     },
     "@langchain/openai": {
       "optional": true
+    },
+    "@langchain/typesafe": {
+      "optional": true
     }
   }
 }