How do I pipe withStructuredOutput to an agent (createOpenAIToolsAgent)? (JS)

[afunworm]

Hello, all.

I couldn't find any docs on how to pipe the structuredOutput to an agent. Below is my code, how do I force the agent to output in a structured Zod format?

import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
import { z } from "zod";
import { createOpenAIToolsAgent, AgentExecutor } from "langchain/agents";

const model = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });
const format = z.object({
	original: z.string().describe("The original phrase"),
	translated: z.string().describe("The translated phrase"),
});

const searchTool = new TavilySearchResults({ maxResults: 1 });
const tools = [searchTool];

const promptTemplate = ChatPromptTemplate.fromMessages([
	["system", "Translate the user's message into {language}"],
	["user", "{input}"],
	new MessagesPlaceholder("chat_history"),
	new MessagesPlaceholder("agent_scratchpad"),
]);

const agent = await createOpenAIToolsAgent({
	llm: model,
	tools,
	prompt: promptTemplate,
});

const agentExecutor = new AgentExecutor({
	agent,
	tools,
	verbose: false,
});

const response = await agentExecutor.invoke({
	input: "Hello from the other side.",
	language: "italian",
	agent_scratchpad: [],
	chat_history: [],
});

console.log(response);

[dosubot[bot]]

I couldn't find specific documentation or examples in the LangChain repository that directly address how to enforce structured output in a Zod format when using the createOpenAIToolsAgent function in JavaScript. However, you might consider implementing a custom output parser that validates the agent's output against your Zod schema after the response is generated. This approach involves manually checking the output and ensuring it conforms to the desired structure.

Here's a general idea of how you might implement this:

1. Invoke the Agent: Use the agentExecutor to get the response from the agent as you are currently doing.

2. Validate the Output: After receiving the response, use your Zod schema to validate the output. If the output does not match the schema, you can handle the error accordingly.

Here's a simplified example of how you might integrate Zod validation:

const response = await agentExecutor.invoke({
    input: "Hello from the other side.",
    language: "italian",
    agent_scratchpad: [],
    chat_history: [],
});

// Validate the response using the Zod schema
try {
    const validatedResponse = format.parse(response);
    console.log(validatedResponse);
} catch (e) {
    console.error("Validation failed:", e.errors);
}

This approach allows you to enforce structured output by validating the agent's response after it is generated. If the response does not conform to the expected format, you can handle it as needed, such as logging an error or attempting to reformat the output.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[rodrigogs]

It is much needed!