PROGRESSIVE_SSE_STREAMING is not honored by the LiteLlm adapter — function-call argument deltas are buffered until finish_reason #5342

# google/adk/models/lite_llm.py:2321                                                                                            
async for part in await self.llm_client.acompletion(**completion_args):                                                           
    for chunk, finish_reason in _model_response_to_chunk(part):
        if isinstance(chunk, FunctionChunk):                                                                                      
            index = chunk.index or fallback_index                         
            if index not in function_calls:                                                                                     
                function_calls[index] = {"name": "", "args": "", "id": None}                                                      
            if chunk.name:                                                                                                        
                function_calls[index]["name"] += chunk.name                                                                       
            if chunk.args:                                                                                                        
                function_calls[index]["args"] += chunk.args   # ← buffer only                                                     
            ...                                                                                                                 
            # NO yield here — the partial function call is invisible to callers                                                   
        elif isinstance(chunk, TextChunk):                                                                                        
            text += chunk.text                                                                                                    
            yield _message_to_generate_content_response(  # ← text DOES yield                                                     
                ChatCompletionAssistantMessage(role="assistant", content=chunk.text),                                             
                is_partial=True,                                                                                                
                model_version=part.model,                                                                                         
            )                                                                                                                     
        ...                                                                                                                       
                                                                                                                                  
    if function_calls and (                                                                                                       
        finish_reason == "tool_calls"                                                                                             
        or finish_reason == "length"                                                                                              
        or (finish_reason == "stop" and chunk is None)                    
    ):                                                                                                                            
        aggregated_llm_response_with_tool_call = _finalize_tool_call_response(...)                                                
        # ← only here, after finish_reason, does the function call become an event

from google.adk.features import FeatureName, is_feature_enabled                                                                 
# ...                                                                                                                             
                                        
elif isinstance(chunk, FunctionChunk):                                                                                            
    index = chunk.index or fallback_index                                 
    if index not in function_calls:                                                                                             
        function_calls[index] = {"name": "", "args": "", "id": None}                                                              
    if chunk.name:                                                                                                              
        function_calls[index]["name"] += chunk.name                                                                               
    if chunk.args:                                                        
        function_calls[index]["args"] += chunk.args                                                                               
    function_calls[index]["id"] = (                                       
        chunk.id or function_calls[index]["id"] or str(index)                                                                   
    )                                                                                                                             
                                            
    if is_feature_enabled(FeatureName.PROGRESSIVE_SSE_STREAMING):                                                                 
        # Mirror the TextChunk path: emit a partial LlmResponse so callers                                                      
        # can show progress while the model streams tool-call arguments.                                                          
        # Args may be partial JSON; consumers should only act on the                                                            
        # non-partial aggregated event downstream, the same as Gemini.                                                            
        yield _partial_function_call_response(                            
            function_calls[index],                                                                                                
            model_version=part.model,                                                                                             
        )                                                                                                                         

def _partial_function_call_response(
    fc_state: dict, *, model_version: str | None                                                                                
) -> LlmResponse:                                                                                                                 
    return LlmResponse(                 
        content=types.Content(                                                                                                    
            role="model",                                                 
            parts=[                                                                                                             
                types.Part(                                                                                                       
                    function_call=types.FunctionCall(                                                                           
                        id=fc_state["id"],                                                                                        
                        name=fc_state["name"] or None,                    
                        # args may not yet be valid JSON — pass through as-is.                                                    
                        # Consumers that need parsed args should wait for the
                        # final non-partial event.                                                                              
                        args=fc_state["args"] or None,                                                                            
                    )           
                )                                                                                                                 
            ],                                                                                                                    
        ),                                                                                                                        
        partial=True,                                                                                                             
        model_version=model_version,                                                                                              
    )                                                                                                                             

import asyncio                                                                                                                    
import time                                                                                                                       
                                                                          
from google.adk.agents import LlmAgent                                                                                            
from google.adk.apps.app import App, ResumabilityConfig                   
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner                                                                                           
from google.adk.sessions import InMemorySessionService                                                                            
from google.adk.tools import LongRunningFunctionTool
from google.genai import types                                                                                                    
                                                                                                                                  
                                                                                                                                
async def ask_user_question(question_flow: dict) -> dict | None:                                                                  
    """Long-running pause sentinel: returning None tells ADK this is still pending."""                                          
    return None                                                                                                                   
                                                                          
                                                                                                                                  
agent = LlmAgent(                                                                                                               
    name="demo",                                                                                                                  
    model=LiteLlm(model="openai/gpt-4o-mini"),  # or any non-Gemini model                                                         
    instruction=(                                                                                                                 
        "When the user says 'go', call ask_user_question with a question_flow "                                                   
        "object containing 7 questions covering subject, grade level, language, "
        "duration, chapter count, difficulty, and goals. Use a rich nested schema."                                             
    ),                                                                                                                            
    tools=[LongRunningFunctionTool(ask_user_question)],                                                                           
)                                                                                                                                 
                                                                                                                                  
app = App(                                                                                                                        
    name="demo",                                                                                                                  
    root_agent=agent,                                                                                                             
    resumability_config=ResumabilityConfig(is_resumable=True),                                                                    
)                                                                                                                                 
                                            
                                                                                                                                  
async def main():                                                         
    session_service = InMemorySessionService()
    await session_service.create_session(app_name="demo", user_id="u", session_id="s")                                          
    runner = Runner(app=app, session_service=session_service)                                                                     
                                        
    last = time.time()                                                                                                            
    async for event in runner.run_async(                                  
        user_id="u",                                                                                                            
        session_id="s",                                                                                                           
        new_message=types.Content(role="user", parts=[types.Part(text="go")]),
    ):                                                                                                                            
        now = time.time()                                                                                                         
        text = ""               
        if event.content and event.content.parts and event.content.parts[0].text:                                                 
            text = (event.content.parts[0].text or "")[:30]                                                                     
        print(                                                                                                                    
            f"+{now - last:6.2f}s  partial={event.partial!s:5}  "
            f"fcs={bool(event.get_function_calls())!s:5}  text={text!r}"                                                          
        )                                                                                                                       
        last = now                                                                                                                
                                                                                                                                  
                                                                                                                                  
asyncio.run(main())