licos-dev-sdk 0.2.3__tar.gz → 0.2.5__tar.gz

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/.gitignore

@@ -17,9 +17,10 @@ packages/*/dist/
 .DS_Store
 Thumbs.db
 
-# Environment
-.env
-.env.local
+# Environment
+.env
+.env.local
+crates/industrial/industrial-stack.env
 
 # Workspace
 /workspace/

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.2.3
+Version: 0.2.5
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: graphviz>=0.20
 Requires-Dist: jinja2>=3.1
-Requires-Dist: licos-platform-sdk>=0.2.6
+Requires-Dist: licos-platform-sdk>=0.2.8
 Requires-Dist: matplotlib>=3.9
 Requires-Dist: mistune>=3.0
 Requires-Dist: openpyxl>=3.1

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.2.3"
+version = "0.2.5"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-platform-sdk>=0.2.6",
+    "licos-platform-sdk>=0.2.8",
     "weasyprint>=62.0",
     "python-docx>=1.1",
     "openpyxl>=3.1",
@@ -24,4 +24,4 @@ dependencies = [
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/licos_dev_sdk"]
+packages = ["src/licos_dev_sdk"]

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/src/licos_dev_sdk/__init__.py

@@ -49,6 +49,7 @@ def __getattr__(name: str):
         "SpeechRecognitionClient": ("model", "SpeechRecognitionClient"),
         "ASRClient": ("model", "ASRClient"),
         "fetch_model_catalogs": ("model", "fetch_model_catalogs"),
+        "fetch_model_detail": ("model", "fetch_model_detail"),
         "resolve_llm_endpoint": ("model", "resolve_llm_endpoint"),
         "resolve_vision_endpoint": ("model", "resolve_vision_endpoint"),
         "resolve_image_generation_endpoint": ("model", "resolve_image_generation_endpoint"),
@@ -93,7 +94,7 @@ __all__ = [
     "ApiError", "ConfigurationError",
     "LLMClient", "VisionClient", "VisionUnderstandingClient", "ImageGenerationClient", "VideoGenerationClient",
     "SpeechRecognitionClient", "ASRClient",
-    "fetch_model_catalogs", "resolve_llm_endpoint", "resolve_vision_endpoint",
+    "fetch_model_catalogs", "fetch_model_detail", "resolve_llm_endpoint", "resolve_vision_endpoint",
     "resolve_image_generation_endpoint", "resolve_video_generation_endpoint",
     "resolve_speech_recognition_endpoint",
     "invoke_llm", "generate_image", "generate_video", "recognize_speech", "understand_image",

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/src/licos_dev_sdk/model.py

@@ -19,12 +19,14 @@ from licos_platform_sdk._runtime import (
 
 
 MODEL_CATALOG_PATH = "/api/v1/llm-gateway/ai/model-catalog"
+MODEL_DETAIL_PATH = "/api/v1/admin/workspaces/models/detail"
 DEFAULT_REQUEST_TIMEOUT_SECS = 120
 DEFAULT_ASYNC_TIMEOUT_SECS = 600
 DEFAULT_ASYNC_POLL_INTERVAL_SECS = 2.0
 DEFAULT_CATALOG_CACHE_TTL_SECS = 300
 
 _CATALOG_CACHE: dict[tuple[str, str], tuple[float, list[dict[str, Any]]]] = {}
+_DETAIL_CACHE: dict[tuple[str, str, str, str], tuple[float, dict[str, Any] | None]] = {}
 
 
 @dataclass(frozen=True)
@@ -42,6 +44,11 @@ class ModelEndpoint:
     model: str
     required_headers: dict[str, str] = field(default_factory=dict)
     endpoint: dict[str, Any] = field(default_factory=dict)
+    response_url: str | None = None
+    cache_context: bool = False
+    context_length: int | None = None
+    max_input_length: int | None = None
+    max_output_length: int | None = None
 
     @property
     def async_task(self) -> bool:
@@ -101,6 +108,20 @@ def fetch_model_catalogs(
     return _fetch_model_catalogs(runtime, refresh=refresh)
 
 
+def fetch_model_detail(
+    model_code: str,
+    *,
+    base_url: str | None = None,
+    user_token: str | None = None,
+    user_id: str | None = None,
+    workspace_id: str | None = None,
+    refresh: bool = False,
+) -> dict[str, Any] | None:
+    """Fetch model detail, including base URL, Response API support and token limits."""
+    runtime = _model_runtime(base_url=base_url, user_token=user_token, user_id=user_id)
+    return _fetch_model_detail(runtime, model_code, workspace_id=workspace_id, refresh=refresh)
+
+
 def resolve_llm_endpoint(
     *,
     model_group: str = "text",
@@ -109,7 +130,7 @@ def resolve_llm_endpoint(
     user_id: str | None = None,
 ) -> ModelEndpoint:
     runtime = _model_runtime(base_url=base_url, user_token=user_token, user_id=user_id)
-    return _resolve_endpoint(runtime, "chat", model_group=model_group)
+    return _resolve_chat_endpoint(runtime, model_group=model_group)
 
 
 def resolve_vision_endpoint(
@@ -174,15 +195,18 @@ class LLMClient:
         timeout: int | None = None,
         **extra: Any,
     ) -> ModelResult:
-        endpoint = _resolve_endpoint(self.runtime, "chat", model_group="text")
-        selected_model = _selected_model(model, endpoint.model)
+        endpoint = _resolve_chat_endpoint(self.runtime, model_group="text", requested_model=model)
+        selected_model = endpoint.model
         body = {
             "model": selected_model,
             "messages": _normalize_messages(messages),
             **_not_none(
                 {
                     "temperature": temperature,
-                    "max_completion_tokens": max_completion_tokens,
+                    "max_completion_tokens": _effective_max_completion_tokens(
+                        max_completion_tokens,
+                        endpoint,
+                    ),
                     **extra,
                 }
             ),
@@ -208,8 +232,8 @@ class LLMClient:
         timeout: int | None = None,
         **extra: Any,
     ) -> Iterator[str]:
-        endpoint = _resolve_endpoint(self.runtime, "chat", model_group="text")
-        selected_model = _selected_model(model, endpoint.model)
+        endpoint = _resolve_chat_endpoint(self.runtime, model_group="text", requested_model=model)
+        selected_model = endpoint.model
         body = {
             "model": selected_model,
             "messages": _normalize_messages(messages),
@@ -217,7 +241,10 @@ class LLMClient:
             **_not_none(
                 {
                     "temperature": temperature,
-                    "max_completion_tokens": max_completion_tokens,
+                    "max_completion_tokens": _effective_max_completion_tokens(
+                        max_completion_tokens,
+                        endpoint,
+                    ),
                     **extra,
                 }
             ),
@@ -453,6 +480,7 @@ def understand_image(**kwargs: Any) -> ModelResult:
 
 def clear_model_catalog_cache_for_tests() -> None:
     _CATALOG_CACHE.clear()
+    _DETAIL_CACHE.clear()
 
 
 def _model_runtime(
@@ -497,6 +525,76 @@ def _fetch_model_catalogs(runtime: ModelRuntime, *, refresh: bool = False) -> li
     return catalogs
 
 
+def _workspace_id(workspace_id: str | None = None) -> str | None:
+    value = workspace_id or env("AGENT_WORKSPACE_ID") or env("LICOS_WORKSPACE_ID")
+    if value is None:
+        return None
+    value = str(value).strip()
+    return value or None
+
+
+def _fetch_model_detail(
+    runtime: ModelRuntime,
+    model_code: str,
+    *,
+    workspace_id: str | None = None,
+    refresh: bool = False,
+) -> dict[str, Any] | None:
+    model_code = str(model_code or "").strip()
+    if not model_code:
+        return None
+    resolved_workspace_id = _workspace_id(workspace_id) or ""
+    cache_key = (runtime.base_url, runtime.token, model_code, resolved_workspace_id)
+    ttl = _int_env("LICOS_MODEL_CATALOG_CACHE_TTL_SECS", DEFAULT_CATALOG_CACHE_TTL_SECS)
+    cached = _DETAIL_CACHE.get(cache_key)
+    if cached and not refresh and time.time() - cached[0] <= ttl:
+        return cached[1]
+
+    query = {"code": model_code}
+    if resolved_workspace_id:
+        query["workspaceId"] = resolved_workspace_id
+    url = f"{runtime.base_url}{MODEL_DETAIL_PATH}?{parse.urlencode(query)}"
+    headers = {"X-Workspace-Id": resolved_workspace_id} if resolved_workspace_id else None
+    try:
+        payload = _request_json(
+            "GET",
+            url,
+            token=runtime.token,
+            headers=headers,
+            timeout=30,
+        )
+    except ApiError as exc:
+        if not refresh and should_refresh_user_token(exc):
+            return _fetch_model_detail(
+                _refresh_model_runtime(runtime),
+                model_code,
+                workspace_id=workspace_id,
+                refresh=True,
+            )
+        raise
+    detail = _model_detail_from_payload(payload)
+    _DETAIL_CACHE[cache_key] = (time.time(), detail)
+    return detail
+
+
+def _model_detail_from_payload(payload: Any) -> dict[str, Any] | None:
+    if not isinstance(payload, dict):
+        raise ApiError("model detail response is not an object", details=payload)
+    code = payload.get("code")
+    if code not in (None, 0) or payload.get("success") is False:
+        raise ApiError(
+            str(payload.get("message") or "model detail API failed"),
+            code=code if isinstance(code, int) else None,
+            details=payload,
+        )
+    data = payload.get("data")
+    if data is None:
+        return None
+    if not isinstance(data, dict):
+        raise ApiError("model detail data is not an object", details=payload)
+    return data
+
+
 def _catalogs_from_payload(payload: Any) -> list[dict[str, Any]]:
     if not isinstance(payload, dict):
         raise ApiError("model catalog response is not an object", details=payload)
@@ -519,6 +617,22 @@ def _catalogs_from_payload(payload: Any) -> list[dict[str, Any]]:
     return [item for item in items if isinstance(item, dict)]
 
 
+def _resolve_chat_endpoint(
+    runtime: ModelRuntime,
+    *,
+    model_group: str,
+    requested_model: str | None = None,
+) -> ModelEndpoint:
+    endpoint = _resolve_endpoint(runtime, "chat", model_group=model_group)
+    selected_model = _selected_model(requested_model, endpoint.model)
+    endpoint = replace(endpoint, model=selected_model)
+    try:
+        detail = _fetch_model_detail(runtime, selected_model)
+    except ApiError:
+        return endpoint
+    return _apply_model_detail(endpoint, detail)
+
+
 def _resolve_endpoint(
     runtime: ModelRuntime,
     capability_key: str,
@@ -555,6 +669,58 @@ def _resolve_endpoint(
     raise ApiError(f"capability `{capability_key}` is not available in model catalog", details=catalogs)
 
 
+def _apply_model_detail(endpoint: ModelEndpoint, detail: dict[str, Any] | None) -> ModelEndpoint:
+    if not detail:
+        return endpoint
+    base_url = _first_non_empty_field(detail, ["baseUrl", "base_url", "url"]) or endpoint.base_url
+    response_url = _first_non_empty_field(
+        detail,
+        ["responseUrl", "response_url", "responsesUrl", "responses_url"],
+    )
+    cache_context = _bool_field(detail, ["cacheContext", "cache_context"])
+    return replace(
+        endpoint,
+        base_url=base_url,
+        response_url=response_url or endpoint.response_url,
+        cache_context=endpoint.cache_context if cache_context is None else cache_context,
+        context_length=_int_field(
+            detail,
+            [
+                "contextLength",
+                "context_length",
+                "contextWindow",
+                "context_window",
+                "maxContextTokens",
+                "max_context_tokens",
+            ],
+        ),
+        max_input_length=_int_field(
+            detail,
+            [
+                "maxInputLength",
+                "max_input_length",
+                "maxInputTokens",
+                "max_input_tokens",
+                "inputTokenLimit",
+                "input_token_limit",
+            ],
+        ),
+        max_output_length=_int_field(
+            detail,
+            [
+                "maxOutputLength",
+                "max_output_length",
+                "maxOutputTokens",
+                "max_output_tokens",
+                "outputTokenLimit",
+                "output_token_limit",
+                "maxCompletionTokens",
+                "max_completion_tokens",
+            ],
+        ),
+    )
+
+
 def _capability_base_url(item: dict[str, Any], capability: dict[str, Any]) -> str | None:
     value = capability.get("baseUrl") or capability.get("base_url")
     if isinstance(value, str) and value.strip():
@@ -609,6 +775,56 @@ def _first_string(value: Any) -> str | None:
     return None
 
 
+def _first_non_empty_field(data: dict[str, Any], names: Sequence[str]) -> str | None:
+    for name in names:
+        value = data.get(name)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def _bool_field(data: dict[str, Any], names: Sequence[str]) -> bool | None:
+    for name in names:
+        value = data.get(name)
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"true", "1", "yes", "y"}:
+                return True
+            if normalized in {"false", "0", "no", "n"}:
+                return False
+    return None
+
+
+def _int_field(data: dict[str, Any], names: Sequence[str]) -> int | None:
+    for name in names:
+        value = data.get(name)
+        if isinstance(value, bool):
+            continue
+        if isinstance(value, int):
+            return value if value > 0 else None
+        if isinstance(value, float):
+            parsed = int(value)
+            return parsed if parsed > 0 else None
+        if isinstance(value, str):
+            try:
+                parsed = int(value.strip())
+            except ValueError:
+                continue
+            return parsed if parsed > 0 else None
+    return None
+
+
+def _effective_max_completion_tokens(requested: int | None, endpoint: ModelEndpoint) -> int | None:
+    limit = endpoint.max_output_length
+    if requested is None:
+        return limit
+    if limit is None:
+        return requested
+    return min(requested, limit)
+
+
 def _post_model_json(
     endpoint: ModelEndpoint,
     runtime: ModelRuntime,

{licos_dev_sdk-0.2.3 → licos_dev_sdk-0.2.5}/tests/test_model.py

@@ -72,6 +72,22 @@ def _catalog_payload() -> dict[str, Any]:
     }
 
 
+def _model_detail_payload(model_code: str = "chat-text") -> dict[str, Any]:
+    return {
+        "code": 0,
+        "success": True,
+        "data": {
+            "code": model_code,
+            "baseUrl": "http://detail.example/v1/chat/completions",
+            "responseUrl": "http://detail.example/v1/responses",
+            "cacheContext": True,
+            "contextLength": 192000,
+            "maxInputLength": 128000,
+            "maxOutputLength": 64000,
+        },
+    }
+
+
 class ModelSdkTests(unittest.TestCase):
     def setUp(self) -> None:
         self.env = mock.patch.dict(
@@ -99,7 +115,10 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url == "http://platform.example/api/v1/llm-gateway/ai/model-catalog":
                 captured["catalog_headers"] = dict(req.header_items())
                 return _FakeResponse(_catalog_payload())
-            if req.full_url == "http://gateway.example/v1/chat/completions":
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                captured["detail_headers"] = dict(req.header_items())
+                return _FakeResponse(_model_detail_payload("chat-text"))
+            if req.full_url == "http://detail.example/v1/chat/completions":
                 captured["chat_headers"] = dict(req.header_items())
                 captured["chat_body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"choices": [{"message": {"content": "hello"}}]})
@@ -112,8 +131,10 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(captured["exchange_headers"]["Authorization"], "Bearer ai-agent-token")
         self.assertEqual(captured["exchange_body"], {"userId": "user-1"})
         self.assertEqual(captured["catalog_headers"]["Authorization"], "Bearer user-token")
+        self.assertEqual(captured["detail_headers"]["Authorization"], "Bearer user-token")
         self.assertEqual(captured["chat_headers"]["Authorization"], "Bearer user-token")
         self.assertEqual(captured["chat_body"]["model"], "chat-text")
+        self.assertEqual(captured["chat_body"]["max_completion_tokens"], 64000)
 
     def test_llm_explicit_model_overrides_catalog_default(self) -> None:
         captured: dict[str, Any] = {}
@@ -123,7 +144,9 @@ class ModelSdkTests(unittest.TestCase):
                 return _FakeResponse({"code": 0, "success": True, "data": {"accessToken": "user-token"}})
             if req.full_url == "http://platform.example/api/v1/llm-gateway/ai/model-catalog":
                 return _FakeResponse(_catalog_payload())
-            if req.full_url == "http://gateway.example/v1/chat/completions":
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload("custom-chat-model"))
+            if req.full_url == "http://detail.example/v1/chat/completions":
                 captured["chat_body"] = json.loads(req.data.decode("utf-8"))
                 return _FakeResponse({"choices": [{"message": {"content": "hello"}}]})
             raise AssertionError(req.full_url)
@@ -145,7 +168,9 @@ class ModelSdkTests(unittest.TestCase):
             if req.full_url == "http://platform.example/api/v1/llm-gateway/ai/model-catalog":
                 catalog_tokens.append(dict(req.header_items())["Authorization"])
                 return _FakeResponse(_catalog_payload())
-            if req.full_url == "http://gateway.example/v1/chat/completions":
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload("chat-text"))
+            if req.full_url == "http://detail.example/v1/chat/completions":
                 chat_tokens.append(dict(req.header_items())["Authorization"])
                 if len(chat_tokens) == 1:
                     raise urlerror.HTTPError(
@@ -165,6 +190,26 @@ class ModelSdkTests(unittest.TestCase):
         self.assertEqual(catalog_tokens, ["Bearer old-token"])
         self.assertEqual(chat_tokens, ["Bearer old-token", "Bearer new-token"])
 
+    def test_resolve_llm_endpoint_applies_model_detail_limits(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 req.full_url == "http://platform.example/api/v1/llm-gateway/ai/model-catalog":
+                return _FakeResponse(_catalog_payload())
+            if req.full_url.startswith("http://platform.example/api/v1/admin/workspaces/models/detail?"):
+                return _FakeResponse(_model_detail_payload())
+            raise AssertionError(req.full_url)
+
+        with mock.patch.object(model.request, "urlopen", fake_urlopen):
+            endpoint = model.resolve_llm_endpoint()
+
+        self.assertEqual(endpoint.base_url, "http://detail.example/v1/chat/completions")
+        self.assertEqual(endpoint.response_url, "http://detail.example/v1/responses")
+        self.assertTrue(endpoint.cache_context)
+        self.assertEqual(endpoint.context_length, 192000)
+        self.assertEqual(endpoint.max_input_length, 128000)
+        self.assertEqual(endpoint.max_output_length, 64000)
+
     def test_image_generation_defaults_to_one_image(self) -> None:
         captured: dict[str, Any] = {}