licos-dev-sdk 0.4.8__tar.gz → 0.5.0__tar.gz

{licos_dev_sdk-0.4.8 → licos_dev_sdk-0.5.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.4.8
+Version: 0.5.0
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4>=4.12
 Requires-Dist: docxtpl>=0.16
 Requires-Dist: graphviz>=0.20
 Requires-Dist: jinja2>=3.1
-Requires-Dist: licos-platform-sdk>=0.3.2
+Requires-Dist: licos-platform-sdk>=0.6.1
 Requires-Dist: matplotlib>=3.9
 Requires-Dist: mistune>=3.0
 Requires-Dist: openpyxl>=3.1

{licos_dev_sdk-0.4.8 → licos_dev_sdk-0.5.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.4.8"
+version = "0.5.0"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-platform-sdk>=0.3.2",
+    "licos-platform-sdk>=0.6.1",
     "weasyprint>=62.0",
     "python-docx>=1.1",
     "docxtpl>=0.16",

licos_dev_sdk-0.5.0/src/licos_dev_sdk/langchain_reasoning.py

@@ -0,0 +1,32 @@
+"""Preserve provider reasoning fields that ChatOpenAI intentionally omits."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def reasoning_chat_model_class(base_class: type) -> type:
+    class ReasoningChatOpenAI(base_class):
+        def _convert_chunk_to_generation_chunk(
+            self, chunk: dict[str, Any], default_chunk_class: type, base_generation_info: dict[str, Any] | None,
+        ) -> Any:
+            generation = super()._convert_chunk_to_generation_chunk(
+                chunk, default_chunk_class, base_generation_info,
+            )
+            choices = chunk.get("choices") or chunk.get("chunk", {}).get("choices", [])
+            if generation is not None and choices:
+                delta = choices[0].get("delta") or {}
+                reasoning = delta.get("reasoning_content")
+                if isinstance(reasoning, str):
+                    generation.message.additional_kwargs["reasoning_content"] = reasoning
+            return generation
+
+        def _create_chat_result(self, response: Any, generation_info: dict[str, Any] | None = None) -> Any:
+            result = super()._create_chat_result(response, generation_info)
+            raw = response if isinstance(response, dict) else response.model_dump()
+            for choice, generation in zip(raw["choices"], result.generations):
+                reasoning = choice["message"].get("reasoning_content")
+                if isinstance(reasoning, str):
+                    generation.message.additional_kwargs["reasoning_content"] = reasoning
+            return result
+
+    return ReasoningChatOpenAI

{licos_dev_sdk-0.4.8 → licos_dev_sdk-0.5.0}/src/licos_dev_sdk/model.py

@@ -7,11 +7,13 @@ import json
 import logging
 import mimetypes
 import queue
+import re
 import threading
 import time
 import uuid
 from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
+from decimal import Decimal
 from pathlib import Path
 from typing import Any, Callable, Iterator, Sequence
 from urllib import error as urlerror
@@ -486,6 +488,7 @@ def create_chat_openai(
     timeout: int | None = None,
     streaming: bool = True,
     use_responses_api: bool | None = None,
+    preserve_reasoning: bool = False,
     default_headers: dict[str, str] | None = None,
     **kwargs: Any,
 ) -> Any:
@@ -496,6 +499,8 @@ def create_chat_openai(
     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.
+    `preserve_reasoning=True` keeps Chat Completions providers' `reasoning_content`
+    in LangChain message metadata for a caller that explicitly forwards it.
     """
     try:
         from langchain_core.callbacks import BaseCallbackHandler
@@ -569,6 +574,10 @@ def create_chat_openai(
         ),
         **kwargs,
     }
+    if preserve_reasoning and not use_responses_api:
+        from .langchain_reasoning import reasoning_chat_model_class
+
+        return reasoning_chat_model_class(ChatOpenAI)(**chat_kwargs)
     return ChatOpenAI(**chat_kwargs)
 
 
@@ -2511,10 +2520,11 @@ def _int_field(data: dict[str, Any], names: Sequence[str]) -> int | None:
             parsed = int(value)
             return parsed if parsed > 0 else None
         if isinstance(value, str):
-            try:
-                parsed = int(value.strip())
-            except ValueError:
+            match = re.fullmatch(r"\s*(\d+(?:\.\d+)?)\s*([KMG]?)\s*", value, flags=re.IGNORECASE)
+            if match is None:
                 continue
+            multiplier = {"": 1, "K": 1000, "M": 1000000, "G": 1000000000}[match.group(2).upper()]
+            parsed = int(Decimal(match.group(1)) * multiplier)
             return parsed if parsed > 0 else None
     return None
 

{licos_dev_sdk-0.4.8 → licos_dev_sdk-0.5.0}/tests/test_model.py

@@ -821,6 +821,25 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(endpoint.max_input_length, 128000)
         self.assertEqual(endpoint.max_output_length, 64000)
 
+    def test_resolve_llm_endpoint_parses_catalog_limit_suffixes(self) -> None:
+        def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
+            if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
+                return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
+            if _is_available_models_request(req):
+                return _available_models_response(req)
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                detail = _model_detail_payload()
+                detail["data"].update(contextLength="1M", maxInputLength="991K", maxOutputLength="128K")
+                return _FakeResponse(detail)
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            endpoint = model.resolve_llm_endpoint()
+
+        self.assertEqual(endpoint.context_length, 1000000)
+        self.assertEqual(endpoint.max_input_length, 991000)
+        self.assertEqual(endpoint.max_output_length, 128000)
+
     def test_resolve_llm_endpoint_accepts_explicit_model(self) -> None:
         def fake_urlopen(req: Any, timeout: int = 0) -> _FakeResponse:
             if req.full_url == "http://platform.example/api/v1/internal/auth/ai-user-token":
@@ -862,9 +881,13 @@ class ModelSdkTests(unittest.TestCase):
         with (
             mock.patch.object(model.request, "urlopen", fake_urlopen),
             mock.patch.dict(sys.modules, {"langchain_openai": fake_langchain_openai}),
+            mock.patch("httpx.Client", return_value=object()),
+            mock.patch("httpx.AsyncClient", return_value=object()),
         ):
             chat_model = model.create_chat_openai(
                 model="auto",
+                preserve_reasoning=True,
+                use_responses_api=False,
                 temperature=0.2,
                 max_completion_tokens=100000,
                 timeout=30,
@@ -875,6 +898,7 @@ class ModelSdkTests(unittest.TestCase):
             )
 
         self.assertIsInstance(chat_model, FakeChatOpenAI)
+        self.assertIsNot(type(chat_model), FakeChatOpenAI)
         self.assertEqual(captured["exchange_headers"]["Authorization"], "Bearer ai-agent-token")
         self.assertEqual(captured["catalog_headers"]["Authorization"], "Bearer user-token")
         self.assertEqual(captured["detail_headers"]["Authorization"], "Bearer user-token")