licos-dev-sdk 0.4.5__tar.gz → 0.4.6__tar.gz

{licos_dev_sdk-0.4.5 → licos_dev_sdk-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.4.5
+Version: 0.4.6
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4>=4.12

{licos_dev_sdk-0.4.5 → licos_dev_sdk-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.4.5"
+version = "0.4.6"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.4.5 → licos_dev_sdk-0.4.6}/src/licos_dev_sdk/model.py

@@ -482,6 +482,7 @@ def create_chat_openai(
     max_completion_tokens: int | None = None,
     timeout: int | None = None,
     streaming: bool = True,
+    use_responses_api: bool | None = None,
     default_headers: dict[str, str] | None = None,
     **kwargs: Any,
 ) -> Any:
@@ -490,6 +491,8 @@ def create_chat_openai(
     `model=None`, an empty string, or `model="auto"` uses the catalog default. The
     returned ChatOpenAI receives the current user token as its OpenAI-compatible API
     key, so deployed projects do not need LLM_MODEL/OPENAI_MODEL env injection.
+    A catalog `response_url` selects Responses by default. Set
+    `use_responses_api=False` to use Chat Completions explicitly.
     """
     try:
         from langchain_core.callbacks import BaseCallbackHandler
@@ -500,6 +503,11 @@ def create_chat_openai(
 
     runtime = _model_runtime(base_url=base_url, user_token=user_token, user_id=user_id, workspace_id=workspace_id)
     endpoint = _resolve_chat_endpoint(runtime, model_group=model_group, requested_model=model)
+    if use_responses_api is None:
+        use_responses_api = bool(endpoint.response_url)
+    if use_responses_api and not endpoint.response_url:
+        raise ConfigurationError(f"Model {endpoint.model!r} has no response_url configured")
+    endpoint_url = endpoint.response_url if use_responses_api else endpoint.base_url
     headers = _without_authorization(
         _merge_headers(
             endpoint.request_headers or endpoint.required_headers,
@@ -540,7 +548,8 @@ def create_chat_openai(
         )
     chat_kwargs: dict[str, Any] = {
         "model": endpoint.model,
-        "base_url": _chat_completions_sdk_base_url(endpoint.base_url),
+        "base_url": _openai_sdk_base_url(endpoint_url, use_responses_api=use_responses_api),
+        "use_responses_api": use_responses_api,
         "api_key": api_key or runtime.token,
         "streaming": streaming,
         **_not_none(
@@ -622,9 +631,10 @@ def _LangChainUsageHandler(
     return UsageHandler()
 
 
-def _chat_completions_sdk_base_url(url: str) -> str:
+def _openai_sdk_base_url(url: str, *, use_responses_api: bool) -> str:
     trimmed = str(url or "").strip().rstrip("/")
-    return trimmed.removesuffix("/chat/completions").rstrip("/")
+    suffix = "/responses" if use_responses_api else "/chat/completions"
+    return trimmed.removesuffix(suffix).rstrip("/")
 
 
 def resolve_vision_endpoint(

licos_dev_sdk-0.4.6/tests/test_langchain_protocol.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+import sys
+import unittest
+from unittest.mock import patch
+
+import httpx
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "licos-platform-sdk" / "src"))
+
+from licos_dev_sdk import model
+from licos_platform_sdk._runtime import ConfigurationError
+
+
+CHAT_URL = "https://chat.example/compatible/v1/chat/completions"
+RESPONSES_URL = "https://responses.example/api/v1/responses"
+
+
+class LangChainProtocolTests(unittest.TestCase):
+    def setUp(self):
+        runtime = model.ModelRuntime(base_url="https://platform.example", token="user-token")
+        self.runtime_patch = patch.object(model, "_model_runtime", return_value=runtime)
+        self.usage_patch = patch.object(model, "_enqueue_model_usage")
+        self.runtime_patch.start()
+        self.usage = self.usage_patch.start()
+        self.addCleanup(self.runtime_patch.stop)
+        self.addCleanup(self.usage_patch.stop)
+
+    def endpoint(self, response_url):
+        return model.ModelEndpoint(
+            provider="test", capability="chat", model="test-model", base_url=CHAT_URL,
+            response_url=response_url, request_headers={"X-Provider-Route": "route-1"},
+        )
+
+    def response(self, request):
+        if str(request.url) == RESPONSES_URL:
+            body = {
+                "id": "resp_1", "object": "response", "created_at": 1,
+                "model": "test-model", "status": "completed", "error": None,
+                "output": [{"id": "msg_1", "type": "message", "role": "assistant", "status": "completed",
+                            "content": [{"type": "output_text", "text": "answer", "annotations": []}]}],
+                "usage": {"input_tokens": 3, "output_tokens": 2, "total_tokens": 5},
+            }
+        else:
+            self.assertEqual(str(request.url), CHAT_URL)
+            body = {
+                "id": "chat_1", "object": "chat.completion", "created": 1, "model": "test-model",
+                "choices": [{"index": 0, "message": {"role": "assistant", "content": "answer"}, "finish_reason": "stop"}],
+                "usage": {"prompt_tokens": 3, "completion_tokens": 2, "total_tokens": 5},
+            }
+        return httpx.Response(200, json=body)
+
+    def test_catalog_selects_actual_protocol_and_address(self):
+        for response_url, override, expected in [
+            (RESPONSES_URL, None, RESPONSES_URL),
+            (None, None, CHAT_URL),
+            (RESPONSES_URL, False, CHAT_URL),
+            (RESPONSES_URL, True, RESPONSES_URL),
+        ]:
+            for asynchronous in (False, True):
+                with self.subTest(response_url=response_url, override=override, asynchronous=asynchronous):
+                    requests = []
+
+                    def handle(request):
+                        requests.append(request)
+                        return self.response(request)
+
+                    transport = httpx.MockTransport(handle)
+                    sync_client = httpx.Client(transport=transport)
+                    async_client = httpx.AsyncClient(transport=transport)
+                    try:
+                        with patch.object(model, "_resolve_chat_endpoint", return_value=self.endpoint(response_url)):
+                            options = {} if override is None else {"use_responses_api": override}
+                            chat = model.create_chat_openai(streaming=False, http_client=sync_client,
+                                                            http_async_client=async_client, **options)
+                        result = asyncio.run(chat.ainvoke("question")) if asynchronous else chat.invoke("question")
+                        self.assertEqual(len(requests), 1)
+                        self.assertEqual(str(requests[0].url), expected)
+                        payload = json.loads(requests[0].content)
+                        self.assertIn("input" if expected == RESPONSES_URL else "messages", payload)
+                        self.assertEqual(requests[0].headers["Authorization"], "Bearer user-token")
+                        self.assertEqual(requests[0].headers["X-Provider-Route"], "route-1")
+                        self.assertTrue(requests[0].headers[model.MODEL_REQUEST_ID_HEADER])
+                        self.assertEqual(result.text, "answer")
+                        self.assertEqual(result.usage_metadata["total_tokens"], 5)
+                        self.assertEqual(chat.use_responses_api, expected == RESPONSES_URL)
+                    finally:
+                        sync_client.close()
+                        asyncio.run(async_client.aclose())
+
+    def test_explicit_responses_requires_catalog_address(self):
+        with patch.object(model, "_resolve_chat_endpoint", return_value=self.endpoint(None)):
+            with self.assertRaisesRegex(ConfigurationError, "response_url"):
+                model.create_chat_openai(use_responses_api=True)
+
+    def test_streaming_uses_selected_endpoint_and_keeps_usage(self):
+        for response_url in (RESPONSES_URL, None):
+            for asynchronous in (False, True):
+                with self.subTest(response_url=response_url, asynchronous=asynchronous):
+                    requests = []
+
+                    def handle(request):
+                        requests.append(request)
+                        body = self.response(request).json()
+                        if response_url:
+                            events = [
+                                {"type": "response.created", "response": {**body, "status": "in_progress", "output": []}},
+                                {"type": "response.output_text.delta", "output_index": 0, "content_index": 0,
+                                 "item_id": "msg_1", "delta": "answer"},
+                                {"type": "response.output_text.done", "output_index": 0, "content_index": 0,
+                                 "item_id": "msg_1", "text": "answer"},
+                                {"type": "response.completed", "response": body},
+                            ]
+                            text = "".join(f"event: {event['type']}\ndata: {json.dumps({**event, 'sequence_number': i})}\n\n"
+                                           for i, event in enumerate(events))
+                        else:
+                            base = {"id": "chat_1", "object": "chat.completion.chunk", "created": 1, "model": "test-model"}
+                            events = [
+                                {**base, "choices": [{"index": 0, "delta": {"role": "assistant", "content": "answer"}, "finish_reason": None}]},
+                                {**base, "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]},
+                                {**base, "choices": [], "usage": body["usage"]},
+                            ]
+                            text = "".join(f"data: {json.dumps(event)}\n\n" for event in events) + "data: [DONE]\n\n"
+                        return httpx.Response(200, headers={"Content-Type": "text/event-stream"}, content=text)
+
+                    transport = httpx.MockTransport(handle)
+                    sync_client = httpx.Client(transport=transport)
+                    async_client = httpx.AsyncClient(transport=transport)
+                    try:
+                        with patch.object(model, "_resolve_chat_endpoint", return_value=self.endpoint(response_url)):
+                            chat = model.create_chat_openai(http_client=sync_client, http_async_client=async_client)
+
+                        async def collect():
+                            return [chunk async for chunk in chat.astream("question")]
+
+                        chunks = asyncio.run(collect()) if asynchronous else list(chat.stream("question"))
+                        combined = chunks[0]
+                        for chunk in chunks[1:]:
+                            combined += chunk
+                        self.assertEqual(str(requests[0].url), response_url or CHAT_URL)
+                        self.assertTrue(json.loads(requests[0].content)["stream"])
+                        self.assertEqual(combined.text, "answer")
+                        self.assertEqual(combined.usage_metadata["total_tokens"], 5)
+                    finally:
+                        sync_client.close()
+                        asyncio.run(async_client.aclose())
+
+
+if __name__ == "__main__":
+    unittest.main()