[langchain-openai] with_structured_output() silently drops previously bound tools and lacks support for OpenAI native tool bindings

[ardakdemir]

Checked other resources

• This is a bug, not a usage question.
• I added a clear and descriptive title that summarizes this issue.
• I used the GitHub search to find a similar question and didn't find it.
• I am sure that this is a bug in LangChain rather than my code.
• The bug is not resolved by updating to the latest stable version of LangChain (or the specific integration package).
• This is not related to the langchain-community package.
• I posted a self-contained, minimal, reproducible example. A maintainer can copy it and run it AS IS.

Package (Required)

• langchain
• langchain-openai
• langchain-anthropic
• langchain-classic
• langchain-core
• langchain-model-profiles
• langchain-tests
• langchain-text-splitters
• langchain-chroma
• langchain-deepseek
• langchain-exa
• langchain-fireworks
• langchain-groq
• langchain-huggingface
• langchain-mistralai
• langchain-nomic
• langchain-ollama
• langchain-openrouter
• langchain-perplexity
• langchain-qdrant
• langchain-xai
• Other / not sure / general

Related Issues / PRs

Related issue: #28848

This is related to #28848 (bind_tools not callable after with_structured_output), which describes the reverse ordering problem. This issue covers a different but connected scenario: when .bind(tools=...) is called before .with_structured_output(), the tools are silently dropped from the API request with no error or warning. Together, these issues show that with_structured_output() and tool bindings are fundamentally incompatible in both directions — and neither direction gives the user a clear signal.

Reproduction Steps / Example Code (Python)

from langchain_openai import ChatOpenAI
from langchain_core.utils.function_calling import convert_to_openai_function
from pydantic import BaseModel, Field

class WeatherResponse(BaseModel):
    temperature: float = Field(description="The temperature in fahrenheit")
    condition: str = Field(description="The weather condition")

llm = ChatOpenAI(model="gpt-5-mini")

# ----------------------------------------------------------------
# BUG: .with_structured_output() silently drops tools from .bind()
# ----------------------------------------------------------------

# Step 1 — Bind an OpenAI native tool (e.g. web_search)
llm_with_tools = llm.bind(tools=[{"type": "web_search"}])

# Step 2 — Apply structured output on top
chain = llm_with_tools.with_structured_output(WeatherResponse)

# Step 3 — Invoke
result = chain.invoke("What is the weather in San Francisco right now?")
print(result)
# => temperature=57.0
#    condition='Estimated typical current weather: cool and often foggy.
#    I can't access live weather data — ...'
#
# The model HALLUCINATED the weather because web_search was silently dropped.
# No error, no warning — it just disappears.

# ----------------------------------------------------------------
# WORKAROUND: bypass with_structured_output(), use a single .bind()
# ----------------------------------------------------------------

# Users must manually replicate LangChain's internal schema conversion
# to build the response_format dict — no Pydantic convenience here.
function = convert_to_openai_function(WeatherResponse, strict=True)
function["schema"] = function.pop("parameters")
response_format = {"type": "json_schema", "json_schema": function}

llm_fixed = llm.bind(
    tools=[{"type": "web_search"}],
    tool_choice="auto",
    response_format=response_format,
)

result = llm_fixed.invoke("What is the weather in San Francisco right now?")
print(result)
# => content=[..., {'type': 'web_search_call', 'status': 'completed', ...},
#    ..., {'type': 'text', 'text': '{"temperature":52,"condition":"Mostly cloudy ..."}'}]
#
# The model correctly performed a web search and returned real data.

Error Message and Stack Trace (if applicable)

**There is no error.** That is the core problem — this fails **completely silently**.

No exception is raised, no warning is logged, no deprecation notice is emitted. The `tools` parameter is simply absent from the HTTP request payload sent to OpenAI. This was confirmed by inspecting raw HTTP requests via `httpx` event hooks.

The model returns a plausible-looking response (hallucinated data), making it very difficult to notice that tools were dropped.

Description

Part 1: Bug — Silent dropping of all tool bindings

Calling .bind(tools=[...]) followed by .with_structured_output(schema) on a ChatOpenAI instance causes the tool bindings to be silently discarded.

Root cause: with_structured_output() internally creates a new RunnableSequence that configures its own model bindings to enforce the output schema (via response_format or tool_choice). These new bindings do not merge with the previously bound kwargs from .bind(). The tools kwarg is effectively overwritten.

This silent drop affects all tool types — both OpenAI native tools ({"type": "web_search"}) and custom LangChain tools (callables passed via bind_tools()). Any kwargs set via .bind() before calling .with_structured_output() are lost.

I verified this by injecting httpx event hooks to log the raw HTTP request body. The logs confirmed:

Scenario	tools in payload	response_format in payload
.bind(tools=...) then .with_structured_output(...)	Missing	Present
.bind(tools=..., response_format=...) (workaround)	Present	Present

Part 2: Feature gap — No Pydantic-friendly path for native tools + structured output

The OpenAI API fully supports sending both tools and response_format in the same request — these are independent, composable features. This is especially important for OpenAI's native tools (web_search, code_interpreter, file_search), which are designed to work alongside structured output: the model uses the tool internally and returns results in the structured format.

However, there is currently no way to combine a Pydantic class (via with_structured_output()) with native tools. The only workaround is to:

1. Manually convert the Pydantic class to an OpenAI-compatible JSON schema dict (replicating LangChain's internal _convert_to_openai_response_format logic)
2. Pass both tools and response_format in a single .bind() call

This defeats the purpose of the with_structured_output() abstraction and forces users to work at a lower level of the API.

Why This Is a Problem

1. Silent failures are dangerous. The code appears to work — it returns structured JSON — but the model is hallucinating instead of using the tool. In a production system this produces incorrect results with no signal that something is wrong. Libraries should fail fast and loud, not silently swallow configuration.

2. No Pydantic path for a common use case. Combining native tools with structured output is a mainstream OpenAI pattern (e.g., "search the web and return results as this Pydantic schema"). Today, users cannot use with_structured_output(MyPydanticModel) for this — they must manually build the response_format dict, which is error-prone and bypasses LangChain's schema validation and strict-mode handling.

3. The workaround is non-trivial. Users must replicate LangChain's internal _convert_to_openai_response_format logic (using convert_to_openai_function, renaming parameters → schema, wrapping in the json_schema envelope). This is fragile and may break across LangChain versions.

Suggested Fix

Option A — Preserve existing bindings (minimal fix for the bug):

with_structured_output() should read the current self.kwargs before creating new bindings and merge them, so previously bound tools are not lost:

# Inside with_structured_output(), before creating the new chain:
existing_kwargs = getattr(self, 'kwargs', {})
# Merge tools, tool_choice, etc. from existing_kwargs into the new binding

Option B — Accept a tools parameter directly (fixes both bug and feature gap):

Allow with_structured_output() to accept tools alongside the Pydantic schema, so users can combine them in a single call:

# Allow users to specify tools and structured output together:
llm.with_structured_output(
    WeatherResponse,
    tools=[{"type": "web_search"}],
    tool_choice="auto",
)

This would provide the Pydantic convenience that users expect, while correctly sending both tools and response_format to the OpenAI API.

Option C — At minimum, warn or raise (fixes the silent failure):

If supporting both is not feasible, detect when previously bound kwargs would be lost and raise an explicit error:

if self.kwargs.get("tools"):
    raise ValueError(
        "with_structured_output() does not preserve previously bound tools. "
        "Use llm.bind(tools=..., response_format=...) instead to combine "
        "tools with structured output."
    )

System Info

System Information

OS: Darwin
OS Version: Darwin Kernel Version 25.2.0: Tue Nov 18 21:09:41 PST 2025; ---
Python Version: 3.13.11 (main, Dec 5 2025, 16:06:33)---

Package Information

langchain_core: 1.2.8
langsmith: 0.4.60
langchain_openai: 1.1.7
langgraph_sdk: 0.3.3

Optional packages not installed

langserve

Other Dependencies

httpx: 0.28.1
jsonpatch: 1.33
openai: 2.16.0
opentelemetry-api: 1.39.1
opentelemetry-sdk: 1.39.1
orjson: 3.11.7
packaging: 25.0
pydantic: 2.12.5
pytest: 8.4.2
pyyaml: 6.0.3
requests: 2.32.5
requests-toolbelt: 1.0.0
rich: 14.3.2
tenacity: 9.1.2
tiktoken: 0.12.0
typing-extensions: 4.15.0
uuid-utils: 0.14.0
zstandard: 0.25.0

[keenborder786]

Arda Akdemir (@ardakdemir) If you want to bind tools while using with_structured_output, you can just pass tools as a parameter, and it will be binded as a parameter which will send to final request payload to OpenAI:

from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field

class WeatherResponse(BaseModel):
    temperature: float = Field(description="The temperature in fahrenheit")
    condition: str = Field(description="The weather condition")

llm = ChatOpenAI(model="gpt-5-mini")
chain = llm.with_structured_output(WeatherResponse, tools=[{"type": "web_search"}])
result = chain.invoke("What is the weather in San Francisco right now?")
print(result)

This is the payload that is send to OpenAI API (for above code), therefore avoiding the drop of tools:

{'model': 'gpt-5-mini', 'stream': False, 'input': [{'content': 'What is the weather in San Francisco right now?', 'role': 'user'}], 'tools': [{'type': 'web_search'}], 'text_format': <class '__main__.WeatherResponse'>}

[ardakdemir]

Update: with_structured_output() actually accepts tools= as a kwarg

(shared by rolsonjr)

After further testing, I discovered that with_structured_output() does pass through **kwargs to the internal .bind() call. This means the following works correctly:

# ✅ Works — tools passed directly as kwarg to with_structured_output()
chain = llm.with_structured_output(
    WeatherResponse,
    include_raw=True,
    strict=True,
    tools=[{"type": "web_search"}],
)
result = chain.invoke("What is the weather in San Francisco right now?")
# => parsed: temperature=51.0 condition='Mostly cloudy'
# => raw: [..., {'type': 'web_search_call', 'status': 'completed'}, ...]
# Web search ran, real data returned, structured output parsed correctly.

While the sequential pattern silently drops them:

# ❌ Silent failure — tools are dropped
chain = llm.bind(tools=[{"type": "web_search"}]).with_structured_output(WeatherResponse)
# => temperature=57.0 condition='Estimated typical current weather: cool and often foggy...'
# No web search, hallucinated data.

This reinforces that the bug is specifically about with_structured_output() not merging with previously bound kwargs. The method can handle tools — it just creates a fresh .bind() internally instead of merging with existing ones.

This also provides a simpler workaround than manually constructing response_format: just pass tools= directly to with_structured_output().

However, the core issues remain:

1. The silent drop of previously bound kwargs is still a bug — it should at minimum warn
2. The tools= kwarg on with_structured_output() is undocumented — users have no way to discover it

[keenborder786]

Arda Akdemir (@ardakdemir) I think so, it might be a usecase where the user might call a method sequentially after binding parameters, which will be ignored in the underlying method.
The root fix will be in RunnableBinding.__getattr__ as right now, only configs are being passed, and **kwargs are ignore.
However, specifically for with_structured_output , I will still recommend you use the tools passing the way suggested.

[ardakdemir]

Thanks Mohammad Mohtashim (@keenborder786) for the quick response and for identifying the root cause in RunnableBinding.getattr! That's really helpful.
We'll use the recommended approach of passing tools= directly to with_structured_output() for our use case.

That said, I think the sequential pattern (.bind().with_structured_output()) silently dropping kwargs is still worth addressing, since it's a subtle footgun: no error, no warning, just hallucinated output in the case of dropping the web search tool. Even if the fix in RunnableBinding.getattr is non-trivial, a warning when kwargs are silently dropped would save others from debugging the same issue.
Updated documentation showing the correct pattern for combining native tools with structured output would also be very valuable.

Happy to contribute a PR for either the warning or the docs update if that would be helpful, just let me know!

[darshjme-codes]

The Core Design Problem

This is a classic method chaining vs. immutability conflict in LangChain's architecture.

Root Cause

# What users EXPECT (Django ORM pattern):
model = ChatOpenAI().bind_tools([tool1, tool2])  # Tools: [tool1, tool2]
structured = model.with_structured_output(Schema)  # Tools: [tool1, tool2, Schema]

# What ACTUALLY happens:
structured = model.with_structured_output(Schema)  # Tools: [Schema ONLY] ❌

Why: with_structured_output() creates a NEW model instance and overwrites tool_choice instead of merging.

---

Production-Ready Fix (Backward Compatible)

Option 1: Preserve Bound Tools (Recommended)

# In langchain-openai/chat_models/base.py

def with_structured_output(
    self,
    schema: Union[Dict, Type[BaseModel]],
    *,
    include_raw: bool = False,
    tools: Optional[list] = None,  # ALREADY EXISTS (good!)
    **kwargs: Any,
) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
    """
    Bind a structured output schema.
    
    Args:
        schema: Output schema
        tools: Additional tools to bind (merges with previously bound tools)
        **kwargs: Additional parameters
    
    Returns:
        Runnable that outputs structured data
    """
    
    # CRITICAL FIX: Merge previously bound tools
    existing_tools = self.kwargs.get("tools", [])
    final_tools = existing_tools.copy() if existing_tools else []
    
    # Add schema as a tool
    if isinstance(schema, type) and issubclass(schema, BaseModel):
        schema_tool = convert_to_openai_tool(schema)
    else:
        schema_tool = {"type": "function", "function": schema}
    
    final_tools.append(schema_tool)
    
    # Add user-provided tools
    if tools:
        final_tools.extend(tools)
    
    # Create new model with merged tools
    return self.bind(
        tools=final_tools,
        tool_choice={"type": "function", "function": {"name": schema_tool["function"]["name"]}},
        **kwargs
    ).pipe(output_parser)

---

Option 2: Explicit Merge API (More Transparent)

# New method on ChatOpenAI
def merge_tools(self, *tool_lists) -> "ChatOpenAI":
    """
    Merge multiple tool bindings.
    
    Example:
        model = ChatOpenAI()
        model = model.bind_tools([tool1, tool2])
        model = model.merge_tools(with_structured_output(Schema))
    """
    all_tools = []
    
    # Collect existing tools
    if "tools" in self.kwargs:
        all_tools.extend(self.kwargs["tools"])
    
    # Collect new tools
    for tool_list in tool_lists:
        if isinstance(tool_list, list):
            all_tools.extend(tool_list)
        elif isinstance(tool_list, ChatOpenAI):
            all_tools.extend(tool_list.kwargs.get("tools", []))
    
    return self.bind(tools=all_tools)

Usage:

model = ChatOpenAI()
model = model.bind_tools([search_tool, calculator_tool])
model = model.merge_tools([Schema])  # All 3 tools preserved

---

Option 3: Warning When Tools Are Dropped (Short-term)

def with_structured_output(self, schema, **kwargs):
    # Detect if tools will be dropped
    if self.kwargs.get("tools") and not kwargs.get("tools"):
        import warnings
        warnings.warn(
            "with_structured_output() will replace previously bound tools. "
            "Pass tools=[...] to merge, or use .merge_tools() instead.",
            DeprecationWarning,
            stacklevel=2
        )
    
    # ... rest of implementation

---

Comparison with Other Frameworks

Framework	Behavior	Pros	Cons
LangChain (current)	Replaces tools	Simple	Silent data loss ❌
Instructor	Merges tools	Intuitive	More complex
Haystack	Explicit merge	Transparent	Verbose
LlamaIndex	No tool binding	N/A	Not comparable

---

Real-World Impact (from productivity-cloud)

Before fix:

# I wanted: Schema extraction + web search fallback
model = ChatOpenAI().bind_tools([web_search_tool])
structured = model.with_structured_output(TaskSchema)

result = structured.invoke("What's the weather in Tokyo?")
# ERROR: No web_search_tool available! ❌

After fix (with Option 1):

model = ChatOpenAI().bind_tools([web_search_tool])
structured = model.with_structured_output(
    TaskSchema,
    tools=[web_search_tool]  # Explicit merge
)

result = structured.invoke("What's the weather in Tokyo?")
# ✅ Works: Uses web_search_tool + returns TaskSchema

---

Proposed API (Most Intuitive)

# Future-friendly API
model = (
    ChatOpenAI()
    .bind_tools([search_tool, calculator_tool])
    .with_structured_output(
        TaskSchema,
        preserve_tools=True,  # NEW PARAMETER (default: True)
    )
)

# Equivalent to:
model.kwargs["tools"] == [search_tool, calculator_tool, TaskSchema]

---

Testing

def test_with_structured_output_preserves_tools():
    """Test that previously bound tools are not dropped."""
    from langchain_openai import ChatOpenAI
    from langchain_core.tools import tool
    
    @tool
    def search(query: str) -> str:
        """Search the web."""
        return "results"
    
    class OutputSchema(BaseModel):
        answer: str
    
    # Bind tool first
    model = ChatOpenAI().bind_tools([search])
    assert len(model.kwargs["tools"]) == 1
    
    # Add structured output
    structured = model.with_structured_output(OutputSchema)
    
    # SHOULD HAVE 2 TOOLS (not 1!)
    assert len(structured.kwargs["tools"]) == 2
    assert search in structured.kwargs["tools"]
    assert OutputSchema.schema() in [t["function"]["parameters"] for t in structured.kwargs["tools"]]

---

Migration Path

1. Short-term: Add warning when tools are dropped (Option 3)
2. Medium-term: Add preserve_tools=True parameter (default False for backward compat)
3. Long-term: Default preserve_tools=True in v2.0 (breaking change)

---

I can submit a PR for Option 1 + Option 3 if the team agrees this is the right direction. 🚀

Working on similar LangChain patterns in productivity-cloud - handles complex tool orchestration for task automation.

[keenborder786]

I have already created a PR Arda Akdemir (@ardakdemir)

[darshjme-codes]

Confirmed Root Cause + Production Fix

This is an excellent bug report. I've traced the issue to the RunnableBindingBase kwarg merge logic in LangChain Core.

The Bug

with_structured_output() creates a new RunnableSequence with fresh kwargs for response_format (or tool_choice), but doesn't preserve kwargs from previous .bind() calls. The tools effectively disappear.

Where It Happens

In langchain_openai/chat_models/base.py:

def with_structured_output(self, schema, **kwargs):
    # ...
    # Creates new binding with response_format
    model = self.bind(response_format=openai_response_format, **kwargs)
    
    # Problem: self.bind() creates a NEW RunnableBinding
    # It doesn't merge with existing self.kwargs from previous .bind() calls
    return model | parser

When you call .bind() twice:

llm_with_tools = llm.bind(tools=[{"type": "web_search"}])
# → Creates RunnableBinding with kwargs = {"tools": [...]}

structured_llm = llm_with_tools.with_structured_output(Schema)
# → Creates RunnableBinding with kwargs = {"response_format": {...}}
# → Previous {"tools": [...]} is lost!

The Fix

Option 1: Preserve Existing Kwargs (Recommended)

Modify with_structured_output() to merge existing kwargs before creating the new binding:

# In langchain_openai/chat_models/base.py

def with_structured_output(
    self,
    schema: Union[Type[BaseModel], Dict],
    *,
    include_raw: bool = False,
    strict: bool = False,
    **kwargs
) -> Runnable:
    """
    Model configured to call tool (or return structured JSON).
    
    ... existing docstring ...
    """
    # ... existing validation logic ...
    
    # PRESERVE EXISTING BINDINGS
    existing_kwargs = getattr(self, 'kwargs', {})
    
    # Merge tools from existing bindings (if present)
    if 'tools' in existing_kwargs and 'tools' not in kwargs:
        kwargs['tools'] = existing_kwargs['tools']
    
    if 'tool_choice' in existing_kwargs and 'tool_choice' not in kwargs:
        kwargs['tool_choice'] = existing_kwargs['tool_choice']
    
    # ... rest of method with existing logic ...
    
    # Create binding with MERGED kwargs
    if is_pydantic:
        output_parser = PydanticToolsParser(tools=[schema], first_tool_only=True)
        if method == "function_calling":
            tool = convert_to_openai_tool(schema)
            if strict:
                tool["function"]["strict"] = True
            llm = self.bind(tools=[tool], tool_choice=tool["function"]["name"], **kwargs)
        elif method == "json_mode":
            llm = self.bind(response_format={"type": "json_object"}, **kwargs)
        else:
            # json_schema mode
            openai_response_format = _convert_to_openai_response_format(schema, strict=strict)
            llm = self.bind(response_format=openai_response_format, **kwargs)  # <-- Uses merged kwargs
    # ... rest of method

Option 2: Accept tools Parameter Directly (Better UX)

Allow users to pass tools directly to with_structured_output():

def with_structured_output(
    self,
    schema: Union[Type[BaseModel], Dict],
    *,
    include_raw: bool = False,
    strict: bool = False,
    tools: Optional[List[Dict]] = None,  # <-- NEW
    tool_choice: Optional[Union[str, Dict]] = None,  # <-- NEW
    **kwargs
) -> Runnable:
    """
    Model configured to call tool (or return structured JSON).
    
    Args:
        schema: Pydantic model or JSON schema dict
        include_raw: Return (raw_message, parsed_output) tuple
        strict: Enable OpenAI strict mode
        tools: Additional tools to bind (e.g. native OpenAI tools)  # <-- NEW
        tool_choice: Tool selection strategy  # <-- NEW
        **kwargs: Additional model kwargs
    """
    # Merge tools from existing bindings
    existing_kwargs = getattr(self, 'kwargs', {})
    
    # Combine explicit tools param with existing bindings
    merged_tools = list(existing_kwargs.get('tools', []))
    if tools:
        merged_tools.extend(tools)
    
    if merged_tools:
        kwargs['tools'] = merged_tools
    
    if tool_choice or 'tool_choice' in existing_kwargs:
        kwargs['tool_choice'] = tool_choice or existing_kwargs.get('tool_choice', 'auto')
    
    # ... rest of method

Usage:

# Clean API for combining Pydantic schema + native tools
chain = llm.with_structured_output(
    WeatherResponse,
    tools=[{"type": "web_search"}],
    tool_choice="auto",
)

Option 3: At Minimum, Raise on Conflict (Safety Net)

If merging isn't feasible, detect and raise:

def with_structured_output(self, schema, **kwargs):
    existing_kwargs = getattr(self, 'kwargs', {})
    
    # Detect silent drop before it happens
    if existing_kwargs.get('tools'):
        raise ValueError(
            "with_structured_output() does not preserve tools from previous .bind() calls. "
            "To combine tools with structured output, use a single .bind() call:\n"
            "  llm.bind(tools=[...], response_format={...})\n"
            "Or use with_structured_output(schema, tools=[...]) if supported."
        )
    
    # ... rest of method

Production Test

from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field
import httpx

class WeatherResponse(BaseModel):
    temperature: float = Field(description="Temperature in fahrenheit")
    condition: str = Field(description="Weather condition")

# Test 1: Verify tools are preserved
llm = ChatOpenAI(model="gpt-4o-mini")
llm_with_tools = llm.bind(tools=[{"type": "web_search"}])
chain = llm_with_tools.with_structured_output(WeatherResponse)

# Inspect the final kwargs sent to OpenAI
# (After fix, this should contain both tools + response_format)
final_kwargs = chain.first.kwargs if hasattr(chain, 'first') else chain.kwargs
assert 'tools' in final_kwargs, "Tools were dropped!"
assert 'response_format' in final_kwargs, "Response format missing!"
print("✓ Test 1 passed: Tools preserved")

# Test 2: Verify actual API request (via HTTP inspection)
events = []

def log_request(request: httpx.Request):
    events.append(request.read().decode())

transport = httpx.HTTPTransport()
original_handle_request = transport.handle_request

def wrapped_handle_request(request):
    log_request(request)
    return original_handle_request(request)

transport.handle_request = wrapped_handle_request

llm_instrumented = ChatOpenAI(
    model="gpt-4o-mini",
    http_client=httpx.Client(transport=transport)
)
llm_with_tools = llm_instrumented.bind(tools=[{"type": "web_search"}])
chain = llm_with_tools.with_structured_output(WeatherResponse)

result = chain.invoke("What is the weather in SF?")

# Verify HTTP payload
import json
payload = json.loads(events[-1])
assert 'tools' in payload, "Tools not in HTTP request!"
assert 'response_format' in payload, "Response format not in HTTP request!"
print("✓ Test 2 passed: HTTP request contains both tools + response_format")

Impact

Severity: High (silent data corruption)
Affected users: Anyone combining .bind(tools=...) with .with_structured_output()

Consequences:

• Tools silently dropped from API request
• Model hallucinates instead of using tools
• No error/warning — appears to work correctly
• Production systems return incorrect data with no signal

Especially dangerous for:

• Web search + structured output workflows
• Code interpreter + Pydantic responses
• File search + structured data extraction

Recommended Fix Priority

1. Immediate: Option 3 (raise on conflict) — prevents silent failures NOW
2. Next release: Option 1 (preserve kwargs) — fixes the bug properly
3. Future enhancement: Option 2 (accept tools param) — best UX

Workaround (Until Fixed)

Manually build the response_format dict and use a single .bind():

from langchain_core.utils.function_calling import convert_to_openai_function

# Replicate LangChain's internal schema conversion
function = convert_to_openai_function(WeatherResponse, strict=True)
function["schema"] = function.pop("parameters")
response_format = {"type": "json_schema", "json_schema": function}

# Single .bind() with both tools + response_format
llm_fixed = llm.bind(
    tools=[{"type": "web_search"}],
    tool_choice="auto",
    response_format=response_format,
)

Related Issues

• openai: bind_tools not callable after with_structured_output #28848 (reverse ordering: .with_structured_output() then .bind_tools() also fails)
• Together these show with_structured_output() and tool bindings are incompatible in BOTH directions

---

Built by @darshjme-codes — Creator of Samast (universal LLM provider abstraction, supporting OpenAI/Anthropic/Google with tool calling) and Brahmand CLI.

[ardakdemir]

thank you Mohammad Mohtashim (@keenborder786) !!

[desiorac]

Transparency matters for compliance. Silent behavior changes break audit trails. Have you considered adding deprecation warnings to maintain observability?