@langchain/langgraph 0.2.45 → 0.2.47

package/dist/prebuilt/react_agent_executor.js

@@ -5,7 +5,7 @@ import { ToolNode } from "./tool_node.js";
 import { Annotation } from "../graph/annotation.js";
 import { messagesStateReducer } from "../graph/message.js";
 import { END, START } from "../constants.js";
-function _convertMessageModifierToStateModifier(messageModifier) {
+function _convertMessageModifierToPrompt(messageModifier) {
     // Handle string or SystemMessage
     if (typeof messageModifier === "string" ||
         (isBaseMessage(messageModifier) && messageModifier._getType() === "system")) {
@@ -21,48 +21,99 @@ function _convertMessageModifierToStateModifier(messageModifier) {
     }
     throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
 }
-function _getStateModifierRunnable(stateModifier) {
-    let stateModifierRunnable;
-    if (stateModifier == null) {
-        stateModifierRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "string") {
-        const systemMessage = new SystemMessage(stateModifier);
-        stateModifierRunnable = RunnableLambda.from((state) => {
+const PROMPT_RUNNABLE_NAME = "prompt";
+function _getPromptRunnable(prompt) {
+    let promptRunnable;
+    if (prompt == null) {
+        promptRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "string") {
+        const systemMessage = new SystemMessage(prompt);
+        promptRunnable = RunnableLambda.from((state) => {
             return [systemMessage, ...(state.messages ?? [])];
-        }).withConfig({ runName: "state_modifier" });
-    }
-    else if (isBaseMessage(stateModifier) &&
-        stateModifier._getType() === "system") {
-        stateModifierRunnable = RunnableLambda.from((state) => [
-            stateModifier,
-            ...state.messages,
-        ]).withConfig({ runName: "state_modifier" });
-    }
-    else if (typeof stateModifier === "function") {
-        stateModifierRunnable = RunnableLambda.from(stateModifier).withConfig({
-            runName: "state_modifier",
+        }).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (isBaseMessage(prompt) && prompt._getType() === "system") {
+        promptRunnable = RunnableLambda.from((state) => [prompt, ...state.messages]).withConfig({ runName: PROMPT_RUNNABLE_NAME });
+    }
+    else if (typeof prompt === "function") {
+        promptRunnable = RunnableLambda.from(prompt).withConfig({
+            runName: PROMPT_RUNNABLE_NAME,
         });
     }
-    else if (Runnable.isRunnable(stateModifier)) {
-        stateModifierRunnable = stateModifier;
+    else if (Runnable.isRunnable(prompt)) {
+        promptRunnable = prompt;
     }
     else {
-        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+        throw new Error(`Got unexpected type for 'prompt': ${typeof prompt}`);
+    }
+    return promptRunnable;
+}
+function _getPrompt(prompt, stateModifier, messageModifier) {
+    // Check if multiple modifiers exist
+    const definedCount = [prompt, stateModifier, messageModifier].filter((x) => x != null).length;
+    if (definedCount > 1) {
+        throw new Error("Expected only one of prompt, stateModifier, or messageModifier, got multiple values");
+    }
+    let finalPrompt = prompt;
+    if (stateModifier != null) {
+        finalPrompt = stateModifier;
+    }
+    else if (messageModifier != null) {
+        finalPrompt = _convertMessageModifierToPrompt(messageModifier);
+    }
+    return _getPromptRunnable(finalPrompt);
+}
+function _shouldBindTools(llm, tools) {
+    if (!Runnable.isRunnable(llm) || !("kwargs" in llm)) {
+        return true;
+    }
+    if (!llm.kwargs ||
+        typeof llm.kwargs !== "object" ||
+        !("tools" in llm.kwargs)) {
+        return true;
     }
-    return stateModifierRunnable;
+    const boundTools = llm.kwargs.tools;
+    if (tools.length !== boundTools.length) {
+        throw new Error("Number of tools in the model.bindTools() and tools passed to createReactAgent must match");
+    }
+    const toolNames = new Set(tools.map((tool) => tool.name));
+    const boundToolNames = new Set();
+    for (const boundTool of boundTools) {
+        let boundToolName;
+        // OpenAI-style tool
+        if ("type" in boundTool && boundTool.type === "function") {
+            boundToolName = boundTool.function.name;
+        }
+        // Anthropic-style tool
+        else if ("name" in boundTool) {
+            boundToolName = boundTool.name;
+        }
+        // unknown tool type so we'll ignore it
+        else {
+            continue;
+        }
+        boundToolNames.add(boundToolName);
+    }
+    const missingTools = [...toolNames].filter((x) => !boundToolNames.has(x));
+    if (missingTools.length > 0) {
+        throw new Error(`Missing tools '${missingTools}' in the model.bindTools().` +
+            `Tools in the model.bindTools() must match the tools passed to createReactAgent.`);
+    }
+    return false;
 }
-function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
-    // Check if both modifiers exist
-    if (stateModifier != null && messageModifier != null) {
-        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+function _getModel(llm) {
+    // Get the underlying model from a RunnableBinding or return the model itself
+    let model = llm;
+    if (Runnable.isRunnable(llm) && "bound" in llm) {
+        model = llm.bound;
     }
-    // Convert message modifier to state modifier if necessary
-    if (stateModifier == null && messageModifier != null) {
-        // eslint-disable-next-line no-param-reassign
-        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    if (!("invoke" in model &&
+        typeof model.invoke === "function" &&
+        "_modelType" in model)) {
+        throw new Error(`Expected \`llm\` to be a ChatModel or RunnableBinding (e.g. llm.bind_tools(...)) with invoke() and generate() methods, got ${model.constructor.name}`);
     }
-    return _getStateModifierRunnable(stateModifier);
+    return model;
 }
 export const createReactAgentAnnotation = () => Annotation.Root({
     messages: Annotation({
@@ -114,7 +165,7 @@ export const createReactAgentAnnotation = () => Annotation.Root({
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, stateModifier, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, } = params;
+    const { llm, tools, messageModifier, stateModifier, prompt, stateSchema, checkpointSaver, checkpointer, interruptBefore, interruptAfter, store, responseFormat, name, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -122,13 +173,17 @@ export function createReactAgent(params) {
     else {
         toolClasses = tools;
     }
-    if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
-        throw new Error(`llm ${llm} must define bindTools method.`);
+    let modelWithTools;
+    if (_shouldBindTools(llm, toolClasses)) {
+        if (!("bindTools" in llm) || typeof llm.bindTools !== "function") {
+            throw new Error(`llm ${llm} must define bindTools method.`);
+        }
+        modelWithTools = llm.bindTools(toolClasses);
+    }
+    else {
+        modelWithTools = llm;
     }
-    const modelWithTools = llm.bindTools(toolClasses);
-    // we're passing store here for validation
-    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
-    const modelRunnable = preprocessor.pipe(modelWithTools);
+    const modelRunnable = _getPrompt(prompt, stateModifier, messageModifier).pipe(modelWithTools);
     // If any of the tools are configured to return_directly after running,
     // our graph needs to check if these were called
     const shouldReturnDirect = new Set(toolClasses
@@ -157,18 +212,22 @@ export function createReactAgent(params) {
             "prompt" in responseFormat &&
             "schema" in responseFormat) {
             const { prompt, schema } = responseFormat;
-            modelWithStructuredOutput = llm.withStructuredOutput(schema);
+            modelWithStructuredOutput = _getModel(llm).withStructuredOutput(schema);
             messages.unshift(new SystemMessage({ content: prompt }));
         }
         else {
-            modelWithStructuredOutput = llm.withStructuredOutput(responseFormat);
+            modelWithStructuredOutput =
+                _getModel(llm).withStructuredOutput(responseFormat);
         }
         const response = await modelWithStructuredOutput.invoke(messages, config);
         return { structuredResponse: response };
     };
     const callModel = async (state, config) => {
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(state, config)] };
+        const response = (await modelRunnable.invoke(state, config));
+        // add agent name to the AIMessage
+        response.name = name;
+        return { messages: [response] };
     };
     const workflow = new StateGraph(stateSchema ?? createReactAgentAnnotation())
         .addNode("agent", callModel)
@@ -215,5 +274,6 @@ export function createReactAgent(params) {
         interruptBefore,
         interruptAfter,
         store,
+        name,
     });
 }