gateforge-sdk 0.2.3__tar.gz → 0.2.4__tar.gz

{gateforge_sdk-0.2.3 → gateforge_sdk-0.2.4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gateforge-sdk
-Version: 0.2.3
-Summary: Privacy-first LLMOps SDK — Auto-init, tool/agent decorators, session tracing, PII masking, cost tracking
+Version: 0.2.4
+Summary: Privacy-first LLMOps SDK — Auto-init, tool/agent decorators, session tracing, nested conversation support
 Project-URL: Homepage, https://gateforge.dev
 Project-URL: Documentation, https://gateforge.dev/docs
 Project-URL: Repository, https://github.com/gateforge/gateforge-sdk

{gateforge_sdk-0.2.3 → gateforge_sdk-0.2.4}/gateforge/context.py

@@ -183,6 +183,9 @@ def agent(
     """
     Decorator that creates a trace context for an agent function.
     
+    If there's an active trace (e.g., from gateforge.session()), it uses that
+    conversation_id for proper nesting. Otherwise creates a new trace.
+    
     All LLM calls and tool calls inside are automatically traced.
     
     Usage::
@@ -190,14 +193,27 @@ def agent(
         def my_agent(message):
             response = client.chat.completions.create(...)
             return response
+        
+        # Or inside a session - shares the session's conversation_id:
+        with gateforge.session() as sess:
+            my_agent("hello")  # Uses sess.conversation_id
     """
     def decorator(fn: Callable) -> Callable:
         @functools.wraps(fn)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             from gateforge.tracing import emit_trace_event
             
-            # Generate or use provided conversation_id
-            cid = conversation_id or f"{fn.__name__}-{int(time.time())}"
+            # Check if there's an active trace (e.g., from session())
+            active_trace = get_active_trace()
+            
+            if active_trace:
+                # Use existing conversation_id for nesting
+                cid = active_trace.conversation_id
+                is_nested = True
+            else:
+                # Create new conversation_id
+                cid = conversation_id or f"{fn.__name__}-{int(time.time())}"
+                is_nested = False
             
             # Emit agent start event
             emit_trace_event(
@@ -206,12 +222,15 @@ def agent(
                 conversation_id=cid,
                 event_type="agent_start",
                 step=0,
-                metadata={"user_id": user_id, "args": _safe_str(args)[:200], "agent_name": name or fn.__name__},
+                metadata={"user_id": user_id, "args": _safe_str(args)[:200], "agent_name": name or fn.__name__, "nested": is_nested},
             )
             
-            # Enter trace context
-            ctx = trace(conversation_id=cid)
-            ctx.__enter__()
+            # Enter trace context (only if not already in one)
+            if not is_nested:
+                ctx = trace(conversation_id=cid)
+                ctx.__enter__()
+            else:
+                ctx = None  # Already in a trace context
             
             try:
                 result = fn(*args, **kwargs)
@@ -222,7 +241,7 @@ def agent(
                     base_url=_get_base_url(),
                     conversation_id=cid,
                     event_type="agent_end",
-                    step=ctx.ctx.step,
+                    step=active_trace.step if active_trace else ctx.ctx.step,
                     metadata={"success": True},
                 )
                 
@@ -234,12 +253,13 @@ def agent(
                     base_url=_get_base_url(),
                     conversation_id=cid,
                     event_type="agent_error",
-                    step=ctx.ctx.step,
+                    step=active_trace.step if active_trace else ctx.ctx.step,
                     metadata={"error": str(e)[:500]},
                 )
                 raise
             finally:
-                ctx.__exit__(None, None, None)
+                if ctx:
+                    ctx.__exit__(None, None, None)
         
         return wrapper
     return decorator

{gateforge_sdk-0.2.3 → gateforge_sdk-0.2.4}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gateforge-sdk"
-version = "0.2.3"
-description = "Privacy-first LLMOps SDK — Auto-init, tool/agent decorators, session tracing, PII masking, cost tracking"
+version = "0.2.4"
+description = "Privacy-first LLMOps SDK — Auto-init, tool/agent decorators, session tracing, nested conversation support"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{gateforge_sdk-0.2.3 → gateforge_sdk-0.2.4}/tests/test_phase1.py

@@ -20,9 +20,7 @@ class TestAutoInit:
     
     def test_auto_init_no_api_key(self, capsys):
         """auto_init() should silently skip if no API key found."""
-        # Ensure no API key in env
         with patch.dict(os.environ, {}, clear=True):
-            # Need to reload module to pick up new env
             import importlib
             import gateforge
             importlib.reload(gateforge)
@@ -36,7 +34,6 @@ class TestAutoInit:
     def test_auto_init_with_api_key(self, capsys):
         """auto_init() should initialize successfully with API key."""
         with patch.dict(os.environ, {"GATEFORGE_API_KEY": "gf_test_key"}):
-            # Mock the init function to avoid actual API calls
             with patch('gateforge.init') as mock_init:
                 import gateforge
                 result = gateforge.auto_init()
@@ -45,7 +42,6 @@ class TestAutoInit:
                 captured = capsys.readouterr()
                 assert "Auto-initialized successfully" in captured.out
                 
-                # Verify init was called with correct params
                 mock_init.assert_called_once()
                 call_kwargs = mock_init.call_args[1]
                 assert call_kwargs['api_key'] == 'gf_test_key'
@@ -107,7 +103,6 @@ class TestToolDecorator:
         """Tool should emit trace event when inside active trace."""
         import gateforge
         
-        # Mock emit_trace_event in tracing module where it's called
         with patch('gateforge.tracing.emit_trace_event') as mock_emit:
             @gateforge.tool()
             def weather_tool(location: str) -> str:
@@ -118,7 +113,6 @@ class TestToolDecorator:
                 
                 assert result == "Weather in Madrid: sunny"
                 
-                # Verify trace event was emitted
                 mock_emit.assert_called_once()
                 call_kwargs = mock_emit.call_args[1]
                 assert call_kwargs['conversation_id'] == 'test-123'
@@ -140,7 +134,6 @@ class TestToolDecorator:
                 with pytest.raises(ValueError):
                     failing_tool()
                 
-                # Verify error was captured
                 mock_emit.assert_called_once()
                 call_kwargs = mock_emit.call_args[1]
                 assert call_kwargs['metadata']['success'] is False
@@ -185,13 +178,12 @@ class TestAgentDecorator:
     """Tests for @gateforge.agent() decorator."""
     
     def test_agent_creates_trace_context(self):
-        """Agent should create trace context automatically."""
+        """Agent should create trace context if not already in one."""
         import gateforge
         from gateforge.context import get_active_trace
         
         @gateforge.agent(conversation_id="agent-test-1")
         def my_agent(message: str) -> str:
-            # Should have active trace inside agent
             trace_ctx = get_active_trace()
             assert trace_ctx is not None
             assert trace_ctx.conversation_id == "agent-test-1"
@@ -200,6 +192,20 @@ class TestAgentDecorator:
         result = my_agent("Hello")
         assert "Hello" in result
     
+    def test_agent_uses_active_session_conversation_id(self):
+        """Agent should use session's conversation_id when nested."""
+        import gateforge
+        from gateforge.context import get_active_trace
+        
+        @gateforge.agent()
+        def my_agent():
+            trace_ctx = get_active_trace()
+            return trace_ctx.conversation_id
+        
+        with gateforge.session(conversation_id="session-123") as sess:
+            agent_cid = my_agent()
+            assert agent_cid == "session-123"
+    
     def test_agent_emits_start_end_events(self):
         """Agent should emit start and end events."""
         import gateforge
@@ -211,19 +217,33 @@ class TestAgentDecorator:
             
             result = my_agent("Hello")
             
-            # Should emit 2 events: start and end
             assert mock_emit.call_count == 2
             
-            # First call: agent_start
             first_call = mock_emit.call_args_list[0][1]
             assert first_call['event_type'] == 'agent_start'
             assert first_call['conversation_id'] == 'agent-test-2'
             
-            # Second call: agent_end
             second_call = mock_emit.call_args_list[1][1]
             assert second_call['event_type'] == 'agent_end'
             assert second_call['metadata']['success'] is True
     
+    def test_agent_nested_doesnt_create_new_trace(self):
+        """Nested agent should not create new trace context."""
+        import gateforge
+        
+        with patch('gateforge.tracing.emit_trace_event') as mock_emit:
+            @gateforge.agent()
+            def my_agent():
+                return "OK"
+            
+            with gateforge.session(conversation_id="session-456"):
+                my_agent()
+            
+            assert mock_emit.call_count == 4
+            
+            conversation_ids = [call[1]['conversation_id'] for call in mock_emit.call_args_list]
+            assert all(cid == 'session-456' for cid in conversation_ids)
+    
     def test_agent_emits_error_event(self):
         """Agent should emit error event on exception."""
         import gateforge
@@ -236,16 +256,14 @@ class TestAgentDecorator:
             with pytest.raises(RuntimeError):
                 failing_agent()
             
-            # Should emit 2 events: start and error
             assert mock_emit.call_count == 2
             
-            # Second call: agent_error
             second_call = mock_emit.call_args_list[1][1]
             assert second_call['event_type'] == 'agent_error'
             assert 'Agent failed' in second_call['metadata']['error']
     
     def test_agent_auto_generates_conversation_id(self):
-        """Agent should auto-generate conversation_id if not provided."""
+        """Agent should auto-generate conversation_id if not provided and no active trace."""
         import gateforge
         
         with patch('gateforge.tracing.emit_trace_event') as mock_emit:
@@ -255,11 +273,27 @@ class TestAgentDecorator:
             
             my_agent()
             
-            # Verify conversation_id was generated
             first_call = mock_emit.call_args_list[0][1]
             assert 'conversation_id' in first_call
             assert first_call['conversation_id'].startswith('my_agent-')
     
+    def test_agent_nested_shows_metadata(self):
+        """Nested agent should include nested=True in metadata."""
+        import gateforge
+        
+        with patch('gateforge.tracing.emit_trace_event') as mock_emit:
+            @gateforge.agent()
+            def my_agent():
+                return "OK"
+            
+            with gateforge.session():
+                my_agent()
+            
+            for call in mock_emit.call_args_list:
+                if call[1]['event_type'] == 'agent_start':
+                    assert call[1]['metadata']['nested'] is True
+                    break
+    
     def test_agent_with_user_id(self):
         """Agent should include user_id in metadata."""
         import gateforge
@@ -287,15 +321,12 @@ class TestSession:
                 assert sess.conversation_id is not None
                 assert sess.user_id == "user-456"
             
-            # Should emit start and end events
             assert mock_emit.call_count == 2
             
-            # First: session_start
             first_call = mock_emit.call_args_list[0][1]
             assert first_call['event_type'] == 'session_start'
             assert first_call['metadata']['user_id'] == 'user-456'
             
-            # Second: session_end
             second_call = mock_emit.call_args_list[1][1]
             assert second_call['event_type'] == 'session_end'
     
@@ -314,15 +345,12 @@ class TestSession:
         """Session provides a conversation context that can be used by nested traces."""
         import gateforge
         
-        # Session provides its conversation_id for use
         with gateforge.session(conversation_id="session-test") as sess:
-            # Can explicitly continue the session's conversation
             with gateforge.continue_session(sess.conversation_id) as t1:
                 assert t1.conversation_id == "session-test"
             
-            # Or create independent traces (also valid)
             with gateforge.trace() as t2:
-                assert t2.conversation_id != "session-test"  # Independent trace
+                assert t2.conversation_id != "session-test"
     
     def test_session_emits_error_on_exception(self):
         """Session should emit error event on exception."""
@@ -333,10 +361,8 @@ class TestSession:
                 with gateforge.session() as sess:
                     raise ValueError("Session error")
             
-            # Should emit start, error, and finally end (3 total)
             assert mock_emit.call_count >= 2
             
-            # Find the error event
             error_event = None
             for call in mock_emit.call_args_list:
                 if call[1]['event_type'] == 'session_error':
@@ -351,7 +377,7 @@ class TestIntegration:
     """Integration tests combining multiple features."""
     
     def test_agent_with_tools(self):
-        """Agent with decorated tools should trace everything."""
+        """Agent with decorated tools should trace everything with same conversation_id."""
         import gateforge
         
         with patch('gateforge.tracing.emit_trace_event') as mock_emit:
@@ -366,18 +392,16 @@ class TestIntegration:
             
             result = my_agent()
             
-            # Should emit: agent_start, tool_call, agent_end
             assert mock_emit.call_count == 3
             
             events = [call[1]['event_type'] for call in mock_emit.call_args_list]
             assert events == ['agent_start', 'tool_call', 'agent_end']
             
-            # All should share same conversation_id
             conversation_ids = [call[1]['conversation_id'] for call in mock_emit.call_args_list]
             assert all(cid == 'integration-1' for cid in conversation_ids)
     
     def test_session_with_agent_and_tools(self):
-        """Session wrapping agent with tools should trace everything."""
+        """Session wrapping agent with tools should all share same conversation_id."""
         import gateforge
         
         with patch('gateforge.tracing.emit_trace_event') as mock_emit:
@@ -389,10 +413,9 @@ class TestIntegration:
             def weather_agent(location: str):
                 return get_weather(location)
             
-            with gateforge.session(user_id="user-integration"):
+            with gateforge.session(conversation_id="session-integration"):
                 result = weather_agent("Madrid")
             
-            # Should emit: session_start, agent_start, tool_call, agent_end, session_end
             assert mock_emit.call_count == 5
             
             events = [call[1]['event_type'] for call in mock_emit.call_args_list]
@@ -403,6 +426,9 @@ class TestIntegration:
                 'agent_end',
                 'session_end'
             ]
+            
+            conversation_ids = [call[1]['conversation_id'] for call in mock_emit.call_args_list]
+            assert all(cid == 'session-integration' for cid in conversation_ids), f"Got different IDs: {set(conversation_ids)}"
 
 
 if __name__ == '__main__':