fix: support structured output (providerStrategy) for Google Gemini models in createAgent (langchain-ai#10489)

Author: maahir30

.changeset/nasty-cars-fold.md

@@ -0,0 +1,5 @@
+---
+"langchain": patch
+---
+
+support structured output (providerStrategy) for Google Gemini models in createAgent

libs/langchain/src/agents/nodes/AgentNode.ts

@@ -31,6 +31,7 @@ import {
   hasToolCalls,
   isClientTool,
 } from "../utils.js";
+import { isConfigurableModel } from "../model.js";
 import { mergeAbortSignals, toPartialZodObject } from "../nodes/utils.js";
 import { CreateAgentParams } from "../types.js";
 import type { InternalAgentState, Runtime } from "../runtime.js";
@@ -164,17 +165,28 @@ export class AgentNode<
    * @param model - The model to get the response format for.
    * @returns The response format.
    */
-  #getResponseFormat(
+  async #getResponseFormat(
     model: string | LanguageModelLike
-  ): ResponseFormat | undefined {
+  ): Promise<ResponseFormat | undefined> {
     if (!this.#options.responseFormat) {
       return undefined;
     }
 
+    let resolvedModel: LanguageModelLike | undefined;
+    if (isConfigurableModel(model)) {
+      resolvedModel = await (
+        model as unknown as {
+          _getModelInstance: () => Promise<LanguageModelLike>;
+        }
+      )._getModelInstance();
+    } else if (typeof model !== "string") {
+      resolvedModel = model;
+    }
+
     const strategies = transformResponseFormat(
       this.#options.responseFormat,
       undefined,
-      model
+      resolvedModel
     );
 
     /**
@@ -350,7 +362,9 @@ export class AgentNode<
        */
       validateLLMHasNoBoundTools(request.model);
 
-      const structuredResponseFormat = this.#getResponseFormat(request.model);
+      const structuredResponseFormat = await this.#getResponseFormat(
+        request.model
+      );
       const modelWithTools = await this.#bindTools(
         request.model,
         request,
@@ -943,6 +957,12 @@ export class AgentNode<
           },
         },
 
+        /**
+         * Google-style options
+         * Used by ChatGoogle and other Gemini-based providers.
+         */
+        responseSchema: structuredResponseFormat.strategy.schema,
+
         /**
          * for LangSmith structured output tracing
          */

libs/langchain/src/agents/responses.ts

@@ -19,7 +19,7 @@ import {
   StructuredOutputParsingError,
   MultipleStructuredOutputsError,
 } from "./errors.js";
-import { isConfigurableModel, isBaseChatModel } from "./model.js";
+import { isBaseChatModel } from "./model.js";
 
 /**
  * Special type to indicate that no response format is provided.
@@ -311,7 +311,7 @@ export function transformResponseFormat(
     | ToolStrategy<any>[]
     | ResponseFormatUndefined,
   options?: ToolStrategyOptions,
-  model?: LanguageModelLike | string
+  model?: LanguageModelLike
 ): ResponseFormat[] {
   if (!responseFormat) {
     return [];
@@ -675,76 +675,29 @@ export type JsonSchemaFormat = {
   __brand?: never;
 };
 
-const CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = ["ChatOpenAI", "ChatXAI"];
-const MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT = [
-  "grok",
-  "gpt-5",
-  "gpt-4.1",
-  "gpt-4o",
-  "gpt-oss",
-  "o3-pro",
-  "o3-mini",
-];
-
 /**
- * Identifies the models that support JSON schema output
- * @param model - The model to check
+ * Identifies the models that support JSON schema output by reading
+ * the model's profile metadata.
+ *
+ * @param model - A resolved model instance to check. Callers should resolve
+ *   string model names and ConfigurableModel wrappers before calling this.
  * @returns True if the model supports JSON schema output, false otherwise
  */
 export function hasSupportForJsonSchemaOutput(
-  model?: LanguageModelLike | string
+  model?: LanguageModelLike
 ): boolean {
-  if (!model) {
-    return false;
-  }
-
-  if (typeof model === "string") {
-    const modelName = model.split(":").pop() as string;
-    return MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(
-      (modelNameSnippet) => modelName.includes(modelNameSnippet)
-    );
-  }
-
-  if (isConfigurableModel(model)) {
-    const configurableModel = model as unknown as {
-      _defaultConfig: { model: string };
-    };
-    return hasSupportForJsonSchemaOutput(
-      configurableModel._defaultConfig.model
-    );
-  }
-
-  if (!isBaseChatModel(model)) {
-    return false;
-  }
-
-  const chatModelClass = model.getName();
-
-  /**
-   * for testing purposes only
-   */
-  if (chatModelClass === "FakeToolCallingChatModel") {
-    return true;
-  }
-
   if (
-    CHAT_MODELS_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.includes(chatModelClass) &&
-    /**
-     * OpenAI models
-     */ (("model" in model &&
-      MODEL_NAMES_THAT_SUPPORT_JSON_SCHEMA_OUTPUT.some(
-        (modelNameSnippet) =>
-          typeof model.model === "string" &&
-          model.model.includes(modelNameSnippet)
-      )) ||
-      /**
-       * for testing purposes only
-       */
-      (chatModelClass === "FakeToolCallingModel" &&
-        "structuredResponse" in model))
+    !model ||
+    !isBaseChatModel(model) ||
+    !("profile" in model) ||
+    typeof model.profile !== "object" ||
+    !model.profile
   ) {
-    return true;
+    return false;
   }
 
-  return false;
+  return (
+    "structuredOutput" in model.profile &&
+    model.profile.structuredOutput === true
+  );
 }

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

@@ -687,42 +687,32 @@ describe("hasSupportForJsonSchemaOutput", () => {
     expect(hasSupportForJsonSchemaOutput(undefined)).toBe(false);
   });
 
-  it("should return true for models that support JSON schema output", () => {
+  it("should use model.profile.structuredOutput to determine support", () => {
     const model = new FakeToolCallingModel({});
     expect(hasSupportForJsonSchemaOutput(model)).toBe(false);
     const model2 = new FakeToolCallingChatModel({});
     expect(hasSupportForJsonSchemaOutput(model2)).toBe(true);
   });
 
-  it("should return true for OpenAI models that support JSON schema output", () => {
+  it("should return true for OpenAI models whose profile reports structuredOutput", () => {
     const model = new ChatOpenAI({
       model: "gpt-4o",
     });
     expect(hasSupportForJsonSchemaOutput(model)).toBe(true);
-    expect(hasSupportForJsonSchemaOutput("openai:gpt-4o")).toBe(true);
-    expect(hasSupportForJsonSchemaOutput("gpt-4o-mini")).toBe(true);
   });
 
-  it("should return false for OpenAI models that do not support JSON schema output", () => {
+  it("should return false for OpenAI models whose profile does not report structuredOutput", () => {
     const model = new ChatOpenAI({
       model: "gpt-3.5-turbo",
     });
     expect(hasSupportForJsonSchemaOutput(model)).toBe(false);
-    expect(hasSupportForJsonSchemaOutput("openai:gpt-3.5-turbo")).toBe(false);
-    expect(hasSupportForJsonSchemaOutput("gpt-3.5-turbo")).toBe(false);
   });
 
-  it("should return false for Anthropic models that don't support JSON schema output", () => {
+  it("should return false for Anthropic models whose profile does not report structuredOutput", () => {
     const model = new ChatAnthropic({
       model: "claude-sonnet-4-5-20250929",
       anthropicApiKey: "foobar",
     });
     expect(hasSupportForJsonSchemaOutput(model)).toBe(false);
-    expect(
-      hasSupportForJsonSchemaOutput("anthropic:claude-sonnet-4-5-20250929")
-    ).toBe(false);
-    expect(hasSupportForJsonSchemaOutput("claude-sonnet-4-5-20250929")).toBe(
-      false
-    );
   });
 });

libs/langchain/src/agents/tests/utils.ts

@@ -7,6 +7,7 @@ import {
   BindToolsInput,
   ToolChoice,
 } from "@langchain/core/language_models/chat_models";
+import type { ModelProfile } from "@langchain/core/language_models/profile";
 import { StructuredTool } from "@langchain/core/tools";
 import {
   BaseMessage,
@@ -191,6 +192,13 @@ export class FakeToolCallingChatModel extends BaseChatModel {
     return "fake";
   }
 
+  get profile(): ModelProfile {
+    return {
+      toolCalling: true,
+      structuredOutput: true,
+    };
+  }
+
   async _generate(
     messages: BaseMessage[],
     _options: this["ParsedCallOptions"],