LangChain create_tool_calling_agent — tool schema validation errors

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

@tool
def search(query: str, max_results: int = 5) -> str:
    """Search the web for information.

    Args:
        query: The search query, e.g. "current NASDAQ index"
        max_results: How many results to return (default 5, max 20)

    Returns:
        Newline-delimited search result snippets.
    """
    # Your implementation
    return f"Result 1 for {query}\nResult 2 for {query}"

@tool
def get_weather(city: str, units: str = "celsius") -> str:
    """Return current weather for a city.

    Args:
        city: City name, e.g. "Karachi" or "Cairo, Egypt"
        units: Temperature units, either "celsius" or "fahrenheit"

    Returns:
        A one-line weather report.
    """
    return f"{city}: 32°C, humid"

tools = [search, get_weather]

# Build the agent
model = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are helpful. Use tools when they help."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(model, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "What is the weather in Karachi?"})
print(result["output"])

from typing import List, Literal
from pydantic import BaseModel, Field
from langchain_core.tools import StructuredTool

class SearchInput(BaseModel):
    """Input schema for the search tool."""
    query: str = Field(description="The search query in plain English")
    site_filter: List[str] = Field(
        default_factory=list,
        description="Optional list of domains to restrict search to, e.g. ['wikipedia.org']"
    )
    result_type: Literal["general", "news", "images"] = Field(
        default="general",
        description="What kind of results to return"
    )

def _search_impl(query: str, site_filter: list, result_type: str) -> str:
    # Real implementation
    return f"[{result_type}] Results for {query} (sites: {site_filter or 'any'})"

search_tool = StructuredTool.from_function(
    func=_search_impl,
    name="web_search",           # explicit name — no invalid characters
    description="Search the web with optional site restrictions and result type filter.",
    args_schema=SearchInput,
)

# Same pattern with an async twin
async def _search_impl_async(query: str, site_filter: list, result_type: str) -> str:
    # Async real implementation
    return f"[{result_type} async] Results for {query}"

search_tool_async = StructuredTool.from_function(
    func=_search_impl,
    coroutine=_search_impl_async,   # async version
    name="web_search",
    description="...",
    args_schema=SearchInput,
)

# Use with any tool-calling agent
tools = [search_tool]

from typing import List, Literal
from pydantic import BaseModel, Field
from langchain_core.tools import tool

# ❌ Optional-heavy: OpenAI strict mode rejects
# @tool
# def search(query: str, site_filter: Optional[List[str]] = None,
#           result_type: Optional[str] = None) -> str:
#     ...

# ✓ Required fields with sensible defaults (portable)
@tool
def search(
    query: str,
    site_filter: List[str] = [],                                # empty list, not None
    result_type: Literal["general", "news", "images"] = "general",  # enum with default
) -> str:
    """Search the web with optional filters.

    Args:
        query: The search query in plain English.
        site_filter: List of domains to restrict search to. Use [] for no restriction.
        result_type: One of general, news, images.
    """
    return "results here"

# Validate the tool schema against the provider you'll actually call
def validate_for_openai_strict(tool):
    """Confirms tool schema is compatible with OpenAI strict mode."""
    schema = tool.args_schema.model_json_schema() if tool.args_schema else tool.tool_call_schema.model_json_schema()
    # Strict mode requires: all fields in required, additionalProperties: false, no Optional
    props = schema.get("properties", {})
    required = set(schema.get("required", []))
    for name, prop in props.items():
        if name not in required:
            raise ValueError(f"OpenAI strict: field '{name}' must be required")
        if "null" in prop.get("type", []) if isinstance(prop.get("type"), list) else False:
            raise ValueError(f"OpenAI strict: field '{name}' must not allow null")
    return True

validate_for_openai_strict(search)