LangGraph with Tools Derived from DynamicStructuredTool

[getvineet]

Do we have any example of LanGraph (especially Reflection Pattern) that uses custom Tools created by deriving from DynamicStructuralTool.

Below is the code that I have and getting the error "Error: ToolNode only accepts AIMessages as input."

`import { DynamicStructuredTool } from "@langchain/core/tools";
import { AzureChatOpenAI } from "@langchain/openai";
import { z } from 'zod';
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { Annotation, END, MemorySaver, START, StateGraph } from "@langchain/langgraph";
import { BaseMessage, HumanMessage } from "@langchain/core/messages";

export async function TestCustomToolsWithLangGraph(userInputText: string) {
dotenv.config();
console.log("User Query: ", userInputText);

// Create a LLM model for the agent
let deployment_name = process.env.AZURE_OPENAI_DEPLOYMENT_NAME;
let api_version = process.env.AZURE_OPENAI_API_VERSION;
let instanceName = process.env.AZURE_OPENAI_INSTNACE_NAME;
let end_point = process.env.AZURE_OPENAI_API_BASE_PATH;
const api_key = process.env.AZURE_OPENAI_API_KEY;

const model = new AzureChatOpenAI({
    temperature: 0,
    azureOpenAIBasePath: end_point,
    azureOpenAIApiDeploymentName: deployment_name,
    azureOpenAIApiInstanceName: instanceName,
    azureOpenAIApiVersion: api_version,
    azureOpenAIApiKey: api_key
});

const generationTool = new DynamicStructuredTool({
    name: "generate",
    description: "generate Domain Specific code",
    schema: z.object({
        a: z.string().describe("user query to generate code")
    }),
    func: async ({ a }: { a: string }) => {
        return "I can write code for you for " + a;
    },
});

const evaluationTool = new DynamicStructuredTool({
    name: "evaluate",
    description: "Check if the code has any errors",
    schema: z.object({
        a: z.string().describe("The code to check for error")
    }),
    func: async ({ a }: { a: string }) => {
        console.log("Code to evaluate: ", a);
        return "All Good, no errors found in the code";
    },
});

const generationNode = new ToolNode([generationTool]);
const reflectionNode = new ToolNode([evaluationTool]);

// Define the top-level State interface
const State = Annotation.Root({
    messages: Annotation<BaseMessage[]>({
        reducer: (x, y) => x.concat(y),
    })
})

// Define the graph
const workflow = new StateGraph(State)
    .addNode("generate", generationNode)
    .addNode("reflect", reflectionNode)
    .addEdge(START, "generate");

const shouldContinue = (state: typeof State.State) => {
    const { messages } = state;
    const noError = true;
    if (noError ) {
        return END;
    }
    return "generate";
};

workflow
    .addConditionalEdges("reflect", shouldContinue)
    .addEdge("generate", "reflect");

const app = workflow.compile({ checkpointer: new MemorySaver() });

const checkpointConfig = { configurable: { thread_id: "my-thread" } };

const result = await app.invoke(
    {
        messages: [
            new HumanMessage({
                content: userInputText,
            }),
        ]
    },
    checkpointConfig,
);

console.log(result.messages);

}

TestCustomToolsWithLangGraph("Write code to create a 3D solid cube");`

[getvineet]

I request if possible for someone to have a look and check if I am making any mistake

[Sohett]

@getvineet did you find the issue ?

[getvineet]

Not yet. Still not able to make this work