Tool Call doesn't work when using Structured Outputs w/ kimi-k2-instruct

[SaudKadiri]

Hi,

I'm facing issues when making my agent perform tool calls when using structured outputs.

Bug description

When we use output_type for structured outputs, the agent doesn't perform tool calling; even if we've asked it to explicitly call and passed the tools.

Here during the first run I was using output_type=WeatherOutput; in the second I commented that line out.

Debug information

• Agents SDK version: 0.3.1
• Python version: 3.10

When using output_type=WeatherOutput

VS when not using output_type=WeatherOutput

Repro steps

from agents import Agent, function_tool, Runner
from agents.extensions.models.litellm_model import LitellmModel

from pydantic import BaseModel, Field
import os
import asyncio
from dotenv import load_dotenv
load_dotenv()

class WeatherOutput(BaseModel):
    is_good_weather: bool = Field(..., description='Is the weather good for travel or outdoor activitied?')
    details: str = Field(..., description='Give the detailed weather report.')

@function_tool
def get_weather(city: str) -> str:
    """
    Use this tool to get the weather for a city
    """
    return f'Current weather in {city} is jublious like a rainbow.'


async def weather_friend(prompt: str):
    model = LitellmModel(
        model=os.getenv("CHAT_MODEL_NAME"), # doesn't matter which LLM but I'm using nvidia_nim/moonshotai/kimi-k2-instruct
        api_key=os.getenv("PROVIDER_API_KEY")
    )
    agent = Agent(
        name="Weather Agent",
        instructions=(
            "You are a helpful weather assistant. "
            "Always call the available tools to gather weather data. "
            "Do not fabricate answers. "
            "Only use the structured output (WeatherOutput) after tool results are retrieved."
        ),
        model=model, 
        tools=[get_weather], ## <--- this tool won't be called
        output_type=WeatherOutput ## <--- however if we remove this line, the above tool will be called
    )
    result = await Runner.run(agent, prompt)

    return result.final_output

async def main():
    prompt = 'What is the weather in London?'
    weather = await weather_friend(prompt)
    print(weather)

if __name__ == '__main__':
    asyncio.run(main())

Expected behavior

The expected behavior is that, the agent should autonomously call the tool (here get_weather tool) and then use the output of this tool to finally give a structured output.

[ihower]

I helped test this on my side:

gpt-4.1, gpt-4.1-mini, gpt-5, gpt-5-mini, claude-3-5-sonnet-20240620, and gemini-2.5-pro all work fine (via LitellmModel), tool calls are triggered with output_type specified.

But with openrouter/moonshotai/kimi-k2 (I tested via OpenRouter) I can reproduce exactly what you’re seeing: the tool isn’t called once structured outputs are enabled.

This looks like a model-specific limitation or LiteLLM issue, not this SDK bug.

[SaudKadiri]

Thanks for testing @ihower on various model, I don't have access to those paid APIs.

To update you, I tried using lite-llm based in google-adk with similar code, turns out it's able to handle the scenario pretty well.

import datetime
from zoneinfo import ZoneInfo
from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm

from pydantic import BaseModel, Field

import litellm

litellm.use_litellm_proxy = True

class WeatherOutput(BaseModel):
    is_good_weather: bool = Field(..., description='Is the weather good for travel or outdoor activitied?')
    details: str = Field(..., description='Give the detailed weather report.')

def get_weather(city: str) -> str:
    """Retrieves the current weather report for a specified city.

    Args:
        city (str): The name of the city for which to retrieve the weather report.

    Returns:
        str: Weather status
    """
    return f'Current weather in {city} is jublious like a rainbow.'

model = LiteLlm(model="moonshotai/kimi-k2-instruct")
root_agent = Agent(
    name="Weather_Agent",
    # model="gemini-2.0-flash",
    model=model,
    description=(
        "Agent to answer questions about weather in a city."
    ),
    instruction=(
        "You are a helpful weather assistant. "
        "Always call the available tools to gather weather data. "
        "Do not fabricate answers. "
        "Only use the structured output (WeatherOutput) after tool results are retrieved."
    ),
    tools=[get_weather],
    output_schema=WeatherOutput
)

Output:

Maybe this issue is with agents.extensions.models.litellm_model.LitellmModel

[ihower]

Google ADK works here only because they implemented a special hack, not because the model itself supports this behavior.
See: google/adk-python@af63567

In ADK, when output_schema and tools are both present, they temporarily remove the output_schema so function calling can still work. Then they inject a prompt like:

IMPORTANT: You have access to other tools, but you must provide 
your final response using the set_model_response tool with the 
required structured format. After using any other tools needed 
to complete the task, always call set_model_response with your 
final answer in the specified schema format.

The purpose is to force the model to call a ADK built-in tool (set_model_response) to simulate structured outputs.

I personally don’t like this kind of hack: adding function calling and injecting prompts under the hood feels too opaque, it hard-codes the function and prompt.

[ihower]

You can use the OpenAI Agents SDK's built-in features to achieve the same effect as Google ADK’s hack.

Don’t use output_type, and instead provide an extra tool like generate_final_answer. In your prompt, instruct the model to call this tool for its final answer.

Also, the OpenAI Agents SDK has a key feature: tool_use_behavior with StopAtTools, you can terminate once the model calls your specified function.

Here’s a example code, it basically does the same thing as Google ADK’s method, without relying on opaque hacks:

from agents import Agent, function_tool, Runner
from agents.extensions.models.litellm_model import LitellmModel

from pydantic import BaseModel, Field
import os
import asyncio
from dotenv import load_dotenv
load_dotenv()

from agents.agent import StopAtTools

@function_tool
def get_weather(city: str) -> str:
    """
    Use this tool to get the weather for a city
    """
    print(f"------ Getting weather for {city}...")

    return f'Current weather in {city} is jublious like a rainbow.'

@function_tool
def generate_final_answer(is_good_weather:bool, details: str):
    """
    Use this for final answer
    Args:
        is_good_weather: Is the weather good for travel or outdoor activitied?
        details: Give the detailed weather report.

    """
    return { "is_good_weather": is_good_weather, "details": details }

def weather_friend(prompt: str):
    model = LitellmModel(model="openrouter/moonshotai/kimi-k2")
    agent = Agent(
        name="Weather Agent",
        instructions=(
            "You are a helpful weather assistant. "
            "Always call the get_weather tool to gather weather data. "
            "Do not fabricate answers. "
            "IMPORTANT: You always call generate_final_answer as your final output" 
        ),
        model=model,
        tools=[get_weather, generate_final_answer], 
        tool_use_behavior=StopAtTools(stop_at_tool_names=["generate_final_answer"]),
    )
    result = Runner.run_sync(agent, prompt)

    return result.final_output

def main():
    prompt = 'What is the weather in London?'
    weather =  weather_friend(prompt)
    print(weather)
    print("--------")

if __name__ == '__main__':
    main()

[SaudKadiri]

Thanks a ton, @ihower, for the ADK internal info as well as the workaround. Although it’s counterintuitive, this is a good workaround and could work for me for the time being.

[seratch]

Thank you so much @ihower for helping here!

We've been observing some behavioral differences with the model. We hope the model side could be changed and/or LiteLLM adapter fills the gap in the future.

[ilganeli]

I encountered the same thing, reproduced on Kimi and on Sonnet (Using OpenRouter)

[github-actions]

This issue is stale because it has been open for 7 days with no activity.