@langchain/langgraph 0.0.27 → 0.0.28

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -1,5 +1,6 @@
-import { StructuredTool } from "@langchain/core/tools";
+import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseMessage } from "@langchain/core/messages";
+import { RunnableToolLike } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { CompiledStateGraph } from "../graph/state.js";
 import { START } from "../graph/index.js";
@@ -8,5 +9,5 @@ export type FunctionCallingExecutorState = {
 };
 export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
     model: Model;
-    tools: Array<StructuredTool> | ToolExecutor;
+    tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;
 }): CompiledStateGraph<FunctionCallingExecutorState, Partial<FunctionCallingExecutorState>, typeof START | "agent" | "action">;

package/dist/prebuilt/chat_agent_executor.js

@@ -1,6 +1,6 @@
 import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
 import { FunctionMessage } from "@langchain/core/messages";
-import { RunnableLambda } from "@langchain/core/runnables";
+import { RunnableLambda, } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph, } from "../graph/state.js";
 import { END, START } from "../graph/index.js";

package/dist/prebuilt/react_agent_executor.d.ts

@@ -1,7 +1,7 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
-import { Runnable } from "@langchain/core/runnables";
-import { StructuredTool } from "@langchain/core/tools";
+import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { START } from "../graph/index.js";
 import { MessagesState } from "../graph/message.js";
@@ -14,7 +14,7 @@ export interface AgentState {
 export type N = typeof START | "agent" | "tools";
 export type CreateReactAgentParams = {
     llm: BaseChatModel;
-    tools: ToolNode<MessagesState> | StructuredTool[];
+    tools: ToolNode<MessagesState> | (StructuredToolInterface | RunnableToolLike)[];
     messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
     checkpointSaver?: BaseCheckpointSaver;
     interruptBefore?: N[] | All;

package/dist/prebuilt/tool_executor.d.ts

@@ -1,7 +1,7 @@
-import { RunnableBinding, RunnableConfig } from "@langchain/core/runnables";
-import { StructuredTool } from "@langchain/core/tools";
+import { RunnableBinding, RunnableConfig, RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 export interface ToolExecutorArgs {
-    tools: Array<StructuredTool>;
+    tools: Array<StructuredToolInterface | RunnableToolLike>;
     /**
      * @default {INVALID_TOOL_MSG_TEMPLATE}
      */
@@ -18,8 +18,8 @@ type ToolExecutorInputType = any;
 type ToolExecutorOutputType = any;
 export declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {
     lc_graph_name: string;
-    tools: Array<StructuredTool>;
-    toolMap: Record<string, StructuredTool>;
+    tools: Array<StructuredToolInterface | RunnableToolLike>;
+    toolMap: Record<string, StructuredToolInterface | RunnableToolLike>;
     invalidToolMsgTemplate: string;
     constructor(fields: ToolExecutorArgs);
     /**

package/dist/prebuilt/tool_node.d.ts

@@ -1,5 +1,6 @@
 import { BaseMessage } from "@langchain/core/messages";
-import { StructuredTool } from "@langchain/core/tools";
+import { RunnableToolLike } from "@langchain/core/runnables";
+import { StructuredToolInterface } from "@langchain/core/tools";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
 import { MessagesState } from "../graph/message.js";
@@ -10,8 +11,8 @@ export declare class ToolNode<T extends BaseMessage[] | MessagesState> extends R
     tool calls are requested, they will be run in parallel. The output will be
     a list of ToolMessages, one for each tool call.
     */
-    tools: StructuredTool[];
-    constructor(tools: StructuredTool[], name?: string, tags?: string[]);
+    tools: (StructuredToolInterface | RunnableToolLike)[];
+    constructor(tools: (StructuredToolInterface | RunnableToolLike)[], name?: string, tags?: string[]);
     private run;
 }
 export declare function toolsCondition(state: BaseMessage[] | MessagesState): "tools" | typeof END;

package/dist/tests/prebuilt.int.test.js

@@ -3,6 +3,8 @@ import { it, beforeAll, describe, expect } from "@jest/globals";
 import { Tool } from "@langchain/core/tools";
 import { ChatOpenAI } from "@langchain/openai";
 import { HumanMessage } from "@langchain/core/messages";
+import { RunnableLambda } from "@langchain/core/runnables";
+import { z } from "zod";
 import { createReactAgent, createFunctionCallingExecutor, } from "../prebuilt/index.js";
 import { initializeAsyncLocalStorageSingleton } from "../setup/async_local_storage.js";
 // Tracing slows down the tests
@@ -97,6 +99,32 @@ describe("createFunctionCallingExecutor", () => {
         const functionCall = endState.messages.find((message) => message._getType() === "function");
         expect(functionCall.content).toBe(weatherResponse);
     });
+    it("can accept RunnableToolLike tools", async () => {
+        const weatherResponse = `Not too cold, not too hot 😎`;
+        const model = new ChatOpenAI();
+        const sfWeatherTool = RunnableLambda.from(async (_) => weatherResponse);
+        const tools = [
+            sfWeatherTool.asTool({
+                name: "current_weather",
+                description: "Get the current weather report for San Francisco, CA",
+                schema: z.object({
+                    location: z.string(),
+                }),
+            }),
+        ];
+        const functionsAgentExecutor = createFunctionCallingExecutor({
+            model,
+            tools,
+        });
+        const response = await functionsAgentExecutor.invoke({
+            messages: [new HumanMessage("What's the weather like in SF?")],
+        });
+        // It needs at least one human message, one AI and one function message.
+        expect(response.messages.length > 3).toBe(true);
+        const firstFunctionMessage = response.messages.find((message) => message._getType() === "function");
+        expect(firstFunctionMessage).toBeDefined();
+        expect(firstFunctionMessage?.content).toBe(weatherResponse);
+    });
 });
 describe("createReactAgent", () => {
     it("can call a tool", async () => {

package/dist/tests/prebuilt.test.js

@@ -5,6 +5,7 @@ import { StructuredTool, Tool } from "@langchain/core/tools";
 import { FakeStreamingLLM } from "@langchain/core/utils/testing";
 import { AIMessage, HumanMessage, SystemMessage, ToolMessage, } from "@langchain/core/messages";
 import { z } from "zod";
+import { RunnableLambda } from "@langchain/core/runnables";
 import { FakeToolCallingChatModel } from "./utils.js";
 import { createAgentExecutor, createReactAgent } from "../prebuilt/index.js";
 // Tracing slows down the tests
@@ -367,4 +368,49 @@ describe("createReactAgent", () => {
             new AIMessage("result2"),
         ]);
     });
+    it("Can accept RunnableToolLike", async () => {
+        const llm = new FakeToolCallingChatModel({
+            responses: [
+                new AIMessage({
+                    content: "result1",
+                    tool_calls: [
+                        { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                    ],
+                }),
+                new AIMessage("result2"),
+            ],
+        });
+        // Instead of re-implementing the tool, wrap it in a RunnableLambda and
+        // call `asTool` to create a RunnableToolLike.
+        const searchApiWithArtifactsTool = new SearchAPIWithArtifact();
+        const runnableToolLikeTool = RunnableLambda.from(async (input, config) => searchApiWithArtifactsTool.invoke(input, config)).asTool({
+            name: searchApiWithArtifactsTool.name,
+            description: searchApiWithArtifactsTool.description,
+            schema: searchApiWithArtifactsTool.schema,
+        });
+        const agent = createReactAgent({
+            llm,
+            tools: [runnableToolLikeTool],
+            messageModifier: "You are a helpful assistant",
+        });
+        const result = await agent.invoke({
+            messages: [new HumanMessage("Hello Input!")],
+        });
+        expect(result.messages).toEqual([
+            new HumanMessage("Hello Input!"),
+            new AIMessage({
+                content: "result1",
+                tool_calls: [
+                    { name: "search_api", id: "tool_abcd123", args: { query: "foo" } },
+                ],
+            }),
+            new ToolMessage({
+                name: "search_api",
+                content: "some response format",
+                tool_call_id: "tool_abcd123",
+                artifact: Buffer.from("123"),
+            }),
+            new AIMessage("result2"),
+        ]);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "LangGraph",
   "type": "module",
   "engines": {