@picoflow/ezgraph 0.0.5 → 0.0.7

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

@@ -1,5 +1,5 @@
 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 declare const GRAPH_LLM_PROVIDERS: readonly ["openai", "openai-auth", "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];
@@ -22,6 +22,9 @@ export type OpenAIReasoningParameters = CommonModelParameters & Readonly<{
     serviceTier?: "auto" | "default" | "flex" | "priority";
     promptCacheKey?: string;
 }>;
+export type OpenAIAuthReasoningParameters = CommonModelParameters & Readonly<{
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+}>;
 export type AnthropicChatParameters = CommonModelParameters & Readonly<{
     temperature?: number;
     outputEffort?: "low" | "medium" | "high" | "xhigh" | "max";
@@ -54,6 +57,7 @@ export type BuiltInModelParameters = Readonly<{
     "openai:gpt-4o-mini": OpenAIChatParameters;
     "openai:gpt-5.1": OpenAIReasoningParameters;
     "openai:gpt-5.4": OpenAIReasoningParameters;
+    "openai-auth:gpt-5.4": OpenAIAuthReasoningParameters;
     "anthropic:claude-sonnet-4-5": AnthropicChatParameters;
     "anthropic:claude-opus-4-1": AnthropicThinkingParameters;
     "google:gemini-3.1-flash-lite": GoogleChatParameters;
@@ -150,6 +154,18 @@ export declare const BUILT_IN_MODEL_CATALOG: {
                 readonly requiredCapabilities: null;
             };
         };
+        readonly "openai-auth.reasoning": {
+            readonly provider: "openai-auth";
+            readonly family: "reasoning";
+            readonly paramsSchema: Record<string, unknown>;
+            readonly parameterMappings: {
+                readonly maxOutputTokens: "maxTokens";
+                readonly reasoningEffort: "reasoningEffort";
+                readonly retries: "maxRetries";
+                readonly forceToolCalls: null;
+                readonly requiredCapabilities: null;
+            };
+        };
         readonly "anthropic.chat": {
             readonly provider: "anthropic";
             readonly family: "chat";
@@ -217,6 +233,9 @@ export declare const BUILT_IN_MODEL_CATALOG: {
         readonly "openai:gpt-5.4": {
             readonly profile: "openai.reasoning";
         };
+        readonly "openai-auth:gpt-5.4": {
+            readonly profile: "openai-auth.reasoning";
+        };
         readonly "anthropic:claude-sonnet-4-5": {
             readonly profile: "anthropic.chat";
         };

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

@@ -0,0 +1,12 @@
+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;
+export declare function invocationNodeState(owner: object, nodeId: string): Record<string, unknown>;
+export declare function saveInvocationNodeState(owner: object, nodeId: string, patch: Record<string, unknown>): void;
+export declare function replaceInvocationNodeState(owner: object, nodeId: string, value: Record<string, unknown>): void;
+export declare function appendInvocationHistory(owner: object, space: string, messages: readonly BaseMessage[]): void;
+export declare function invocationHistory(owner: object, space: string): BaseMessage[];
+export declare function invocationGraphState<State extends GraphState>(owner: object): State;
+export declare function invocationUpdate<State extends GraphState>(owner: object): Partial<State>;

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

@@ -1,5 +1,3 @@
-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> = {
@@ -11,31 +9,4 @@ export type GraphNodeTarget<LocalState extends object = object> = {
 };
 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 {};
+export declare function combineGraphNodeUpdates<State extends GraphState>(current: GraphNodeUpdate<State>, addition: GraphNodeUpdate<State>): GraphNodeUpdate<State>;

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

@@ -3,4 +3,5 @@ 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;
+export declare function replaceNodeStates<NodeStates extends object>(current: NodeStates, update: Partial<NodeStates>): NodeStates;
+export declare const mergeNodeStates: typeof replaceNodeStates;

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

@@ -0,0 +1,12 @@
+import type { GraphLlmConfig, ModelProviderInitialization } from './graph-llm.config.js';
+export declare const OPENAI_AUTH_PROVIDER = "openai-auth";
+export type OpenAIAuthCredentials = Readonly<{
+    accessToken: string;
+    accountId?: string;
+}>;
+export declare function initializeOpenAIAuthProvider(model: string, options: Readonly<Record<string, unknown>>): ModelProviderInitialization;
+export declare function isOpenAIAuthConfig(config: GraphLlmConfig): boolean;
+export declare function openAIAuthMessageText(content: unknown): string;
+export declare function openAIAuthFile(): string;
+export declare function readOpenAIAuthCredentials(authFile?: string): OpenAIAuthCredentials;
+export declare function normalizeOpenAIAuthResponsesRequest(request: Request): Promise<Request>;

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.5",
+  "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 {};