Merge pull request #52 from universal-tool-calling-protocol/dev

Add docs and update http to 1.0.2

Author: h3xxit

plugins/communication_protocols/http/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utcp-http"
-version = "1.0.1"
+version = "1.0.2"
 authors = [
   { name = "UTCP Contributors" },
 ]

plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.py

@@ -310,7 +310,11 @@ async def call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], too
                     timeout=aiohttp.ClientTimeout(total=30.0)
                 ) as response:
                     response.raise_for_status()
-                    return await response.json()
+                    
+                    content_type = response.headers.get('Content-Type', '').lower()
+                    if 'application/json' in content_type:
+                        return await response.json()
+                    return await response.text()
 
             except aiohttp.ClientResponseError as e:
                 logger.error(f"Error calling tool '{tool_name}' on call template '{tool_call_template.name}': {e}")

plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.py

@@ -30,7 +30,6 @@ class SseCommunicationProtocol(CommunicationProtocol):
 
     def __init__(self, logger: Optional[Callable[[str], None]] = None):
         self._oauth_tokens: Dict[str, Dict[str, Any]] = {}
-        self._active_connections: Dict[str, tuple[aiohttp.ClientResponse, aiohttp.ClientSession]] = {}
 
     def _apply_auth(self, provider: SseCallTemplate, headers: Dict[str, str], query_params: Dict[str, Any]) -> tuple:
         """Apply authentication to the request based on the provider's auth configuration.
@@ -148,13 +147,9 @@ async def register_manual(self, caller, manual_call_template: CallTemplate) -> R
 
     async def deregister_manual(self, caller, manual_call_template: CallTemplate) -> None:
         """REQUIRED
-        Deregister an SSE manual and close any active connections."""
-        template_name = manual_call_template.name
-        if template_name in self._active_connections:
-            response, session = self._active_connections.pop(template_name)
-            response.close()
-            await session.close()
-
+        Deregister an SSE manual."""
+        pass
+    
     async def call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: CallTemplate) -> Any:
         """REQUIRED
         Execute a tool call through SSE transport."""
@@ -210,7 +205,6 @@ async def call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str,
                 auth=auth, cookies=cookies, json=json_data, data=data, timeout=None
             )
             response.raise_for_status()
-            self._active_connections[tool_call_template.name] = (response, session)
             async for event in self._process_sse_stream(response, tool_call_template.event_type):
                 yield event
         except Exception as e:
@@ -300,15 +294,6 @@ async def _handle_oauth2(self, auth_details: OAuth2Auth) -> str:
             except aiohttp.ClientError as e:
                 logger.error(f"OAuth2 with header failed: {e}")
                 raise e
-
-    async def close(self):
-        """Closes all active connections and sessions."""
-        for provider_name in list(self._active_connections.keys()):
-            if provider_name in self._active_connections:
-                response, session = self._active_connections.pop(provider_name)
-                response.close()
-                await session.close()
-        self._active_connections.clear()
 
     def _build_url_with_path_params(self, url_template: str, tool_args: Dict[str, Any]) -> str:
         """Build URL by substituting path parameters from arguments.

plugins/communication_protocols/http/tests/test_sse_communication_protocol.py

@@ -112,7 +112,6 @@ async def sse_transport():
     """Fixture to create and properly tear down an SseCommunicationProtocol instance."""
     transport = SseCommunicationProtocol()
     yield transport
-    await transport.close()
 
 @pytest.fixture
 def app():
@@ -273,26 +272,6 @@ async def test_call_tool_error(sse_transport, aiohttp_client, app):
 
     assert excinfo.value.status == 500
 
-@pytest.mark.asyncio
-async def test_deregister_manual(sse_transport, aiohttp_client, app):
-    """Test deregistering a manual closes the connection."""
-    client = await aiohttp_client(app)
-    call_template = SseCallTemplate(name="test-deregister", url=f"{client.make_url('/events')}")
-    
-    # Make a call to establish a connection
-    stream_iterator = sse_transport.call_tool_streaming(None, "test_tool", {}, call_template)
-    await anext(stream_iterator)
-    assert call_template.name in sse_transport._active_connections
-    response, session = sse_transport._active_connections[call_template.name]
-
-    # Deregister
-    await sse_transport.deregister_manual(None, call_template)
-    
-    # Verify connection and session are closed and removed
-    assert call_template.name not in sse_transport._active_connections
-    assert response.closed
-    assert session.closed
-
 @pytest.mark.asyncio
 async def test_call_tool_basic_nonstream(sse_transport, aiohttp_client, app):
     """Non-streaming call should aggregate SSE events into a list (basic)."""