@librechat/agents 2.4.322 → 3.0.0-rc10

package/dist/cjs/graphs/Graph.cjs

@@ -4,28 +4,26 @@ var nanoid = require('nanoid');
 var stream = require('@langchain/core/utils/stream');
 var googleVertexai = require('@langchain/google-vertexai');
 var langgraph = require('@langchain/langgraph');
-var dispatch = require('@langchain/core/callbacks/dispatch');
+var runnables = require('@langchain/core/runnables');
 var messages = require('@langchain/core/messages');
 var _enum = require('../common/enum.cjs');
-var providers = require('../llm/providers.cjs');
-var ToolNode = require('../tools/ToolNode.cjs');
 var core = require('../messages/core.cjs');
 var prune = require('../messages/prune.cjs');
 var graph = require('../utils/graph.cjs');
 var llm = require('../utils/llm.cjs');
 var run = require('../utils/run.cjs');
 require('js-tiktoken/lite');
+var providers = require('../llm/providers.cjs');
+var ToolNode = require('../tools/ToolNode.cjs');
 var index = require('../llm/openai/index.cjs');
+var events = require('../utils/events.cjs');
+var AgentContext = require('../agents/AgentContext.cjs');
 var fake = require('../llm/fake.cjs');
 
 /* eslint-disable no-console */
 // src/graphs/Graph.ts
 const { AGENT, TOOLS } = _enum.GraphNodeKeys;
 class Graph {
-    lastToken;
-    tokenTypeSwitch;
-    reasoningKey = 'reasoning_content';
-    currentTokenType = _enum.ContentTypes.TEXT;
     messageStepHasToolCalls = new Map();
     messageIdsByStepKey = new Map();
     prelimMessageIdsByStepKey = new Map();
@@ -34,71 +32,37 @@ class Graph {
     stepKeyIds = new Map();
     contentIndexMap = new Map();
     toolCallStepIds = new Map();
-    currentUsage;
-    indexTokenCountMap = {};
-    maxContextTokens;
-    pruneMessages;
-    /** The amount of time that should pass before another consecutive API call */
-    streamBuffer;
-    tokenCounter;
     signal;
+    /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
+    invokedToolIds;
+    handlerRegistry;
 }
 class StandardGraph extends Graph {
-    graphState;
-    clientOptions;
-    boundModel;
-    /** The last recorded timestamp that a stream API call was invoked */
-    lastStreamCall;
-    handlerRegistry;
-    systemMessage;
+    overrideModel;
+    /** Optional compile options passed into workflow.compile() */
+    compileOptions;
     messages = [];
     runId;
-    tools;
-    toolMap;
     startIndex = 0;
-    provider;
-    toolEnd;
     signal;
-    constructor({ runId, tools, signal, toolMap, provider, streamBuffer, instructions, reasoningKey, clientOptions, toolEnd = false, additional_instructions = '', }) {
+    /** Map of agent contexts by agent ID */
+    agentContexts = new Map();
+    /** Default agent ID to use */
+    defaultAgentId;
+    constructor({ 
+    // parent-level graph inputs
+    runId, signal, agents, tokenCounter, indexTokenCountMap, }) {
         super();
         this.runId = runId;
-        this.tools = tools;
         this.signal = signal;
-        this.toolEnd = toolEnd;
-        this.toolMap = toolMap;
-        this.provider = provider;
-        this.streamBuffer = streamBuffer;
-        this.clientOptions = clientOptions;
-        this.graphState = this.createGraphState();
-        this.boundModel = this.initializeModel();
-        if (reasoningKey) {
-            this.reasoningKey = reasoningKey;
+        if (agents.length === 0) {
+            throw new Error('At least one agent configuration is required');
         }
-        let finalInstructions = instructions;
-        if (additional_instructions) {
-            finalInstructions =
-                finalInstructions != null && finalInstructions
-                    ? `${finalInstructions}\n\n${additional_instructions}`
-                    : additional_instructions;
-        }
-        if (finalInstructions != null &&
-            finalInstructions &&
-            provider === _enum.Providers.ANTHROPIC &&
-            (clientOptions.clientOptions?.defaultHeaders?.['anthropic-beta']?.includes('prompt-caching') ??
-                false)) {
-            finalInstructions = {
-                content: [
-                    {
-                        type: 'text',
-                        text: instructions,
-                        cache_control: { type: 'ephemeral' },
-                    },
-                ],
-            };
-        }
-        if (finalInstructions != null && finalInstructions !== '') {
-            this.systemMessage = new messages.SystemMessage(finalInstructions);
+        for (const agentConfig of agents) {
+            const agentContext = AgentContext.AgentContext.fromConfig(agentConfig, tokenCounter, indexTokenCountMap);
+            this.agentContexts.set(agentConfig.agentId, agentContext);
         }
+        this.defaultAgentId = agents[0].agentId;
     }
     /* Init */
     resetValues(keepContent) {
@@ -111,15 +75,12 @@ class StandardGraph extends Graph {
         this.stepKeyIds = graph.resetIfNotEmpty(this.stepKeyIds, new Map());
         this.toolCallStepIds = graph.resetIfNotEmpty(this.toolCallStepIds, new Map());
         this.messageIdsByStepKey = graph.resetIfNotEmpty(this.messageIdsByStepKey, new Map());
-        this.messageStepHasToolCalls = graph.resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
+        this.messageStepHasToolCalls = graph.resetIfNotEmpty(this.messageStepHasToolCalls, new Map());
         this.prelimMessageIdsByStepKey = graph.resetIfNotEmpty(this.prelimMessageIdsByStepKey, new Map());
-        this.currentTokenType = graph.resetIfNotEmpty(this.currentTokenType, _enum.ContentTypes.TEXT);
-        this.lastToken = graph.resetIfNotEmpty(this.lastToken, undefined);
-        this.tokenTypeSwitch = graph.resetIfNotEmpty(this.tokenTypeSwitch, undefined);
-        this.indexTokenCountMap = graph.resetIfNotEmpty(this.indexTokenCountMap, {});
-        this.currentUsage = graph.resetIfNotEmpty(this.currentUsage, undefined);
-        this.tokenCounter = graph.resetIfNotEmpty(this.tokenCounter, undefined);
-        this.maxContextTokens = graph.resetIfNotEmpty(this.maxContextTokens, undefined);
+        this.invokedToolIds = graph.resetIfNotEmpty(this.invokedToolIds, undefined);
+        for (const context of this.agentContexts.values()) {
+            context.reset();
+        }
     }
     /* Run Step Processing */
     getRunStep(stepId) {
@@ -129,6 +90,27 @@ class StandardGraph extends Graph {
         }
         return undefined;
     }
+    getAgentContext(metadata) {
+        if (!metadata) {
+            throw new Error('No metadata provided to retrieve agent context');
+        }
+        const currentNode = metadata.langgraph_node;
+        if (!currentNode) {
+            throw new Error('No langgraph_node in metadata to retrieve agent context');
+        }
+        let agentId;
+        if (currentNode.startsWith(AGENT)) {
+            agentId = currentNode.substring(AGENT.length);
+        }
+        else if (currentNode.startsWith(TOOLS)) {
+            agentId = currentNode.substring(TOOLS.length);
+        }
+        const agentContext = this.agentContexts.get(agentId ?? '');
+        if (!agentContext) {
+            throw new Error(`No agent context found for agent ID ${agentId}`);
+        }
+        return agentContext;
+    }
     getStepKey(metadata) {
         if (!metadata)
             return '';
@@ -174,10 +156,14 @@ class StandardGraph extends Graph {
             metadata.langgraph_step,
             metadata.checkpoint_ns,
         ];
-        if (this.currentTokenType === _enum.ContentTypes.THINK ||
-            this.currentTokenType === 'think_and_text') {
+        const agentContext = this.getAgentContext(metadata);
+        if (agentContext.currentTokenType === _enum.ContentTypes.THINK ||
+            agentContext.currentTokenType === 'think_and_text') {
             keyList.push('reasoning');
         }
+        if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {
+            keyList.push(this.invokedToolIds.size + '');
+        }
         return keyList;
     }
     checkKeyList(keyList) {
@@ -191,113 +177,158 @@ class StandardGraph extends Graph {
         return core.convertMessagesToContent(this.messages.slice(this.startIndex));
     }
     /* Graph */
-    createGraphState() {
-        return {
-            messages: {
-                value: (x, y) => {
-                    if (!x.length) {
-                        if (this.systemMessage) {
-                            x.push(this.systemMessage);
-                        }
-                        this.startIndex = x.length + y.length;
-                    }
-                    const current = x.concat(y);
-                    this.messages = current;
-                    return current;
-                },
-                default: () => [],
-            },
-        };
+    createSystemRunnable({ provider, clientOptions, instructions, additional_instructions, }) {
+        let finalInstructions = instructions;
+        if (additional_instructions != null && additional_instructions !== '') {
+            finalInstructions =
+                finalInstructions != null && finalInstructions
+                    ? `${finalInstructions}\n\n${additional_instructions}`
+                    : additional_instructions;
+        }
+        if (finalInstructions != null &&
+            finalInstructions &&
+            provider === _enum.Providers.ANTHROPIC &&
+            (clientOptions.clientOptions
+                ?.defaultHeaders?.['anthropic-beta']?.includes('prompt-caching') ??
+                false)) {
+            finalInstructions = {
+                content: [
+                    {
+                        type: 'text',
+                        text: instructions,
+                        cache_control: { type: 'ephemeral' },
+                    },
+                ],
+            };
+        }
+        if (finalInstructions != null && finalInstructions !== '') {
+            const systemMessage = new messages.SystemMessage(finalInstructions);
+            return runnables.RunnableLambda.from((messages) => {
+                return [systemMessage, ...messages];
+            }).withConfig({ runName: 'prompt' });
+        }
     }
-    initializeTools() {
-        // return new ToolNode<t.BaseGraphState>(this.tools);
+    initializeTools({ currentTools, currentToolMap, }) {
         return new ToolNode.ToolNode({
-            tools: this.tools || [],
-            toolMap: this.toolMap,
+            tools: currentTools ?? [],
+            toolMap: currentToolMap,
             toolCallStepIds: this.toolCallStepIds,
             errorHandler: (data, metadata) => StandardGraph.handleToolCallErrorStatic(this, data, metadata),
         });
     }
-    initializeModel() {
-        const ChatModelClass = providers.getChatModelClass(this.provider);
-        const model = new ChatModelClass(this.clientOptions);
-        if (llm.isOpenAILike(this.provider) &&
+    initializeModel({ provider, tools, clientOptions, }) {
+        const ChatModelClass = providers.getChatModelClass(provider);
+        const model = new ChatModelClass(clientOptions ?? {});
+        if (llm.isOpenAILike(provider) &&
             (model instanceof index.ChatOpenAI || model instanceof index.AzureChatOpenAI)) {
-            model.temperature = this.clientOptions
+            model.temperature = clientOptions
                 .temperature;
-            model.topP = this.clientOptions.topP;
-            model.frequencyPenalty = this.clientOptions
+            model.topP = clientOptions.topP;
+            model.frequencyPenalty = clientOptions
                 .frequencyPenalty;
-            model.presencePenalty = this.clientOptions
+            model.presencePenalty = clientOptions
                 .presencePenalty;
-            model.n = this.clientOptions.n;
+            model.n = clientOptions.n;
         }
-        else if (this.provider === _enum.Providers.VERTEXAI &&
+        else if (provider === _enum.Providers.VERTEXAI &&
             model instanceof googleVertexai.ChatVertexAI) {
-            model.temperature = this.clientOptions
+            model.temperature = clientOptions
                 .temperature;
-            model.topP = this.clientOptions
-                .topP;
-            model.topK = this.clientOptions
-                .topK;
-            model.topLogprobs = this.clientOptions
+            model.topP = clientOptions.topP;
+            model.topK = clientOptions.topK;
+            model.topLogprobs = clientOptions
                 .topLogprobs;
-            model.frequencyPenalty = this.clientOptions
+            model.frequencyPenalty = clientOptions
                 .frequencyPenalty;
-            model.presencePenalty = this.clientOptions
+            model.presencePenalty = clientOptions
                 .presencePenalty;
-            model.maxOutputTokens = this.clientOptions
+            model.maxOutputTokens = clientOptions
                 .maxOutputTokens;
         }
-        if (!this.tools || this.tools.length === 0) {
+        if (!tools || tools.length === 0) {
             return model;
         }
-        return model.bindTools(this.tools);
+        return model.bindTools(tools);
     }
     overrideTestModel(responses, sleep, toolCalls) {
-        this.boundModel = fake.createFakeStreamingLLM({
+        this.overrideModel = fake.createFakeStreamingLLM({
             responses,
             sleep,
             toolCalls,
         });
     }
-    getNewModel({ clientOptions = {}, omitOriginalOptions, }) {
-        const ChatModelClass = providers.getChatModelClass(this.provider);
-        const _options = omitOriginalOptions
-            ? Object.fromEntries(Object.entries(this.clientOptions).filter(([key]) => !omitOriginalOptions.has(key)))
-            : this.clientOptions;
-        const options = Object.assign(_options, clientOptions);
-        return new ChatModelClass(options);
+    getNewModel({ provider, clientOptions, }) {
+        const ChatModelClass = providers.getChatModelClass(provider);
+        return new ChatModelClass(clientOptions ?? {});
     }
-    storeUsageMetadata(finalMessage) {
+    getUsageMetadata(finalMessage) {
         if (finalMessage &&
             'usage_metadata' in finalMessage &&
             finalMessage.usage_metadata != null) {
-            this.currentUsage = finalMessage.usage_metadata;
+            return finalMessage.usage_metadata;
+        }
+    }
+    /** Execute model invocation with streaming support */
+    async attemptInvoke({ currentModel, finalMessages, provider, tools, }, config) {
+        const model = this.overrideModel ?? currentModel;
+        if (!model) {
+            throw new Error('No model found');
+        }
+        if ((tools?.length ?? 0) > 0 && providers.manualToolStreamProviders.has(provider)) {
+            if (!model.stream) {
+                throw new Error('Model does not support stream');
+            }
+            const stream$1 = await model.stream(finalMessages, config);
+            let finalChunk;
+            for await (const chunk of stream$1) {
+                await events.safeDispatchCustomEvent(_enum.GraphEvents.CHAT_MODEL_STREAM, { chunk, emitted: true }, config);
+                finalChunk = finalChunk ? stream.concat(finalChunk, chunk) : chunk;
+            }
+            finalChunk = core.modifyDeltaProperties(provider, finalChunk);
+            return { messages: [finalChunk] };
+        }
+        else {
+            const finalMessage = await model.invoke(finalMessages, config);
+            if ((finalMessage.tool_calls?.length ?? 0) > 0) {
+                finalMessage.tool_calls = finalMessage.tool_calls?.filter((tool_call) => !!tool_call.name);
+            }
+            return { messages: [finalMessage] };
         }
     }
-    cleanupSignalListener() {
+    cleanupSignalListener(currentModel) {
         if (!this.signal) {
             return;
         }
-        if (!this.boundModel) {
+        const model = this.overrideModel ?? currentModel;
+        if (!model) {
             return;
         }
-        const client = this.boundModel?.exposedClient;
+        const client = model?.exposedClient;
         if (!client?.abortHandler) {
             return;
         }
         this.signal.removeEventListener('abort', client.abortHandler);
         client.abortHandler = undefined;
     }
-    createCallModel() {
+    createCallModel(agentId = 'default', currentModel) {
         return async (state, config) => {
-            const { provider = '' } = config?.configurable ?? {};
-            if (this.boundModel == null) {
+            /**
+             * Get agent context - it must exist by this point
+             */
+            const agentContext = this.agentContexts.get(agentId);
+            if (!agentContext) {
+                throw new Error(`Agent context not found for agentId: ${agentId}`);
+            }
+            const model = this.overrideModel ?? currentModel;
+            if (!model) {
                 throw new Error('No Graph model found');
             }
-            if (!config || !provider) {
-                throw new Error(`No ${config ? 'provider' : 'config'} provided`);
+            if (!config) {
+                throw new Error('No config provided');
+            }
+            // Ensure token calculations are complete before proceeding
+            if (agentContext.tokenCalculationPromise) {
+                await agentContext.tokenCalculationPromise;
             }
             if (!config.signal) {
                 config.signal = this.signal;
@@ -305,32 +336,32 @@ class StandardGraph extends Graph {
             this.config = config;
             const { messages: messages$1 } = state;
             let messagesToUse = messages$1;
-            if (!this.pruneMessages &&
-                this.tokenCounter &&
-                this.maxContextTokens != null &&
-                this.indexTokenCountMap[0] != null) {
-                const isAnthropicWithThinking = (this.provider === _enum.Providers.ANTHROPIC &&
-                    this.clientOptions.thinking !=
+            if (!agentContext.pruneMessages &&
+                agentContext.tokenCounter &&
+                agentContext.maxContextTokens != null &&
+                agentContext.indexTokenCountMap[0] != null) {
+                const isAnthropicWithThinking = (agentContext.provider === _enum.Providers.ANTHROPIC &&
+                    agentContext.clientOptions.thinking !=
                         null) ||
-                    (this.provider === _enum.Providers.BEDROCK &&
-                        this.clientOptions
+                    (agentContext.provider === _enum.Providers.BEDROCK &&
+                        agentContext.clientOptions
                             .additionalModelRequestFields?.['thinking'] != null);
-                this.pruneMessages = prune.createPruneMessages({
-                    provider: this.provider,
-                    indexTokenCountMap: this.indexTokenCountMap,
-                    maxTokens: this.maxContextTokens,
-                    tokenCounter: this.tokenCounter,
+                agentContext.pruneMessages = prune.createPruneMessages({
                     startIndex: this.startIndex,
+                    provider: agentContext.provider,
+                    tokenCounter: agentContext.tokenCounter,
+                    maxTokens: agentContext.maxContextTokens,
                     thinkingEnabled: isAnthropicWithThinking,
+                    indexTokenCountMap: agentContext.indexTokenCountMap,
                 });
             }
-            if (this.pruneMessages) {
-                const { context, indexTokenCountMap } = this.pruneMessages({
+            if (agentContext.pruneMessages) {
+                const { context, indexTokenCountMap } = agentContext.pruneMessages({
                     messages: messages$1,
-                    usageMetadata: this.currentUsage,
+                    usageMetadata: agentContext.currentUsage,
                     // startOnMessageType: 'human',
                 });
-                this.indexTokenCountMap = indexTokenCountMap;
+                agentContext.indexTokenCountMap = indexTokenCountMap;
                 messagesToUse = context;
             }
             const finalMessages = messagesToUse;
@@ -340,87 +371,145 @@ class StandardGraph extends Graph {
             const lastMessageY = finalMessages.length >= 1
                 ? finalMessages[finalMessages.length - 1]
                 : null;
-            if (provider === _enum.Providers.BEDROCK &&
+            if (agentContext.provider === _enum.Providers.BEDROCK &&
                 lastMessageX instanceof messages.AIMessageChunk &&
                 lastMessageY instanceof messages.ToolMessage &&
                 typeof lastMessageX.content === 'string') {
                 finalMessages[finalMessages.length - 2].content = '';
             }
             const isLatestToolMessage = lastMessageY instanceof messages.ToolMessage;
-            if (isLatestToolMessage && provider === _enum.Providers.ANTHROPIC) {
+            if (isLatestToolMessage &&
+                agentContext.provider === _enum.Providers.ANTHROPIC) {
                 core.formatAnthropicArtifactContent(finalMessages);
             }
             else if (isLatestToolMessage &&
-                (llm.isOpenAILike(provider) || llm.isGoogleLike(provider))) {
+                (llm.isOpenAILike(agentContext.provider) ||
+                    llm.isGoogleLike(agentContext.provider))) {
                 core.formatArtifactPayload(finalMessages);
             }
-            if (this.lastStreamCall != null && this.streamBuffer != null) {
-                const timeSinceLastCall = Date.now() - this.lastStreamCall;
-                if (timeSinceLastCall < this.streamBuffer) {
-                    const timeToWait = Math.ceil((this.streamBuffer - timeSinceLastCall) / 1000) * 1000;
+            if (agentContext.lastStreamCall != null &&
+                agentContext.streamBuffer != null) {
+                const timeSinceLastCall = Date.now() - agentContext.lastStreamCall;
+                if (timeSinceLastCall < agentContext.streamBuffer) {
+                    const timeToWait = Math.ceil((agentContext.streamBuffer - timeSinceLastCall) / 1000) *
+                        1000;
                     await run.sleep(timeToWait);
                 }
             }
-            this.lastStreamCall = Date.now();
+            agentContext.lastStreamCall = Date.now();
             let result;
-            if ((this.tools?.length ?? 0) > 0 &&
-                providers.manualToolStreamProviders.has(provider)) {
-                const stream$1 = await this.boundModel.stream(finalMessages, config);
-                let finalChunk;
-                for await (const chunk of stream$1) {
-                    dispatch.dispatchCustomEvent(_enum.GraphEvents.CHAT_MODEL_STREAM, { chunk }, config);
-                    if (!finalChunk) {
-                        finalChunk = chunk;
+            const fallbacks = agentContext.clientOptions?.fallbacks ??
+                [];
+            try {
+                result = await this.attemptInvoke({
+                    currentModel: model,
+                    finalMessages,
+                    provider: agentContext.provider,
+                    tools: agentContext.tools,
+                }, config);
+            }
+            catch (primaryError) {
+                let lastError = primaryError;
+                for (const fb of fallbacks) {
+                    try {
+                        let model = this.getNewModel({
+                            provider: fb.provider,
+                            clientOptions: fb.clientOptions,
+                        });
+                        const bindableTools = agentContext.tools;
+                        model = (!bindableTools || bindableTools.length === 0
+                            ? model
+                            : model.bindTools(bindableTools));
+                        result = await this.attemptInvoke({
+                            currentModel: model,
+                            finalMessages,
+                            provider: fb.provider,
+                            tools: agentContext.tools,
+                        }, config);
+                        lastError = undefined;
+                        break;
                     }
-                    else {
-                        finalChunk = stream.concat(finalChunk, chunk);
+                    catch (e) {
+                        lastError = e;
+                        continue;
                     }
                 }
-                finalChunk = core.modifyDeltaProperties(this.provider, finalChunk);
-                result = { messages: [finalChunk] };
-            }
-            else {
-                const finalMessage = (await this.boundModel.invoke(finalMessages, config));
-                if ((finalMessage.tool_calls?.length ?? 0) > 0) {
-                    finalMessage.tool_calls = finalMessage.tool_calls?.filter((tool_call) => {
-                        if (!tool_call.name) {
-                            return false;
-                        }
-                        return true;
-                    });
+                if (lastError !== undefined) {
+                    throw lastError;
                 }
-                result = { messages: [finalMessage] };
             }
-            this.storeUsageMetadata(result.messages?.[0]);
+            if (!result) {
+                throw new Error('No result after model invocation');
+            }
+            agentContext.currentUsage = this.getUsageMetadata(result.messages?.[0]);
             this.cleanupSignalListener();
             return result;
         };
     }
-    createWorkflow() {
+    createAgentNode(agentId) {
+        const agentContext = this.agentContexts.get(agentId);
+        if (!agentContext) {
+            throw new Error(`Agent context not found for agentId: ${agentId}`);
+        }
+        let currentModel = this.initializeModel({
+            tools: agentContext.tools,
+            provider: agentContext.provider,
+            clientOptions: agentContext.clientOptions,
+        });
+        if (agentContext.systemRunnable) {
+            currentModel = agentContext.systemRunnable.pipe(currentModel);
+        }
+        const agentNode = `${AGENT}${agentId}`;
+        const toolNode = `${TOOLS}${agentId}`;
         const routeMessage = (state, config) => {
             this.config = config;
-            // const lastMessage = state.messages[state.messages.length - 1] as AIMessage;
-            // if (!lastMessage?.tool_calls?.length) {
-            //   return END;
-            // }
-            // return TOOLS;
-            return ToolNode.toolsCondition(state);
+            return ToolNode.toolsCondition(state, toolNode, this.invokedToolIds);
         };
-        const workflow = new langgraph.StateGraph({
-            channels: this.graphState,
-        })
-            .addNode(AGENT, this.createCallModel())
-            .addNode(TOOLS, this.initializeTools())
-            .addEdge(langgraph.START, AGENT)
-            .addConditionalEdges(AGENT, routeMessage)
-            .addEdge(TOOLS, this.toolEnd ? langgraph.END : AGENT);
-        return workflow.compile();
+        const StateAnnotation = langgraph.Annotation.Root({
+            messages: langgraph.Annotation({
+                reducer: langgraph.messagesStateReducer,
+                default: () => [],
+            }),
+        });
+        const workflow = new langgraph.StateGraph(StateAnnotation)
+            .addNode(agentNode, this.createCallModel(agentId, currentModel))
+            .addNode(toolNode, this.initializeTools({
+            currentTools: agentContext.tools,
+            currentToolMap: agentContext.toolMap,
+        }))
+            .addEdge(langgraph.START, agentNode)
+            .addConditionalEdges(agentNode, routeMessage)
+            .addEdge(toolNode, agentContext.toolEnd ? langgraph.END : agentNode);
+        // Cast to unknown to avoid tight coupling to external types; options are opt-in
+        return workflow.compile(this.compileOptions);
+    }
+    createWorkflow() {
+        /** Use the default (first) agent for now */
+        const agentNode = this.createAgentNode(this.defaultAgentId);
+        const StateAnnotation = langgraph.Annotation.Root({
+            messages: langgraph.Annotation({
+                reducer: (a, b) => {
+                    if (!a.length) {
+                        this.startIndex = a.length + b.length;
+                    }
+                    const result = langgraph.messagesStateReducer(a, b);
+                    this.messages = result;
+                    return result;
+                },
+                default: () => [],
+            }),
+        });
+        const workflow = new langgraph.StateGraph(StateAnnotation)
+            .addNode(this.defaultAgentId, agentNode, { ends: [langgraph.END] })
+            .addEdge(langgraph.START, this.defaultAgentId)
+            .compile();
+        return workflow;
     }
     /* Dispatchers */
     /**
      * Dispatches a run step to the client, returns the step ID
      */
-    dispatchRunStep(stepKey, stepDetails) {
+    async dispatchRunStep(stepKey, stepDetails) {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -448,17 +537,21 @@ class StandardGraph extends Graph {
         }
         this.contentData.push(runStep);
         this.contentIndexMap.set(stepId, runStep.index);
-        dispatch.dispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, this.config);
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP, runStep, this.config);
         return stepId;
     }
-    handleToolCallCompleted(data, metadata) {
+    async handleToolCallCompleted(data, metadata, omitOutput) {
         if (!this.config) {
             throw new Error('No config provided');
         }
         if (!data.output) {
             return;
         }
-        const { input, output } = data;
+        const { input, output: _output } = data;
+        if (_output?.lg_name === 'Command') {
+            return;
+        }
+        const output = _output;
         const { tool_call_id } = output;
         const stepId = this.toolCallStepIds.get(tool_call_id) ?? '';
         if (!stepId) {
@@ -468,17 +561,20 @@ class StandardGraph extends Graph {
         if (!runStep) {
             throw new Error(`No run step found for stepId ${stepId}`);
         }
+        const dispatchedOutput = typeof output.content === 'string'
+            ? output.content
+            : JSON.stringify(output.content);
         const args = typeof input === 'string' ? input : input.input;
         const tool_call = {
             args: typeof args === 'string' ? args : JSON.stringify(args),
             name: output.name ?? '',
             id: output.tool_call_id,
-            output: typeof output.content === 'string'
-                ? output.content
-                : JSON.stringify(output.content),
+            output: omitOutput === true ? '' : dispatchedOutput,
             progress: 1,
         };
-        this.handlerRegistry?.getHandler(_enum.GraphEvents.ON_RUN_STEP_COMPLETED)?.handle(_enum.GraphEvents.ON_RUN_STEP_COMPLETED, {
+        await this.handlerRegistry
+            ?.getHandler(_enum.GraphEvents.ON_RUN_STEP_COMPLETED)
+            ?.handle(_enum.GraphEvents.ON_RUN_STEP_COMPLETED, {
             result: {
                 id: stepId,
                 index: runStep.index,
@@ -491,7 +587,7 @@ class StandardGraph extends Graph {
      * Static version of handleToolCallError to avoid creating strong references
      * that prevent garbage collection
      */
-    static handleToolCallErrorStatic(graph, data, metadata) {
+    static async handleToolCallErrorStatic(graph, data, metadata) {
         if (!graph.config) {
             throw new Error('No config provided');
         }
@@ -515,7 +611,7 @@ class StandardGraph extends Graph {
             output: `Error processing tool${error?.message != null ? `: ${error.message}` : ''}`,
             progress: 1,
         };
-        graph.handlerRegistry
+        await graph.handlerRegistry
             ?.getHandler(_enum.GraphEvents.ON_RUN_STEP_COMPLETED)
             ?.handle(_enum.GraphEvents.ON_RUN_STEP_COMPLETED, {
             result: {
@@ -530,10 +626,10 @@ class StandardGraph extends Graph {
      * Instance method that delegates to the static method
      * Kept for backward compatibility
      */
-    handleToolCallError(data, metadata) {
-        StandardGraph.handleToolCallErrorStatic(this, data, metadata);
+    async handleToolCallError(data, metadata) {
+        await StandardGraph.handleToolCallErrorStatic(this, data, metadata);
     }
-    dispatchRunStepDelta(id, delta) {
+    async dispatchRunStepDelta(id, delta) {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -544,9 +640,9 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        dispatch.dispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, this.config);
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_RUN_STEP_DELTA, runStepDelta, this.config);
     }
-    dispatchMessageDelta(id, delta) {
+    async dispatchMessageDelta(id, delta) {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -554,9 +650,9 @@ class StandardGraph extends Graph {
             id,
             delta,
         };
-        dispatch.dispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_MESSAGE_DELTA, messageDelta, this.config);
     }
-    dispatchReasoningDelta = (stepId, delta) => {
+    dispatchReasoningDelta = async (stepId, delta) => {
         if (!this.config) {
             throw new Error('No config provided');
         }
@@ -564,7 +660,7 @@ class StandardGraph extends Graph {
             id: stepId,
             delta,
         };
-        dispatch.dispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
+        await events.safeDispatchCustomEvent(_enum.GraphEvents.ON_REASONING_DELTA, reasoningDelta, this.config);
     };
 }