fix(langchain): properly retrieve structured output from thinking block (#9623)

Author: christian-bromann

.changeset/khaki-fishes-compare.md

@@ -0,0 +1,5 @@
+---
+"langchain": patch
+---
+
+fix(langchain): properly retrieve structured output from thinking block

libs/langchain/src/agents/responses.ts

@@ -165,19 +165,45 @@ export class ProviderStrategy<T = unknown> {
   /**
    * Parse tool arguments according to the schema. If the response is not valid, return undefined.
    *
-   * @param toolArgs - The arguments from the tool call
+   * @param response - The AI message response to parse
    * @returns The parsed response according to the schema type
    */
   parse(response: AIMessage) {
     /**
-     * return if the response doesn't contain valid content
+     * Extract text content from the response.
+     * Handles both string content and array content (e.g., from thinking models).
      */
-    if (typeof response.content !== "string" || response.content === "") {
+    let textContent: string | undefined;
+
+    if (typeof response.content === "string") {
+      textContent = response.content;
+    } else if (Array.isArray(response.content)) {
+      /**
+       * For thinking models, content is an array with thinking blocks and text blocks.
+       * Extract the text from text blocks.
+       */
+      for (const block of response.content) {
+        if (
+          typeof block === "object" &&
+          block !== null &&
+          "type" in block &&
+          block.type === "text" &&
+          "text" in block &&
+          typeof block.text === "string"
+        ) {
+          textContent = block.text;
+          break; // Use the first text block found
+        }
+      }
+    }
+
+    // Return if no valid text content found
+    if (!textContent || textContent === "") {
       return;
     }
 
     try {
-      const content = JSON.parse(response.content);
+      const content = JSON.parse(textContent);
       const validator = new Validator(this.schema);
       const result = validator.validate(content);
       if (!result.valid) {

libs/langchain/src/agents/tests/responses.int.test.ts

@@ -245,3 +245,130 @@ describe("Strategy Selection", () => {
     expect(hasExtractToolCalls).toBe(false);
   });
 });
+
+describe("Thinking models with responseFormat", () => {
+  it("should parse structured response from thinking model with providerStrategy", async () => {
+    // Use Anthropic model with thinking enabled
+    const model = new ChatAnthropic({
+      model: "claude-haiku-4-5-20251001",
+      thinking: { type: "enabled", budget_tokens: 5000 },
+      maxTokens: 15000,
+    });
+
+    // Define tools that should be called before returning structured output
+    const { tool: getDetailByName, mock: getDetailByNameMock } = makeTool(
+      ({ name }: { name: string }) =>
+        JSON.stringify({
+          name,
+          color: "blue",
+          size: "large",
+        }),
+      {
+        name: "get_detail_by_name",
+        description: "Get details about a shape by its name",
+        schema: z.object({
+          name: z.string(),
+        }),
+      }
+    );
+
+    const { tool: deleteShape, mock: deleteShapeMock } = makeTool(
+      ({ name }: { name: string }) =>
+        `Shape "${name}" has been deleted successfully.`,
+      {
+        name: "delete_shape",
+        description: "Delete a shape by its name",
+        schema: z.object({
+          name: z.string(),
+        }),
+      }
+    );
+
+    const ResponseSchema = z.object({
+      shapeName: z.string().describe("The name of the shape"),
+      details: z.string().describe("Details about the shape"),
+      wasDeleted: z.boolean().describe("Whether the shape was deleted"),
+    });
+
+    const agent = createAgent({
+      model,
+      tools: [getDetailByName, deleteShape],
+      systemPrompt: `You are a helpful shape management assistant.
+When asked to perform operations on shapes, you MUST:
+1. First use the get_detail_by_name tool to get information about the shape
+2. Then use the delete_shape tool if deletion is requested
+3. Only after using the tools, return the structured response`,
+      responseFormat: providerStrategy(ResponseSchema),
+    });
+
+    const result = await agent.invoke({
+      messages: [
+        new HumanMessage(
+          "Please delete the circle shape and tell me about it first"
+        ),
+      ],
+    });
+
+    // Verify user tools were called
+    expect(getDetailByNameMock).toHaveBeenCalledTimes(1);
+    expect(deleteShapeMock).toHaveBeenCalledTimes(1);
+
+    // Verify structured response is present and correctly parsed
+    // This was previously undefined due to thinking model content being an array
+    expect(result.structuredResponse).toBeDefined();
+    expect(result.structuredResponse.shapeName).toBe("circle");
+    expect(result.structuredResponse.wasDeleted).toBe(true);
+    expect(typeof result.structuredResponse.details).toBe("string");
+
+    // Verify no extract- tool calls (providerStrategy uses native structured output)
+    const hasExtractToolCalls = result.messages.some(
+      (msg) =>
+        AIMessage.isInstance(msg) &&
+        msg.tool_calls?.some((tc) => tc.name.startsWith("extract-"))
+    );
+    expect(hasExtractToolCalls).toBe(false);
+
+    // Verify AI messages contain thinking blocks (array content)
+    const aiMessages = result.messages.filter(AIMessage.isInstance);
+    const hasThinkingContent = aiMessages.some(
+      (msg) =>
+        Array.isArray(msg.content) &&
+        msg.content.some(
+          (block: any) =>
+            typeof block === "object" &&
+            block !== null &&
+            block.type === "thinking"
+        )
+    );
+    expect(hasThinkingContent).toBe(true);
+  });
+
+  it("should fail with toolStrategy and thinking models due to tool_choice conflict", async () => {
+    // Use Anthropic model with thinking enabled
+    const model = new ChatAnthropic({
+      model: "claude-haiku-4-5-20251001",
+      thinking: { type: "enabled", budget_tokens: 5000 },
+      maxTokens: 15000,
+    });
+
+    const ResponseSchema = z.object({
+      answer: z.string(),
+    });
+
+    const agent = createAgent({
+      model,
+      tools: [],
+      // toolStrategy uses tool_choice: "any" which conflicts with thinking mode
+      responseFormat: toolStrategy(ResponseSchema),
+    });
+
+    // This should fail because Anthropic doesn't allow thinking with forced tool use
+    await expect(
+      agent.invoke({
+        messages: [new HumanMessage("What is 2+2?")],
+      })
+    ).rejects.toThrow(
+      /Thinking may not be enabled when tool_choice forces tool use/
+    );
+  });
+});