"""
Minimal reproducible example showing that callbacks don't propagate 
through DeepAgent/agent model nodes in langchain.agents.factory.

This affects Langfuse tracing, OpenTelemetry instrumentation, and any 
other callback-based observability when using sub-agents or middleware.
"""
import asyncio
from typing import Any, Optional
from langchain.agents import create_react_agent
from langchain_core.callbacks import BaseCallbackHandler
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import AIMessage


class TestCallbackHandler(BaseCallbackHandler):
    """Test handler that logs all LLM starts to verify callback propagation."""
    
    def __init__(self):
        self.llm_starts: list[dict] = []
    
    def on_llm_start(self, serialized: dict[str, Any], prompts: list[str], **kwargs) -> None:
        self.llm_starts.append({"serialized": serialized, "prompts": prompts})
        print(f"[CALLBACK] on_llm_start: {serialized.get('name', 'unknown')}")


async def main():
    # Create a simple mock model for testing
    class MockModel:
        async def ainvoke(self, messages, config=None, **kwargs):
            # Check if config was passed (this is what fails in factory.py)
            print(f"[MODEL] ainvoke called with config={config}")
            if config and config.get("callbacks"):
                print(f"[MODEL] config has {len(config['callbacks'])} callbacks")
            else:
                print("[MODEL] NO callbacks in config - THIS IS THE BUG")
            return AIMessage(content="test response")
        
        def bind_tools(self, tools, **kwargs):
            return self
    
    model = MockModel()
    
    # Create a simple ReAct agent
    tools = []
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful assistant."),
        ("placeholder", "{messages}"),
    ])
    
    agent = create_react_agent(model, tools, prompt=prompt)
    
    # Create callback handler
    handler = TestCallbackHandler()
    config = {"callbacks": [handler]}
    
    # Invoke the agent with callbacks
    print("=" * 60)
    print("Invoking agent with callback handler...")
    print("=" * 60)
    
    result = await agent.ainvoke(
        {"messages": [("human", "Hello")]},
        config=config
    )
    
    print("=" * 60)
    print(f"Callback handler recorded {len(handler.llm_starts)} LLM starts")
    print("=" * 60)
    
    if len(handler.llm_starts) == 0:
        print("\n❌ BUG CONFIRMED: Callbacks did NOT propagate to model_.ainvoke")
        print("The model node in factory.py doesn't pass config to model_.ainvoke()")
    else:
        print("\n✅ Callbacks propagated successfully")


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

---

No error is thrown - this is a silent failure where callbacks simply don't propagate.

When tracing with Langfuse, you'll see:

Root trace created
Agent/Chain observations visible
Missing: LLM/GENERATION observations from model node (silent failure)
Callback handlers in config are ignored during model_.ainvoke()

---

async def _execute_model_async(messages, model_, **kwargs):  # Missing config param
    response = await model_.ainvoke(messages, **kwargs)  # Missing config=config

async def amodel_node(state, **kwargs):  # Missing config param
    return await _execute_model_async(messages, model_, **kwargs)