tinet-agent-cli 0.1.0.dev36__py3-none-any.whl

taco/services/app_service.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from typing import Any
+from uuid import UUID
+
+from taco.core.api_client import ApiClient
+from taco.core.errors import TacoError
+
+
+_FINAL_IMPORT_STATUSES = {"completed", "completed-with-warnings"}
+
+
+class AppService:
+    def __init__(self, api_client: ApiClient | None = None) -> None:
+        self.api_client = api_client or ApiClient()
+
+    def list_apps(
+        self,
+        *,
+        page: int = 1,
+        limit: int = 20,
+        name: str | None = None,
+        mode: str | None = None,
+        tag_ids: list[str] | None = None,
+        profile: str | None = None,
+    ) -> Any:
+        params: dict[str, Any] = {"page": page, "limit": limit, "compact": True}
+        if name:
+            params["name"] = name
+        if mode:
+            params["mode"] = mode
+        normalized_tag_ids = _normalize_tag_ids(tag_ids)
+        if normalized_tag_ids:
+            params["tag_ids"] = ",".join(normalized_tag_ids)
+        return self.api_client.get(
+            "/apps",
+            params=params,
+            profile=profile,
+        )
+
+    def list_tags(
+        self,
+        *,
+        keyword: str | None = None,
+        profile: str | None = None,
+    ) -> Any:
+        params = {"type": "app"}
+        if keyword:
+            params["keyword"] = keyword
+        return self.api_client.get(
+            "/tags",
+            params=params,
+            profile=profile,
+        )
+
+    def get_app(self, app_id: str, *, profile: str | None = None) -> Any:
+        return self.api_client.get(
+            f"/apps/{app_id}",
+            profile=profile,
+        )
+
+    def create_app(
+        self,
+        *,
+        name: str,
+        mode: str,
+        profile: str | None = None,
+    ) -> Any:
+        return self.api_client.post(
+            "/apps",
+            json={"name": name, "mode": mode},
+            profile=profile,
+        )
+
+    def list_templates(
+        self,
+        *,
+        language: str | None = None,
+        profile: str | None = None,
+    ) -> Any:
+        params = {"language": language} if language else None
+        return self.api_client.get(
+            "/explore/apps",
+            params=params,
+            profile=profile,
+        )
+
+    def create_app_from_template(
+        self,
+        template_app_id: str,
+        *,
+        name: str | None = None,
+        profile: str | None = None,
+    ) -> Any:
+        detail = self.api_client.get(
+            f"/explore/apps/{template_app_id}",
+            profile=profile,
+        )
+        export_data = detail.get("export_data") if isinstance(detail, dict) else None
+        if not isinstance(export_data, str) or not export_data.strip():
+            raise TacoError(
+                code="APP_TEMPLATE_DETAIL_INVALID",
+                message="应用模板详情缺少有效 export_data。",
+                exit_code=4,
+                hint="请重新获取模板列表并确认模板应用 ID。",
+            )
+
+        payload = {"mode": "yaml-content", "yaml_content": export_data}
+        if name:
+            payload["name"] = name
+        result = self.api_client.post(
+            "/apps/imports",
+            json=payload,
+            profile=profile,
+        )
+        status = result.get("status") if isinstance(result, dict) else None
+        if status == "pending":
+            import_id = result.get("id")
+            if not isinstance(import_id, str) or not import_id.strip():
+                raise _invalid_template_import_response()
+            result = self.api_client.post(
+                f"/apps/imports/{import_id}/confirm",
+                profile=profile,
+            )
+            status = result.get("status") if isinstance(result, dict) else None
+
+        if status not in _FINAL_IMPORT_STATUSES:
+            raise _invalid_template_import_response()
+        return result
+
+
+def _normalize_tag_ids(tag_ids: list[str] | None) -> list[str]:
+    normalized = []
+    for tag_id in tag_ids or []:
+        try:
+            normalized.append(str(UUID(tag_id.strip())))
+        except (AttributeError, ValueError):
+            raise TacoError(
+                code="APP_LIST_TAG_ID_INVALID",
+                message=f"标签 ID 不是有效的 UUID：{tag_id}",
+                exit_code=2,
+                hint="请通过 --tag-id 传入有效的标签 UUID。",
+            ) from None
+    return normalized
+
+
+def _invalid_template_import_response() -> TacoError:
+    return TacoError(
+        code="APP_TEMPLATE_IMPORT_RESPONSE_INVALID",
+        message="应用模板导入响应缺少有效的完成状态。",
+        exit_code=4,
+        hint="请检查模板兼容性和 Console API 响应。",
+    )

taco/services/category_service.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any
+
+from taco.core.api_client import ApiClient
+from taco.core.errors import TacoError
+
+
+class CategoryService:
+    def __init__(self, api_client: ApiClient | None = None) -> None:
+        self.api_client = api_client or ApiClient()
+
+    def list_categories(self, *, profile: str | None = None) -> list[dict[str, Any]]:
+        payload = self.api_client.get("/tinet/app/categories", profile=profile)
+        if not isinstance(payload, list) or any(
+            not isinstance(item, dict) for item in payload
+        ):
+            raise TacoError(
+                code="CATEGORY_RESPONSE_INVALID",
+                message="分类接口返回结构不合法。",
+                exit_code=4,
+            )
+        return payload
+
+    def get_category(
+        self,
+        code: str,
+        *,
+        profile: str | None = None,
+    ) -> dict[str, Any]:
+        category = _find_category(self.list_categories(profile=profile), code)
+        if category is None:
+            raise TacoError(
+                code="CATEGORY_NOT_FOUND",
+                message=f"未找到智能体分类：{code}",
+                exit_code=6,
+                hint="请先执行 taco category list，不要猜测分类 code。",
+            )
+        return category
+
+
+def _find_category(
+    categories: list[dict[str, Any]],
+    code: str,
+) -> dict[str, Any] | None:
+    for category in categories:
+        if category.get("code") == code:
+            return category
+        children = category.get("children")
+        if isinstance(children, list):
+            child = _find_category(
+                [item for item in children if isinstance(item, dict)],
+                code,
+            )
+            if child is not None:
+                return child
+    return None

taco/services/model_service.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from taco.core.api_client import ApiClient
+from taco.core.errors import TacoError
+from taco.services.category_service import CategoryService
+
+
+class ModelService:
+    def __init__(
+        self,
+        api_client: ApiClient | None = None,
+        *,
+        category_service: CategoryService | None = None,
+    ) -> None:
+        self.api_client = api_client or ApiClient()
+        self.category_service = category_service or CategoryService(
+            api_client=self.api_client
+        )
+
+    def list_models(
+        self,
+        *,
+        category: str | None = None,
+        profile: str | None = None,
+    ) -> dict[str, Any]:
+        if category is not None:
+            self.category_service.get_category(category, profile=profile)
+        payload = self.api_client.get(
+            "/workspaces/current/models/model-types/llm",
+            profile=profile,
+        )
+        providers = payload.get("data") if isinstance(payload, dict) else None
+        if not isinstance(providers, list):
+            raise _invalid_model_response()
+
+        items: list[dict[str, Any]] = []
+        for provider in providers:
+            if not isinstance(provider, dict):
+                raise _invalid_model_response()
+            provider_id = provider.get("provider")
+            models = provider.get("models")
+            if not isinstance(provider_id, str) or not isinstance(models, list):
+                continue
+            for model in models:
+                if not isinstance(model, dict) or not isinstance(
+                    model.get("model"),
+                    str,
+                ):
+                    continue
+                categories = model.get("t_categories")
+                if (
+                    category
+                    and isinstance(categories, list)
+                    and category not in categories
+                ):
+                    continue
+                items.append(
+                    {
+                        **model,
+                        "provider": provider_id,
+                        "provider_label": provider.get("label"),
+                    }
+                )
+        return {"category": category, "items": items}
+
+    def describe_model(
+        self,
+        *,
+        provider: str,
+        model: str,
+        category: str | None = None,
+        profile: str | None = None,
+    ) -> dict[str, Any]:
+        models = self.list_models(category=category, profile=profile)["items"]
+        item = next(
+            (
+                candidate
+                for candidate in models
+                if candidate.get("provider") == provider
+                and candidate.get("model") == model
+            ),
+            None,
+        )
+        if item is None:
+            raise TacoError(
+                code="MODEL_NOT_FOUND",
+                message=f"未找到分类可用模型：{provider}/{model}",
+                exit_code=6,
+                hint="请先执行 taco model list --category <code>。",
+            )
+        rules_payload = self.api_client.get(
+            (
+                "/workspaces/current/model-providers/"
+                f"{quote(provider, safe='')}/models/parameter-rules"
+            ),
+            params={"model": model},
+            profile=profile,
+        )
+        rules = (
+            rules_payload.get("data")
+            if isinstance(rules_payload, dict)
+            else None
+        )
+        if not isinstance(rules, list):
+            raise _invalid_model_response()
+        return {**item, "parameter_rules": rules}
+
+
+def _invalid_model_response() -> TacoError:
+    return TacoError(
+        code="MODEL_RESPONSE_INVALID",
+        message="模型接口返回结构不合法。",
+        exit_code=4,
+    )