"""
Minimal reproducible example showing trace=False prevents callback setup.

When trace=False is set on a RunnableCallable, the on_llm_start callback
is never triggered, breaking Langfuse, OpenTelemetry, and other observability.
"""
import asyncio
from typing import Any, Optional
from langchain.agents import create_react_agent
from langchain_core.callbacks import BaseCallbackHandler
from langchain_core.callbacks.manager import AsyncCallbackManager
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import AIMessage
from langchain_core.runnables import RunnableCallable


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


async def demonstrate_trace_false_bug():
    """
    Demonstrates that trace=False prevents callback setup in RunnableCallable.
    
    This is exactly what happens in langchain/agents/factory.py line 1327:
    
    node = RunnableCallable(
        func=amodel_node,
        name="model_node", 
        trace=False,  # <-- THIS IS THE BUG
    )
    """
    
    async def dummy_model_func(input_data: dict, config: Optional[Any] = None) -> AIMessage:
        """Simulates what model_.ainvoke does internally."""
        print(f"[MODEL] Executing with config={config}")
        return AIMessage(content="test")
    
    handler = TestCallbackHandler()
    
    # Test 1: trace=False (current buggy behavior in factory.py)
    print("=" * 60)
    print("Test 1: trace=False (CURRENT BUG in factory.py line 1327)")
    print("=" * 60)
    
    buggy_node = RunnableCallable(
        func=dummy_model_func,
        name="model_node_trace_false",
        trace=False,  # This is what's in factory.py currently
    )
    
    result1 = await buggy_node.ainvoke(
        {"messages": [("human", "Hello")]},
        config={"callbacks": [handler]}
    )
    
    print(f"Events captured with trace=False: {handler.events}")
    if "on_llm_start" not in handler.events:
        print("❌ BUG: on_llm_start was NOT called - callbacks not set up!")
    
    handler.events.clear()
    
    # Test 2: trace=True (or omitted, defaults to True) - fixed behavior
    print("\n" + "=" * 60)
    print("Test 2: trace=True (or omitted - defaults to True, THE FIX)")
    print("=" * 60)
    
    fixed_node = RunnableCallable(
        func=dummy_model_func,
        name="model_node_trace_true",
        trace=True,  # This is the fix
    )
    
    result2 = await fixed_node.ainvoke(
        {"messages": [("human", "Hello")]},
        config={"callbacks": [handler]}
    )
    
    print(f"Events captured with trace=True: {handler.events}")
    if "on_llm_start" in handler.events:
        print("✅ FIXED: on_llm_start was called - callbacks work!")
    
    print("\n" + "=" * 60)
    print("CONCLUSION: trace=False prevents callback setup in RunnableCallable")
    print("=" * 60)


async def main():
    await demonstrate_trace_false_bug()
    
    # Show the actual impact with create_react_agent
    print("\n" + "=" * 60)
    print("Actual impact with create_react_agent:")
    print("=" * 60)
    
    from langchain.agents import create_react_agent
    
    class MockModel:
        async def ainvoke(self, messages, config=None, **kwargs):
            return AIMessage(content="test")
        def bind_tools(self, tools, **kwargs):
            return self
    
    model = MockModel()
    tools = []
    prompt = ChatPromptTemplate.from_messages([
        ("system", "You are a helpful assistant."),
        ("placeholder", "{messages}"),
    ])
    
    agent = create_react_agent(model, tools, prompt=prompt)
    
    handler = TestCallbackHandler()
    result = await agent.ainvoke(
        {"messages": [("human", "Hello")]},
        config={"callbacks": [handler]}
    )
    
    print(f"\nWith create_react_agent, events: {handler.events}")
    if "on_llm_start" not in handler.events:
        print("❌ CONFIRMED: Callbacks don't reach LLM calls in agent model node")
        print("   This is because trace=False bypasses callback setup in RunnableCallable")


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

---

No error is thrown - this is a silent failure where callbacks are never set up.

The code path that's skipped (from `langchain_core/runnables/_runnable.py:410-429`):

# When trace=True (or omitted), this code runs:
if self.trace:
    await run_manager.on_llm_start(...)  # Callbacks set up here
    
# When trace=False, this is SKIPPED entirely:
else:
    # No callback setup happens!
    response = await self.afunc(*args, **kwargs)

---

node = RunnableCallable(
    func=amodel_node,
    name="model_node",
    trace=False,  # <-- This is the bug
)

---

async def ainvoke(self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any) -> Output:
    if self.trace:
        # Callback setup happens here (this is skipped when trace=False)
        callback_manager = AsyncCallbackManager.configure(...)
        run_manager = await callback_manager.on_llm_start(...)
    else:
        # trace=False path - NO callback setup!
        response = await self.afunc(input, config=config, **kwargs)

---

System Information
------------------
> OS:  Linux/Mac/Windows
> Python:  3.12+

Package Information
-------------------
> langchain: 0.3.x
> langchain-core: 0.3.x
> langgraph: 0.2.x

Other Dependencies:
> langfuse: 2.x/3.x (for tracing reproduction)