How can I enforce a Zod-validated output format using an Output Parser in a LangChain agent?

Below is one common workaround: instead of expecting the agent chain to automatically use the Zod parser as its output parser (like you can do in a non‐agent chain), you can wrap or post-process the agent’s output with your Zod schema. In other words, after invoking the agent, pass its output through your Zod parser. For example, using LangChain’s output parser (if you’d like to integrate it into the chain) you can do something like this:

TYPESCRIPTCopied
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";
import { ZodOutputParser } from "langchain/output_parsers"; // ensure you have an appropriate output parser available

// Define your Zod schema for structured output
const format = z.object({
  original: z.string().describe("The original phrase"),
  translated: z.string().describe("The translated phrase"),
});

// Create a Zod-based output parser instance
const outputParser = new ZodOutputParser(format);

const model = new ChatOpenAI({ model: "gpt-4o", temperature: 0.7 });
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"),
]);

// Create the agent; note that many of our agent constructors (like createOpenAIToolsAgent)
// do not yet have first-class support for output parsers. One approach is to pass the parser if supported:
const agent = await createOpenAIToolsAgent({
  llm: model,
  tools,
  prompt: promptTemplate,
  // (optional) if createOpenAIToolsAgent accepts an outputParser parameter:
  outputParser,
});

// Then create the executor as usual.
const agentExecutor = new AgentExecutor({
  agent,
  tools,
  verbose: false,
});

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

// If the agent does not automatically run your output parser, simply post-process:
const structuredResponse = outputParser.parse(rawResponse);
console.log(structuredResponse);

Explanation

1. Define a Zod schema:
   The schema “format” describes the expected structure.

2. Create a Zod-based output parser:
   Here we import a (hypothetical or experimental) ZodOutputParser from LangChain’s output parser module. (If you’re using a version without one, you can manually call format.parse(rawOutput)).

3. Integrate with the agent:
   If the agent creation function accepts an outputParser parameter, pass it in. Otherwise, wrap the agent executor’s result with your parser as shown.

4. Post-Processing:
   In our example, after the agent returns its raw output, we pass it through our Zod parser to enforce the structured format.

Currently, direct piping of an output parser into an agent chain (so that the agent always emits structured, Zod-validated output) isn’t as well documented for the agent case. This workaround manually forces your agent’s output into the Zod format either by passing the output parser (if supported on your version) or by post-processing the returned result.

This method lets you continue using your agent while enforcing a structured schema for downstream processing.