@picoflow/ezgraph 0.0.6 → 0.0.7

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

@@ -33,6 +33,7 @@ export type BeginTurnResult<State extends GraphState = GraphState> = Readonly<{
 export type SessionWriteOptions = Readonly<{
     owner?: string;
     expectedRevision?: number;
+    keepTurn?: boolean;
 }>;
 export type SessionGraphStatus = 'in_progress' | 'completed' | 'error';
 export type SessionGraphDocument<State extends GraphState = GraphState> = {

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

@@ -1,11 +1,10 @@
-import { END, type ExtractStateType, type ExtractUpdateType, START, type StateDefinitionInit } from '@langchain/langgraph';
+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>;
+    readonly invoke: (state: State) => Promise<Update | Command<unknown, Update & Record<string, unknown>, string>>;
     route(state: State): string;
     validateTools?(): void;
-    readonly supportsAutomaticOutcomeRouting?: boolean;
 };
 export type GraphNodeClass = {
     readonly name: string;
@@ -33,10 +32,7 @@ export declare class StateGraphExt<StateDefinition extends StateDefinitionInit>
     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;
@@ -44,12 +40,10 @@ export declare class StateGraphExt<StateDefinition extends StateDefinitionInit>
     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;

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

@@ -0,0 +1,25 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { GraphNodeLocalState, GraphNodeTarget } from './node-outcome.js';
+export type ToolResponseKind = 'go' | 'stay' | 'direct' | 'finish';
+export type ToolResponse = Readonly<{
+    kind: ToolResponseKind;
+    target?: GraphNodeTarget;
+    feedback?: string;
+    state?: Record<string, unknown>;
+    message?: BaseMessage;
+    messages?: readonly BaseMessage[];
+    cleanup?: () => Promise<void>;
+    response?: string;
+}>;
+export type ToolResponseBuilder<NodeClass extends GraphNodeTarget> = ToolResponse & {
+    withState(state: Partial<GraphNodeLocalState<NodeClass>>): ToolResponseBuilder<NodeClass>;
+    withMessage(message: BaseMessage): ToolResponseBuilder<NodeClass>;
+    withMessages(messages: readonly BaseMessage[]): ToolResponseBuilder<NodeClass>;
+    withCleanup(cleanup: () => Promise<void>): ToolResponseBuilder<NodeClass>;
+    withToolFeedback(feedback: string): 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 finish(content: string | object): ToolResponseBuilder<GraphNodeTarget>;
+export declare function isToolResponse(value: unknown): value is ToolResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@picoflow/ezgraph",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Provider-neutral graph primitives built on LangGraph and LangChain.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/framework/conversation-tool-result.js

@@ -1 +0,0 @@
-var i=Object.defineProperty;var n=(o,t)=>i(o,"name",{value:t,configurable:!0});const u=Symbol("TOOL_RESULT_EFFECTS");function p(o){return l({output:o},{context:[],stops:[]})}n(p,"createConversationToolResult");function b(o,t){const s=o[u];if(!s)return o;for(const e of s.context){const r=typeof e=="function"?e(t):e;if(!r||typeof r!="object"||Array.isArray(r))throw new Error("withContext() must produce an object patch.");Object.assign(t,r)}const a=s.stops.some(e=>typeof e=="function"?e(t):e);return{...o,...a?{stopAfterBatch:!0}:{}}}n(b,"resolveConversationToolResult");function l(o,t){const s={...o},a=n((e,r=t)=>l({...o,...e},r),"derive");return Object.defineProperties(s,{[u]:{enumerable:!1,value:t},withContext:{enumerable:!1,value:n(e=>a({},{...t,context:[...t.context,e]}),"value")},withMessages:{enumerable:!1,value:n(e=>{const r=Array.isArray(e)?[...e]:[e];return a({messages:[...o.messages??[],...r]})},"value")},withCleanup:{enumerable:!1,value:n(e=>a({cleanup:e}),"value")},haltAfterBatch:{enumerable:!1,value:n(()=>a({},{...t,stops:[...t.stops,!0]}),"value")},stopAfterBatchWhen:{enumerable:!1,value:n(e=>a({},{...t,stops:[...t.stops,e]}),"value")}}),s}n(l,"createBuilder");export{p as createConversationToolResult,b as resolveConversationToolResult};

package/dist/types/src/framework/conversation-tool-result.d.ts

@@ -1,19 +0,0 @@
-import type { BaseMessage } from '@langchain/core/messages';
-export type ConversationToolResult = {
-    output: unknown;
-    messages?: BaseMessage[];
-    cleanup?: () => Promise<void>;
-    stopAfterBatch?: boolean;
-};
-type ContextEffect<Context extends object> = Partial<Context> | ((context: Readonly<Context>) => Partial<Context>);
-type StopPredicate<Context extends object> = boolean | ((context: Readonly<Context>) => boolean);
-export type ConversationToolResultBuilder<Context extends object> = ConversationToolResult & {
-    withContext(effect: ContextEffect<Context>): ConversationToolResultBuilder<Context>;
-    withMessages(messages: BaseMessage | readonly BaseMessage[]): ConversationToolResultBuilder<Context>;
-    withCleanup(cleanup: () => Promise<void>): ConversationToolResultBuilder<Context>;
-    haltAfterBatch(): ConversationToolResultBuilder<Context>;
-    stopAfterBatchWhen(predicate: StopPredicate<Context>): ConversationToolResultBuilder<Context>;
-};
-export declare function createConversationToolResult<Context extends object>(output: unknown): ConversationToolResultBuilder<Context>;
-export declare function resolveConversationToolResult<Context extends object>(result: ConversationToolResult, context: Context): ConversationToolResult;
-export {};