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

{licos_dev_sdk-0.4.4 → licos_dev_sdk-0.4.6}/DOCX.md

@@ -1,4 +1,4 @@
-# Word SDK / CLI 0.4.4
+# Word SDK / CLI 0.4.5
 
 Cloud document execution stays in `licos-dev-sdk` and `licos-dev`. CLI commands
 only parse arguments and call the SDK; no additional Agent-native Word tools are

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.4.4
+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.4 → licos_dev_sdk-0.4.6}/pyproject.toml

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

{licos_dev_sdk-0.4.4 → licos_dev_sdk-0.4.6}/src/licos_dev_sdk/document_docx_inspect.py

@@ -62,7 +62,7 @@ def inspect_docx(source: str | Path, *, scope: str = "all", offset: int = 1, lim
             if element.tag == W + "tbl":
                 grid = element.find(W + "tblGrid")
                 tables.append({"part": part, "row_count": len(element.findall(W + "tr")),
-                               "column_count": len(grid) if grid is not None else None})
+                               "column_count": len(grid.findall(W + "gridCol")) if grid is not None else None})
             if element.tag not in {A + "blip", V + "imagedata"}:
                 continue
             rid = element.get(R + "embed") or element.get(R + "link") or element.get(R + "id")

{licos_dev_sdk-0.4.4 → 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.4 → licos_dev_sdk-0.4.6}/tests/test_docx_inspect.py

@@ -82,6 +82,26 @@ def test_incomplete_toc_and_external_or_missing_image_relationships(tmp_path):
     assert [image['status'] for image in report['images']['items']] == ['external', 'missing_relationship']
 
 
+def test_table_grid_revisions_do_not_count_as_current_columns(tmp_path):
+    path = tmp_path / 'tracked-table.docx'
+    doc = Document()
+    table = doc.add_table(rows=3, cols=2)
+    change = OxmlElement('w:tblGridChange')
+    change.set(qn('w:id'), '1')
+    previous = OxmlElement('w:tblGrid')
+    previous.append(OxmlElement('w:gridCol'))
+    change.append(previous)
+    table._tbl.tblGrid.append(change)
+    doc.save(path)
+    original = path.read_bytes()
+    assert len(Document(path).tables[0].columns) == 2
+    report = inspect_docx(path, scope='tables')
+    assert report['tables']['items'] == [
+        {'part': 'word/document.xml', 'row_count': 3, 'column_count': 2},
+    ]
+    assert path.read_bytes() == original
+
+
 def test_batch_file_assertions_resolve_from_explicit_base_and_keep_exact_text(tmp_path, monkeypatch):
     path = tmp_path / 'report.docx'
     text = '  中文🙂\tA\n' * 90 + '  '

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()