jaf-py 2.2.3__py3-none-any.whl → 2.3.0__py3-none-any.whl

jaf/core/engine.py

@@ -91,7 +91,13 @@ async def run(
         set_current_run_config(config)
         
         if config.on_event:
-            config.on_event(RunStartEvent(data=to_event_data(RunStartEventData(run_id=initial_state.run_id, trace_id=initial_state.trace_id))))
+            config.on_event(RunStartEvent(data=to_event_data(RunStartEventData(
+                run_id=initial_state.run_id,
+                trace_id=initial_state.trace_id,
+                session_id=config.conversation_id,
+                context=initial_state.context,
+                messages=initial_state.messages
+            ))))
 
         state_with_memory = await _load_conversation_history(initial_state, config)
         result = await _run_internal(state_with_memory, config)
@@ -289,7 +295,9 @@ async def _run_internal(
             agent_name=current_agent.name,
             model=model,
             trace_id=state.trace_id,
-            run_id=state.run_id
+            run_id=state.run_id,
+            context=state.context,
+            messages=state.messages
         ))))
 
     # Get completion from model provider

jaf/core/tracing.py

@@ -358,15 +358,99 @@ class LangfuseTraceCollector:
             if event.type == "run_start":
                 # Start a new trace for the entire run
                 print(f"[LANGFUSE] Starting trace for run: {trace_id}")
+                
+                # Extract user query from the run_start data
+                user_query = None
+                user_id = None
+                
+                # Debug: Print the event data structure to understand what we're working with
+                print(f"[LANGFUSE DEBUG] Event data keys: {list(event.data.keys()) if event.data else 'No data'}")
+                if event.data.get("context"):
+                    context = event.data["context"]
+                    print(f"[LANGFUSE DEBUG] Context type: {type(context)}")
+                    print(f"[LANGFUSE DEBUG] Context attributes: {dir(context) if hasattr(context, '__dict__') else 'Not an object'}")
+                    if hasattr(context, '__dict__'):
+                        print(f"[LANGFUSE DEBUG] Context dict: {context.__dict__}")
+                
+                # Try to extract from context first
+                context = event.data.get("context")
+                if context:
+                    # Try direct attribute access
+                    if hasattr(context, 'query'):
+                        user_query = context.query
+                        print(f"[LANGFUSE DEBUG] Found user_query from context.query: {user_query}")
+                    
+                    # Try to extract from combined_history
+                    if hasattr(context, 'combined_history') and context.combined_history:
+                        history = context.combined_history
+                        print(f"[LANGFUSE DEBUG] Found combined_history with {len(history)} messages")
+                        for i, msg in enumerate(reversed(history)):
+                            print(f"[LANGFUSE DEBUG] History message {i}: {msg}")
+                            if isinstance(msg, dict) and msg.get("role") == "user":
+                                user_query = msg.get("content", "")
+                                print(f"[LANGFUSE DEBUG] Found user_query from history: {user_query}")
+                                break
+                    
+                    # Try to extract user_id from token_response
+                    if hasattr(context, 'token_response'):
+                        token_response = context.token_response
+                        print(f"[LANGFUSE DEBUG] Found token_response: {type(token_response)}")
+                        if isinstance(token_response, dict):
+                            user_id = token_response.get("email") or token_response.get("username")
+                            print(f"[LANGFUSE DEBUG] Extracted user_id: {user_id}")
+                        elif hasattr(token_response, 'email'):
+                            user_id = token_response.email
+                            print(f"[LANGFUSE DEBUG] Extracted user_id from attr: {user_id}")
+                
+                # Fallback: try to extract from messages if context didn't work
+                if not user_query and event.data.get("messages"):
+                    print(f"[LANGFUSE DEBUG] Trying fallback from messages")
+                    messages = event.data["messages"]
+                    print(f"[LANGFUSE DEBUG] Found {len(messages)} messages")
+                    # Find the last user message which should be the current query
+                    for i, msg in enumerate(reversed(messages)):
+                        print(f"[LANGFUSE DEBUG] Message {i}: {msg}")
+                        if isinstance(msg, dict) and msg.get("role") == "user":
+                            user_query = msg.get("content", "")
+                            print(f"[LANGFUSE DEBUG] Found user_query from messages: {user_query}")
+                            break
+                        elif hasattr(msg, 'role') and msg.role == 'user':
+                            user_query = msg.content
+                            print(f"[LANGFUSE DEBUG] Found user_query from message attr: {user_query}")
+                            break
+                
+                print(f"[LANGFUSE DEBUG] Final extracted - user_query: {user_query}, user_id: {user_id}")
+                
+                # Create comprehensive input data for the trace
+                trace_input = {
+                    "user_query": user_query,
+                    "run_id": str(trace_id),
+                    "agent_name": event.data.get("agent_name", "analytics_agent_jaf"),
+                    "session_info": {
+                        "session_id": event.data.get("session_id"),
+                        "user_id": user_id or event.data.get("user_id")
+                    }
+                }
+                
                 trace = self.langfuse.trace(
                     name=f"jaf-run-{trace_id}",
-                    user_id=event.data.get("user_id"),
+                    user_id=user_id or event.data.get("user_id"),
                     session_id=event.data.get("session_id"),
-                    input=event.data,
-                    metadata={"framework": "jaf", "event_type": "run_start", "trace_id": str(trace_id)}
+                    input=trace_input,
+                    metadata={
+                        "framework": "jaf", 
+                        "event_type": "run_start", 
+                        "trace_id": str(trace_id),
+                        "user_query": user_query,
+                        "user_id": user_id or event.data.get("user_id"),
+                        "agent_name": event.data.get("agent_name", "analytics_agent_jaf")
+                    }
                 )
                 self.trace_spans[trace_id] = trace
-                print(f"[LANGFUSE] Created trace: {trace}")
+                # Store user_id and user_query for later use in generations
+                trace._user_id = user_id or event.data.get("user_id")
+                trace._user_query = user_query
+                print(f"[LANGFUSE] Created trace with user query: {user_query[:100] if user_query else 'None'}...")
                 
             elif event.type == "run_end":
                 if trace_id in self.trace_spans:
@@ -386,10 +470,21 @@ class LangfuseTraceCollector:
                 # Start a generation for LLM calls
                 model = event.data.get("model", "unknown")
                 print(f"[LANGFUSE] Starting generation for LLM call with model: {model}")
-                generation = self.trace_spans[trace_id].generation(
+                
+                # Get stored user information from the trace
+                trace = self.trace_spans[trace_id]
+                user_id = getattr(trace, '_user_id', None)
+                user_query = getattr(trace, '_user_query', None)
+                
+                generation = trace.generation(
                     name=f"llm-call-{model}",
                     input=event.data.get("messages"),
-                    metadata={"agent_name": event.data.get("agent_name"), "model": model}
+                    metadata={
+                        "agent_name": event.data.get("agent_name"), 
+                        "model": model,
+                        "user_id": user_id,
+                        "user_query": user_query
+                    }
                 )
                 span_id = self._get_span_id(event)
                 self.active_spans[span_id] = generation
@@ -405,47 +500,111 @@ class LangfuseTraceCollector:
                     
                     # Extract usage from the event data
                     usage = event.data.get("usage", {})
-
-                    # Convert to Langfuse v2 format
+                    
+                    # Extract model information from choice data or event data
+                    model = choice.get("model", "unknown")
+                    if model == "unknown":
+                        # Try to get model from the choice response structure
+                        if isinstance(choice, dict):
+                            model = choice.get("model") or choice.get("id", "unknown")
+                    
+                    # Convert to Langfuse v2 format - let Langfuse handle cost calculation automatically
                     langfuse_usage = None
                     if usage:
+                        prompt_tokens = usage.get("prompt_tokens", 0)
+                        completion_tokens = usage.get("completion_tokens", 0)
+                        total_tokens = usage.get("total_tokens", 0)
+                        
                         langfuse_usage = {
-                            "input": usage.get("prompt_tokens", 0),
-                            "output": usage.get("completion_tokens", 0),
-                            "total": usage.get("total_tokens", 0),
+                            "input": prompt_tokens,
+                            "output": completion_tokens,
+                            "total": total_tokens,
                             "unit": "TOKENS"
                         }
-
-                    generation.end(output=choice, usage=langfuse_usage)
+                        
+                        print(f"[LANGFUSE] Usage data for automatic cost calculation: {langfuse_usage}")
+
+                    # Include model information in the generation end - Langfuse will calculate costs automatically
+                    generation.end(
+                        output=choice, 
+                        usage=langfuse_usage,
+                        model=model,  # Pass model directly for automatic cost calculation
+                        metadata={
+                            "model": model,
+                            "system_fingerprint": choice.get("system_fingerprint"),
+                            "created": choice.get("created"),
+                            "response_id": choice.get("id")
+                        }
+                    )
 
                     # Clean up the span reference
                     del self.active_spans[span_id]
-                    print(f"[LANGFUSE] Generation ended")
+                    print(f"[LANGFUSE] Generation ended with cost tracking")
                 else:
                     print(f"[LANGFUSE] No generation found for llm_call_end: {span_id}")
                     
             elif event.type == "tool_call_start":
-                # Start a span for tool calls
-                print(f"[LANGFUSE] Starting span for tool call: {event.data.get('tool_name')}")
+                # Start a span for tool calls with detailed input information
+                tool_name = event.data.get('tool_name', 'unknown')
+                tool_args = event.data.get("args", {})
+                
+                print(f"[LANGFUSE] Starting span for tool call: {tool_name}")
+                
+                # Create comprehensive input data for the tool call
+                tool_input = {
+                    "tool_name": tool_name,
+                    "arguments": tool_args,
+                    "call_id": event.data.get("call_id"),
+                    "timestamp": datetime.now().isoformat()
+                }
+                
                 span = self.trace_spans[trace_id].span(
-                    name=f"tool-{event.data.get('tool_name', 'unknown')}",
-                    input=event.data.get("args"),
-                    metadata={"tool_name": event.data.get("tool_name")}
+                    name=f"tool-{tool_name}",
+                    input=tool_input,
+                    metadata={
+                        "tool_name": tool_name,
+                        "call_id": event.data.get("call_id"),
+                        "framework": "jaf",
+                        "event_type": "tool_call"
+                    }
                 )
                 span_id = self._get_span_id(event)
                 self.active_spans[span_id] = span
-                print(f"[LANGFUSE] Created tool span: {span}")
+                print(f"[LANGFUSE] Created tool span for {tool_name} with args: {str(tool_args)[:100]}...")
                     
             elif event.type == "tool_call_end":
                 span_id = self._get_span_id(event)
                 if span_id in self.active_spans:
-                    print(f"[LANGFUSE] Ending span for tool call")
-                    # End the span
+                    tool_name = event.data.get('tool_name', 'unknown')
+                    tool_result = event.data.get("result")
+                    
+                    print(f"[LANGFUSE] Ending span for tool call: {tool_name}")
+                    
+                    # Create comprehensive output data for the tool call
+                    tool_output = {
+                        "tool_name": tool_name,
+                        "result": tool_result,
+                        "call_id": event.data.get("call_id"),
+                        "timestamp": datetime.now().isoformat(),
+                        "status": "completed"
+                    }
+                    
+                    # End the span with detailed output
                     span = self.active_spans[span_id]
-                    span.end(output=event.data.get("result"))
+                    span.end(
+                        output=tool_output,
+                        metadata={
+                            "tool_name": tool_name,
+                            "call_id": event.data.get("call_id"),
+                            "result_length": len(str(tool_result)) if tool_result else 0,
+                            "framework": "jaf",
+                            "event_type": "tool_call_end"
+                        }
+                    )
+                    
                     # Clean up the span reference
                     del self.active_spans[span_id]
-                    print(f"[LANGFUSE] Tool span ended")
+                    print(f"[LANGFUSE] Tool span ended for {tool_name} with result length: {len(str(tool_result)) if tool_result else 0}")
                 else:
                     print(f"[LANGFUSE] No tool span found for tool_call_end: {span_id}")
                     
@@ -502,19 +661,10 @@ class LangfuseTraceCollector:
             tool_name = event.data.get('tool_name') or event.data.get('toolName', 'unknown')
             return f"tool-{tool_name}-{trace_id}"
         elif event.type.startswith('llm_call'):
-            # For LLM calls, get the model name from the event data
-            model = event.data.get('model')
-            
-            # For llm_call_end events, the model might be in the choice object
-            if not model and event.type == 'llm_call_end':
-                choice = event.data.get('choice', {})
-                if isinstance(choice, dict):
-                    model = choice.get('model')
-            
-            # Handle case where model might be empty or None
-            if not model or model == '':
-                model = 'unknown'
-            return f"llm-{model}-{trace_id}"
+            # For LLM calls, use a simpler consistent ID that matches between start and end
+            # Get run_id for more consistent matching
+            run_id = event.data.get('run_id') or event.data.get('runId', trace_id)
+            return f"llm-{run_id}"
         else:
             return f"{event.type}-{trace_id}"
 

jaf/core/types.py

@@ -378,6 +378,9 @@ class RunStartEventData:
     """Data for run start events."""
     run_id: RunId
     trace_id: TraceId
+    session_id: Optional[str] = None
+    context: Optional[Any] = None
+    messages: Optional[List[Message]] = None
 
 @dataclass(frozen=True)
 class RunStartEvent:
@@ -391,6 +394,8 @@ class LLMCallStartEventData:
     model: str
     trace_id: TraceId
     run_id: RunId
+    context: Optional[Any] = None
+    messages: Optional[List[Message]] = None
 
 @dataclass(frozen=True)
 class LLMCallStartEvent:

jaf/providers/model.py

@@ -51,8 +51,11 @@ def make_litellm_provider(
                 if proxies:
                     # Create httpx client with proxy configuration
                     try:
-                        http_client = httpx.Client(proxies=proxies)
-                        client_kwargs["http_client"] = http_client
+                        # Use the https proxy if available, otherwise http proxy
+                        proxy_url = proxies.get('https://') or proxies.get('http://')
+                        if proxy_url:
+                            http_client = httpx.Client(proxy=proxy_url)
+                            client_kwargs["http_client"] = http_client
                     except Exception as e:
                         print(f"Warning: Could not configure proxy: {e}")
                         # Fall back to environment variables for proxy

{jaf_py-2.2.3.dist-info → jaf_py-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.2.3
+Version: 2.3.0
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -73,7 +73,7 @@ Dynamic: license-file
 
 <!-- ![JAF Banner](docs/cover.png) -->
 
-[![Version](https://img.shields.io/badge/version-2.0.0-blue.svg)](https://github.com/xynehq/jaf-py)
+[![Version](https://img.shields.io/badge/version-2.2.3-blue.svg)](https://github.com/xynehq/jaf-py)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
 [![Docs](https://img.shields.io/badge/Docs-Live-brightgreen)](https://xynehq.github.io/jaf-py/)
 
@@ -114,15 +114,23 @@ A purely functional agent framework with immutable state and composable tools, p
 
 ### 📊 **Observability & Monitoring**
 - ✅ **Real-time Tracing**: Event-driven observability
+- ✅ **OpenTelemetry Integration**: Distributed tracing with OTLP
+- ✅ **Langfuse Tracing**: LLM observability and analytics
 - ✅ **Structured Logging**: JSON-formatted logs
 - ✅ **Error Handling**: Comprehensive error types and recovery
 - ✅ **Performance Metrics**: Built-in timing and counters
 
+### 🤖 **Agent-as-Tool Architecture**
+- ✅ **Hierarchical Orchestration**: Use agents as tools in other agents
+- ✅ **Conditional Tool Enabling**: Enable/disable agent tools based on context
+- ✅ **Session Management**: Configurable session inheritance for sub-agents
+- ✅ **Flexible Output Extraction**: Custom extractors for agent tool outputs
+
 ### 🔧 **Developer Experience**
 - ✅ **CLI Tools**: Project initialization and management
 - ✅ **Hot Reload**: Development server with auto-reload
 - ✅ **Type Hints**: Full mypy compatibility
-- ✅ **Rich Examples**: RAG, multi-agent, and server demos
+- ✅ **Rich Examples**: RAG, multi-agent, agent-as-tool, and server demos
 - ✅ **Visual Architecture**: Graphviz-powered agent and tool diagrams
 
 ## 🎯 Core Philosophy
@@ -148,6 +156,7 @@ pip install "jaf-py[all] @ git+https://github.com/xynehq/jaf-py.git"
 pip install "jaf-py[server] @ git+https://github.com/xynehq/jaf-py.git"        # FastAPI server support
 pip install "jaf-py[memory] @ git+https://github.com/xynehq/jaf-py.git"        # Redis/PostgreSQL memory providers
 pip install "jaf-py[visualization] @ git+https://github.com/xynehq/jaf-py.git" # Graphviz visualization tools
+pip install "jaf-py[tracing] @ git+https://github.com/xynehq/jaf-py.git"       # OpenTelemetry and Langfuse tracing
 pip install "jaf-py[dev] @ git+https://github.com/xynehq/jaf-py.git"           # Development tools
 ```
 
@@ -212,6 +221,7 @@ For offline access, documentation is also available in the [`docs/`](docs/) dire
 - **[🔧 Tools Guide](docs/tools.md)** - Creating and using tools
 - **[💾 Memory System](docs/memory-system.md)** - Persistence and memory providers
 - **[🤖 Model Providers](docs/model-providers.md)** - LiteLLM integration
+- **[📊 Monitoring](docs/monitoring.md)** - Observability, metrics, and alerting
 - **[🌐 Server API](docs/server-api.md)** - FastAPI endpoints reference
 - **[📦 Deployment](docs/deployment.md)** - Production deployment guide
 - **[🎮 Examples](docs/examples.md)** - Detailed example walkthroughs
@@ -439,6 +449,58 @@ config = RunConfig(
 )
 ```
 
+## 🤖 Agent-as-Tool Functionality
+
+JAF 2.2+ introduces powerful agent-as-tool capabilities, allowing you to use agents as tools within other agents for hierarchical orchestration:
+
+```python
+from jaf.core.agent_tool import create_agent_tool
+from jaf.core.types import create_json_output_extractor
+
+# Create specialized agents
+spanish_agent = Agent(
+    name="spanish_translator",
+    instructions=lambda state: "Translate text to Spanish",
+    output_codec=TranslationOutput
+)
+
+french_agent = Agent(
+    name="french_translator", 
+    instructions=lambda state: "Translate text to French",
+    output_codec=TranslationOutput
+)
+
+# Convert agents to tools with conditional enabling
+spanish_tool = spanish_agent.as_tool(
+    tool_name="translate_to_spanish",
+    tool_description="Translate text to Spanish",
+    max_turns=3,
+    custom_output_extractor=create_json_output_extractor(),
+    is_enabled=True  # Always enabled
+)
+
+french_tool = french_agent.as_tool(
+    tool_name="translate_to_french", 
+    tool_description="Translate text to French",
+    max_turns=3,
+    custom_output_extractor=create_json_output_extractor(),
+    is_enabled=lambda context, agent: context.language_preference == "french_spanish"
+)
+
+# Create orchestrator agent using agent tools
+orchestrator = Agent(
+    name="translation_orchestrator",
+    instructions=lambda state: "Use translation tools to respond in multiple languages",
+    tools=[spanish_tool, french_tool]
+)
+```
+
+### Key Features:
+- **Conditional Enabling**: Enable/disable agent tools based on runtime context
+- **Session Management**: Configure whether sub-agents inherit parent session state
+- **Custom Output Extraction**: Define how to extract and format agent tool outputs
+- **Error Handling**: Robust error handling for failed agent tool executions
+
 ## 🔗 Agent Handoffs
 
 ```python
@@ -488,6 +550,48 @@ config = RunConfig(
 )
 ```
 
+### OpenTelemetry Integration
+
+JAF 2.2+ includes built-in OpenTelemetry support for distributed tracing:
+
+```python
+import os
+from jaf.core.tracing import create_composite_trace_collector, ConsoleTraceCollector
+
+# Configure OpenTelemetry endpoint
+os.environ["TRACE_COLLECTOR_URL"] = "http://localhost:4318/v1/traces"
+
+# Tracing will be automatically configured when creating a composite collector
+trace_collector = create_composite_trace_collector(ConsoleTraceCollector())
+
+config = RunConfig(
+    # ... other config
+    on_event=trace_collector.collect,
+)
+```
+
+### Langfuse Integration
+
+For LLM-specific observability and analytics:
+
+```python
+import os
+from jaf.core.tracing import create_composite_trace_collector, ConsoleTraceCollector
+
+# Configure Langfuse credentials
+os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-lf-your-public-key"
+os.environ["LANGFUSE_SECRET_KEY"] = "sk-lf-your-secret-key" 
+os.environ["LANGFUSE_HOST"] = "https://cloud.langfuse.com"  # or your self-hosted instance
+
+# Langfuse tracing will be automatically configured
+trace_collector = create_composite_trace_collector(ConsoleTraceCollector())
+
+config = RunConfig(
+    # ... other config
+    on_event=trace_collector.collect,
+)
+```
+
 ### Error Handling
 
 ```python
@@ -663,7 +767,41 @@ python server_example.py
 - `POST /chat` - Chat with any agent
 - `GET /docs` - Interactive API documentation
 
-### 2. MCP Integration Demo
+### 2. Agent-as-Tool Demo
+
+```bash
+cd examples
+python agent_as_tool_example.py
+
+# Or start as server
+python agent_as_tool_example.py --server
+```
+
+**Features demonstrated:**
+- ✅ Hierarchical agent orchestration
+- ✅ Conditional tool enabling based on context
+- ✅ Custom output extraction from agent tools
+- ✅ Session management for sub-agents
+- ✅ Translation agents working together
+
+### 3. Tracing Integration Demos
+
+```bash
+# OpenTelemetry tracing example
+cd examples
+python otel_tracing_demo.py
+
+# Langfuse tracing example  
+python langfuse_tracing_demo.py
+```
+
+**Features demonstrated:**
+- ✅ OpenTelemetry distributed tracing setup
+- ✅ Langfuse LLM observability integration
+- ✅ Composite trace collectors
+- ✅ Real-time monitoring and analytics
+
+### 4. MCP Integration Demo
 
 ```bash
 cd examples/mcp_demo  
@@ -721,4 +859,4 @@ MIT
 
 ---
 
-**JAF (Juspay Agentic Framework) v2.0** - Building the future of functional AI agent systems 🚀
+**JAF (Juspay Agentic Framework) v2.2** - Building the future of functional AI agent systems 🚀

{jaf_py-2.2.3.dist-info → jaf_py-2.3.0.dist-info}/RECORD

@@ -42,7 +42,7 @@ jaf/core/__init__.py,sha256=rBvP_7TGbJICDJnA7a3qyX8yQErCDWaGAn5WzpyH4gU,1339
 jaf/core/agent_tool.py,sha256=8TcBuSxGmDTW5F_GhBU_m5S43nYqkjO4qTrNERraAig,11656
 jaf/core/analytics.py,sha256=NrUfOLLTDIhOzdfc65ZqS9AJ4ZAP9BtNtga69q0YdYw,23265
 jaf/core/composition.py,sha256=IVxRO1Q9nK7JRH32qQ4p8WMIUu66BhqPNrlTNMGFVwE,26317
-jaf/core/engine.py,sha256=wakHo9DcNSVH7N5FC_6vi4Nc0yO15YJpNvNTLyyGM_E,26857
+jaf/core/engine.py,sha256=v6yXp-zJF9Cj_9qlaW1rmCz7_N3YuDU02xxlzl-howM,27122
 jaf/core/errors.py,sha256=5fwTNhkojKRQ4wZj3lZlgDnAsrYyjYOwXJkIr5EGNUc,5539
 jaf/core/performance.py,sha256=jedQmTEkrKMD6_Aw1h8PdG-5TsdYSFFT7Or6k5dmN2g,9974
 jaf/core/proxy.py,sha256=_WM3cpRlSQLYpgSBrnY30UPMe2iZtlqDQ65kppE-WY0,4609
@@ -50,8 +50,8 @@ jaf/core/proxy_helpers.py,sha256=i7a5fAX9rLmO4FMBX51-yRkTFwfWedzQNgnLmeLUd_A,437
 jaf/core/streaming.py,sha256=c5o9iqpjoYV2LrUpG6qLWCYrWcP-DCcZsvMbyqKunp8,16089
 jaf/core/tool_results.py,sha256=-bTOqOX02lMyslp5Z4Dmuhx0cLd5o7kgR88qK2HO_sw,11323
 jaf/core/tools.py,sha256=SbJRRr4y_xxNYNTulZg6OiyNaHBlo_qXWYY510jxQEs,16489
-jaf/core/tracing.py,sha256=r96LCi4dV7BSoqVuFMXI7j72G9jOwpbEjnhYqubuQzc,23455
-jaf/core/types.py,sha256=RWHkWm18bAFx7SMSuCGi1cQnCmQR9yxkyz-FppDpglM,16868
+jaf/core/tracing.py,sha256=1g5n-jRkSVSuQNONIgip0j3pHOfOnu2CBzoYhiknGo8,31902
+jaf/core/types.py,sha256=9UXrPkepw7opgv1VGbPAC1Zx80RP4-ouRxtb6kVTA-A,17063
 jaf/core/workflows.py,sha256=Ul-82gzjIXtkhnSMSPv-8igikjkMtW1EBo9yrfodtvI,26294
 jaf/memory/__init__.py,sha256=-L98xlvihurGAzF0DnXtkueDVvO_wV2XxxEwAWdAj50,1400
 jaf/memory/factory.py,sha256=Fh6JyvQtCKe38DZV5-NnC9vPRCvzBgSSPFIGaX7Nt5E,2958
@@ -68,7 +68,7 @@ jaf/policies/handoff.py,sha256=KJYYuL9T6v6DECRhnsS2Je6q4Aj9_zC5d_KBnvEnZNE,8318
 jaf/policies/validation.py,sha256=wn-7ynH10E5nk-_r1_kHIYHrBGmLX0EFr-FUTHrsxvc,10903
 jaf/providers/__init__.py,sha256=j_o-Rubr8d9tNYlFWb6fvzkxIBl3JKK_iabj9wTFia0,2114
 jaf/providers/mcp.py,sha256=WxcC8gUFpDBBYyhorMcc1jHq3xMDMBtnwyRPthfL0S0,13074
-jaf/providers/model.py,sha256=9kCisPgppBeVKXS7JtXeOyA5791Tdh6z0vcJbENAQNs,7535
+jaf/providers/model.py,sha256=9w2mph6g1TaLOFp3t0VtN2kYEfTa-lyYAVjAqQg3wrU,7748
 jaf/server/__init__.py,sha256=K0vSgTfzn3oM54UX9BeAROpaksYY43mFtfjSXoQrhXA,339
 jaf/server/main.py,sha256=CTb0ywbPIq9ELfay5MKChVR7BpIQOoEbPjPfpzo2aBQ,2152
 jaf/server/server.py,sha256=o-n6dPWmlu4_v5ozVW3BTOm1b5kHBQhqRYlHh5sXL-k,8048
@@ -79,9 +79,9 @@ jaf/visualization/functional_core.py,sha256=zedMDZbvjuOugWwnh6SJ2stvRNQX1Hlkb9Ab
 jaf/visualization/graphviz.py,sha256=WTOM6UP72-lVKwI4_SAr5-GCC3ouckxHv88ypCDQWJ0,12056
 jaf/visualization/imperative_shell.py,sha256=GpMrAlMnLo2IQgyB2nardCz09vMvAzaYI46MyrvJ0i4,2593
 jaf/visualization/types.py,sha256=QQcbVeQJLuAOXk8ynd08DXIS-PVCnv3R-XVE9iAcglw,1389
-jaf_py-2.2.3.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.2.3.dist-info/METADATA,sha256=IqS2qTIVxsXrYE0GLCKRRVv5H4MjwBCbg0UgWuqsZHE,23150
-jaf_py-2.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.2.3.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.2.3.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.2.3.dist-info/RECORD,,
+jaf_py-2.3.0.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.3.0.dist-info/METADATA,sha256=_MyYA624bGLW5kwGHSXg4jNrbD_PJEd7UGwr2_JTkdA,27613
+jaf_py-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.3.0.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.3.0.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.3.0.dist-info/RECORD,,