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

taco/release.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from email import policy
+from email.parser import BytesParser
+from pathlib import Path
+from typing import Iterable
+
+from taco.core.errors import TacoError
+from taco.core.output import failure, success, to_json_line
+
+
+RESOURCE_GROUPS = (
+    "skills",
+    "schemas",
+    "scenarios",
+    "examples",
+    "aikb",
+    "agent_openapi",
+)
+REQUIRED_ASSETS = (
+    "taco/assets/skills/taco/SKILL.md",
+    "taco/assets/skills/taco/manifest.json",
+    "taco/assets/schemas/agent.json",
+    "taco/assets/schemas/agent-tool.json",
+    "taco/assets/schemas/workflow.json",
+    "taco/assets/schemas/workflow.http.json",
+    "taco/assets/scenarios/agent-basic.json",
+    "taco/assets/scenarios/agent-builtin-tool.json",
+    "taco/assets/scenarios/agent-workflow-tool.json",
+    "taco/assets/examples/agent-basic.json",
+    "taco/assets/examples/agent-builtin-tool.json",
+    "taco/assets/examples/agent-workflow-tool.json",
+    "taco/assets/examples/workflow-http.json",
+    "taco/assets/agent_openapi/catalog.json",
+    "taco/assets/agent_openapi/operations/conversation/list-conversations.json",
+    "taco/assets/agent_openapi/operations/message/list-conversation-messages.json",
+    "taco/assets/agent_openapi/operations/trace/list-message-traces.json",
+)
+
+
+def _invalid_runtime_version_error() -> TacoError:
+    return TacoError(
+        code="RELEASE_ASSET_INVALID",
+        message="wheel 内的 runtime __version__ 必须是唯一字符串字面量。",
+        exit_code=7,
+    )
+
+
+def _runtime_version_from_source(source: bytes) -> str:
+    try:
+        module = ast.parse(source.decode("utf-8"), filename="<wheel-runtime>")
+    except (SyntaxError, UnicodeDecodeError):
+        raise _invalid_runtime_version_error() from None
+
+    assignments: list[ast.expr | None] = []
+    for statement in module.body:
+        if isinstance(statement, ast.Assign):
+            for target in statement.targets:
+                if isinstance(target, ast.Name) and target.id == "__version__":
+                    assignments.append(statement.value)
+        elif (
+            isinstance(statement, ast.AnnAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.target.id == "__version__"
+        ):
+            assignments.append(statement.value)
+        elif (
+            isinstance(statement, ast.AugAssign)
+            and isinstance(statement.target, ast.Name)
+            and statement.target.id == "__version__"
+        ):
+            assignments.append(None)
+
+    if len(assignments) != 1:
+        raise _invalid_runtime_version_error()
+    value = assignments[0]
+    if not isinstance(value, ast.Constant) or not isinstance(value.value, str):
+        raise _invalid_runtime_version_error()
+    return value.value
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as file:
+        for chunk in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def verify_wheel_resources(wheel: Path) -> tuple[str, ...]:
+    try:
+        with zipfile.ZipFile(wheel) as archive:
+            archive_names = archive.namelist()
+            names = set(archive_names)
+            metadata_paths = [
+                name
+                for name in archive_names
+                if len(name.split("/")) == 2
+                and name.split("/")[0].endswith(".dist-info")
+                and name.split("/")[1] == "METADATA"
+            ]
+            runtime_paths = [
+                name for name in archive_names if name == "taco/__init__.py"
+            ]
+            manifest_bytes = (
+                archive.read("taco/assets/manifest.json")
+                if "taco/assets/manifest.json" in names
+                else None
+            )
+            skill_manifest_bytes = (
+                archive.read("taco/assets/skills/taco/manifest.json")
+                if "taco/assets/skills/taco/manifest.json" in names
+                else None
+            )
+            metadata_bytes = (
+                archive.read(metadata_paths[0])
+                if len(metadata_paths) == 1
+                else None
+            )
+            runtime_bytes = (
+                archive.read(runtime_paths[0])
+                if len(runtime_paths) == 1
+                else None
+            )
+    except (OSError, zipfile.BadZipFile) as error:
+        raise TacoError(
+            code="RELEASE_ASSET_INVALID",
+            message="wheel 不是可读取的 ZIP 归档。",
+            exit_code=7,
+        ) from error
+
+    if len(runtime_paths) != 1 or runtime_bytes is None:
+        raise _invalid_runtime_version_error()
+    runtime_version = _runtime_version_from_source(runtime_bytes)
+
+    missing: list[str] = []
+    if manifest_bytes is None:
+        missing.append("manifest.json")
+    for group in RESOURCE_GROUPS:
+        prefix = f"taco/assets/{group}/"
+        if not any(name.startswith(prefix) and name != prefix for name in names):
+            missing.append(group)
+    missing.extend(path for path in REQUIRED_ASSETS if path not in names)
+    if missing:
+        raise TacoError(
+            code="RELEASE_ASSET_MISSING",
+            message=f"wheel 缺少资源：{', '.join(missing)}",
+            exit_code=7,
+            hint="请检查 pyproject.toml 的 package data 配置后重新构建。",
+        )
+    if len(metadata_paths) != 1 or metadata_bytes is None:
+        raise TacoError(
+            code="RELEASE_ASSET_INVALID",
+            message="wheel 必须且只能包含一个 *.dist-info/METADATA。",
+            exit_code=7,
+        )
+    try:
+        manifest = json.loads(manifest_bytes)
+        skill_manifest = json.loads(skill_manifest_bytes)
+    except (UnicodeDecodeError, json.JSONDecodeError, TypeError) as error:
+        raise TacoError(
+            code="RELEASE_ASSET_INVALID",
+            message="wheel 内的资源 manifest 不是合法 JSON。",
+            exit_code=7,
+        ) from error
+    resource_groups = (
+        manifest.get("resource_groups") if isinstance(manifest, dict) else None
+    )
+    if (
+        not isinstance(manifest, dict)
+        or manifest.get("format_version") != 1
+        or not isinstance(resource_groups, list)
+        or not all(isinstance(group, str) for group in resource_groups)
+        or set(resource_groups) != set(RESOURCE_GROUPS)
+    ):
+        raise TacoError(
+            code="RELEASE_ASSET_INVALID",
+            message="wheel 内的资源 manifest 结构不合法。",
+            exit_code=7,
+        )
+    metadata = BytesParser(policy=policy.default).parsebytes(metadata_bytes)
+    metadata_versions = metadata.get_all("Version", [])
+    versions = [
+        runtime_version,
+        metadata_versions[0] if len(metadata_versions) == 1 else None,
+        manifest.get("cli_version"),
+        skill_manifest.get("cli_version")
+        if isinstance(skill_manifest, dict)
+        else None,
+    ]
+    if (
+        not all(isinstance(version, str) and version.strip() for version in versions)
+        or len(set(versions)) != 1
+    ):
+        raise TacoError(
+            code="RELEASE_ASSET_INVALID",
+            message="wheel runtime、METADATA 与资源 manifest 的版本必须非空且完全一致。",
+            exit_code=7,
+        )
+    return tuple(sorted(RESOURCE_GROUPS))
+
+
+def write_checksum_file(artifacts: Iterable[Path], output: Path) -> Path:
+    lines = [
+        f"{sha256_file(path)}  {path.name}"
+        for path in sorted(artifacts, key=lambda item: item.name)
+    ]
+    output.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return output
+
+
+def build_release(dist_dir: Path, *, upload: bool = False) -> dict[str, object]:
+    try:
+        return _build_release(dist_dir, upload=upload)
+    except OSError as error:
+        raise TacoError(
+            code="RELEASE_IO_FAILED",
+            message="无法读写发布目录或产物。",
+            exit_code=7,
+            hint=f"请检查目录权限和磁盘空间：{dist_dir}",
+        ) from error
+
+
+def _build_release(dist_dir: Path, *, upload: bool = False) -> dict[str, object]:
+    dist_dir.mkdir(parents=True, exist_ok=True)
+    safe_env = _environment_without_twine_credentials()
+    upload_env = _upload_environment() if upload else None
+    repository_url = os.getenv("TACO_PYPI_REPOSITORY_URL") if upload else None
+    with tempfile.TemporaryDirectory(prefix=".taco-build-", dir=dist_dir) as staging:
+        staging_dir = Path(staging)
+        _run(
+            [sys.executable, "-m", "build", "--outdir", str(staging_dir)],
+            env=safe_env,
+        )
+
+        staged_artifacts = sorted(
+            [
+                *staging_dir.glob("*.whl"),
+                *staging_dir.glob("*.tar.gz"),
+            ],
+            key=lambda path: path.name,
+        )
+        wheels = [path for path in staged_artifacts if path.suffix == ".whl"]
+        sdists = [path for path in staged_artifacts if path.name.endswith(".tar.gz")]
+        if not wheels or not sdists:
+            raise TacoError(
+                code="RELEASE_ARTIFACT_MISSING",
+                message="构建必须同时生成 wheel 和 sdist 产物。",
+                exit_code=7,
+            )
+        for wheel in wheels:
+            verify_wheel_resources(wheel)
+
+        _run(
+            [sys.executable, "-m", "twine", "check", *map(str, staged_artifacts)],
+            env=safe_env,
+        )
+        artifacts: list[Path] = []
+        for artifact in staged_artifacts:
+            destination = dist_dir / artifact.name
+            shutil.copy2(artifact, destination)
+            artifacts.append(destination)
+
+    checksum_file = write_checksum_file(artifacts, dist_dir / "SHA256SUMS")
+
+    if upload:
+        _run(
+            [
+                sys.executable,
+                "-m",
+                "twine",
+                "upload",
+                "--non-interactive",
+                "--repository-url",
+                str(repository_url),
+                *map(str, artifacts),
+            ],
+            env=upload_env,
+        )
+
+    return {
+        "artifacts": [str(path) for path in artifacts],
+        "checksum_file": str(checksum_file),
+        "uploaded": upload,
+    }
+
+
+def _environment_without_twine_credentials() -> dict[str, str]:
+    env = dict(os.environ)
+    env.pop("TWINE_USERNAME", None)
+    env.pop("TWINE_PASSWORD", None)
+    return env
+
+
+def _upload_environment() -> dict[str, str]:
+    repository_url = os.getenv("TACO_PYPI_REPOSITORY_URL")
+    username = os.getenv("TWINE_USERNAME")
+    password = os.getenv("TWINE_PASSWORD")
+    if not repository_url:
+        raise TacoError(
+            code="RELEASE_REPOSITORY_REQUIRED",
+            message="上传前必须设置 TACO_PYPI_REPOSITORY_URL。",
+            exit_code=2,
+        )
+    if not username or not password:
+        raise TacoError(
+            code="RELEASE_CREDENTIALS_REQUIRED",
+            message="非交互上传必须设置 TWINE_USERNAME 和 TWINE_PASSWORD。",
+            exit_code=2,
+        )
+    env = _environment_without_twine_credentials()
+    env.update(
+        {
+            "TWINE_USERNAME": username,
+            "TWINE_PASSWORD": password,
+            "TWINE_NON_INTERACTIVE": "1",
+        }
+    )
+    return env
+
+
+def _run(command: list[str], *, env: dict[str, str] | None = None) -> None:
+    completed = subprocess.run(
+        command,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    if completed.returncode != 0:
+        raise TacoError(
+            code="RELEASE_COMMAND_FAILED",
+            message=f"发布命令执行失败，退出码 {completed.returncode}。",
+            exit_code=7,
+            hint="请在本地直接运行对应的 build/twine 命令查看详细日志。",
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="构建并校验 TACO 内部发布产物")
+    parser.add_argument("--dist-dir", type=Path, default=Path("dist"))
+    parser.add_argument("--upload", action="store_true")
+    args = parser.parse_args()
+    try:
+        result = build_release(args.dist_dir, upload=args.upload)
+    except TacoError as error:
+        print(to_json_line(failure(error)), file=sys.stderr)
+        raise SystemExit(error.exit_code) from error
+    print(to_json_line(success(result)))
+
+
+if __name__ == "__main__":
+    main()

taco/services/__init__.py

@@ -0,0 +1 @@
+"""Business services for TACO."""

taco/services/agent_service.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from jsonschema import Draft202012Validator
+
+from taco.core.api_client import ApiClient
+from taco.core.assets import load_json_asset
+from taco.core.errors import TacoError
+from taco.services.category_service import CategoryService
+
+
+class AgentService:
+    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 create_agent(
+        self,
+        *,
+        name: str,
+        category: str,
+        description: str = "",
+        profile: str | None = None,
+    ) -> dict[str, Any]:
+        self.category_service.get_category(category, profile=profile)
+        app = self.api_client.post(
+            "/apps",
+            json={
+                "name": name,
+                "description": description,
+                "mode": "agent-chat",
+                "t_category_code": category,
+                "icon_type": "emoji",
+                "icon": "🤖",
+                "icon_background": "#FFEAD5",
+            },
+            profile=profile,
+        )
+        if not isinstance(app, dict):
+            raise _missing_model_config_error()
+        if not isinstance(app.get("model_config"), dict):
+            app = self.api_client.get(f"/apps/{app.get('id', '')}", profile=profile)
+        if not isinstance(app, dict) or not isinstance(
+            app.get("model_config"),
+            dict,
+        ):
+            raise _missing_model_config_error()
+        return app
+
+    def pull_agent_config(self, app_id: str, *, profile: str | None = None) -> Any:
+        app_detail = self.api_client.get(f"/apps/{app_id}", profile=profile)
+        if not isinstance(app_detail, dict):
+            raise _missing_model_config_error()
+
+        model_config = app_detail.get("model_config")
+        if not isinstance(model_config, dict):
+            raise _missing_model_config_error()
+
+        return model_config
+
+    def run_agent(
+        self,
+        app_id: str,
+        *,
+        model_config: dict[str, Any],
+        query: str,
+        inputs: dict[str, Any] | None = None,
+        conversation_id: str | None = None,
+        parent_message_id: str | None = None,
+        files: list[dict[str, Any]] | None = None,
+        on_event: Callable[[dict[str, Any]], None] | None = None,
+        profile: str | None = None,
+    ) -> Any:
+        events: list[dict[str, Any]] = []
+        result: dict[str, Any] = {"answer": ""}
+        completed = False
+        request_payload: dict[str, Any] = {
+            "inputs": inputs or {},
+            "query": query,
+            "model_config": model_config,
+            "response_mode": "streaming",
+            "retriever_from": "dev",
+        }
+        if conversation_id is not None:
+            request_payload["conversation_id"] = conversation_id
+        if parent_message_id is not None:
+            request_payload["parent_message_id"] = parent_message_id
+        if files is not None:
+            request_payload["files"] = files
+
+        stream = self.api_client.stream(
+            "POST",
+            f"/apps/{app_id}/chat-messages",
+            json=request_payload,
+            profile=profile,
+        )
+        try:
+            for sse_event in stream:
+                if isinstance(sse_event.data, dict):
+                    event = dict(sse_event.data)
+                else:
+                    event = {"data": sse_event.data}
+                if sse_event.event and "event" not in event:
+                    event["event"] = sse_event.event
+                if sse_event.id is not None:
+                    event["sse_id"] = sse_event.id
+                events.append(event)
+
+                if event.get("event") == "error":
+                    raise TacoError(
+                        code="AGENT_RUN_FAILED",
+                        message=str(
+                            event.get("message") or "Agent 调试流返回错误。"
+                        ),
+                        exit_code=5,
+                        hint="请检查本地 DSL、模型配置和输入参数。",
+                    )
+                if on_event is not None:
+                    on_event(event)
+                answer = event.get("answer")
+                if isinstance(answer, str):
+                    if event.get("event") == "message_replace":
+                        result["answer"] = answer
+                    else:
+                        result["answer"] += answer
+                for key in ("conversation_id", "message_id", "task_id"):
+                    if event.get(key):
+                        result[key] = event[key]
+                if isinstance(event.get("metadata"), dict):
+                    result["metadata"] = event["metadata"]
+                if event.get("event") == "message_end":
+                    completed = True
+                    break
+        finally:
+            close = getattr(stream, "close", None)
+            if callable(close):
+                close()
+
+        if not completed:
+            raise TacoError(
+                code="AGENT_RUN_INCOMPLETE",
+                message="Agent 调试流在 message_end 前结束。",
+                exit_code=5,
+                hint="请检查网络和服务端日志后重试。",
+            )
+        result["events"] = events
+        return result
+
+    def stop_agent(
+        self,
+        app_id: str,
+        *,
+        task_id: str,
+        profile: str | None = None,
+    ) -> Any:
+        return self.api_client.post(
+            f"/apps/{app_id}/chat-messages/{task_id}/stop",
+            profile=profile,
+        )
+
+    def publish_agent(
+        self,
+        app_id: str,
+        *,
+        model_config: dict[str, Any],
+        profile: str | None = None,
+    ) -> Any:
+        return self.api_client.post(
+            f"/apps/{app_id}/model-config",
+            json=model_config,
+            profile=profile,
+        )
+
+
+def _missing_model_config_error() -> TacoError:
+    return TacoError(
+        code="AGENT_MODEL_CONFIG_MISSING",
+        message="应用详情中缺少 model_config。",
+        exit_code=6,
+        hint="请确认应用是支持 model_config 的 Agent 类型智能体。",
+    )
+
+
+def validate_agent_config(model_config: dict[str, Any]) -> dict[str, Any]:
+    validator = Draft202012Validator(load_json_asset("schemas", "agent"))
+    errors: list[str] = []
+    for error in sorted(
+        validator.iter_errors(model_config),
+        key=lambda item: tuple(str(part) for part in item.path),
+    ):
+        path = _json_path(list(error.absolute_path))
+        if error.validator == "required" and isinstance(error.instance, dict):
+            missing = [
+                field
+                for field in error.validator_value
+                if field not in error.instance
+            ]
+            errors.extend(
+                f"{path + '.' if path else ''}{field} 为必填项"
+                for field in missing
+            )
+        elif error.validator == "enum":
+            allowed = "、".join(
+                str(value) for value in error.validator_value if value is not None
+            )
+            errors.append(f"{path or '$'} 必须是以下值之一：{allowed}")
+        elif error.validator == "const":
+            errors.append(f"{path or '$'} 必须等于 {error.validator_value}")
+        else:
+            errors.append(f"{path or '$'}：{error.message}")
+    if errors:
+        raise _validation_error(errors)
+    return {"valid": True, "errors": []}
+
+
+def validate_completion_params(
+    completion_params: dict[str, Any],
+    parameter_rules: list[dict[str, Any]],
+) -> None:
+    errors: list[str] = []
+    if "stop" in completion_params:
+        stop = completion_params["stop"]
+        if (
+            not isinstance(stop, list)
+            or not all(isinstance(item, str) for item in stop)
+            or len(stop) > 4
+        ):
+            errors.append(
+                "model.completion_params.stop 必须是最多包含 4 个字符串的数组"
+            )
+    provider_params = {
+        name: value
+        for name, value in completion_params.items()
+        if name != "stop"
+    }
+    if not parameter_rules:
+        if errors:
+            raise _validation_error(errors)
+        return
+    rules = {
+        rule.get("name"): rule
+        for rule in parameter_rules
+        if isinstance(rule, dict) and isinstance(rule.get("name"), str)
+    }
+    for name, value in provider_params.items():
+        rule = rules.get(name)
+        path = f"model.completion_params.{name}"
+        if rule is None:
+            errors.append(f"{path} 不是该模型支持的参数")
+            continue
+        expected = rule.get("type")
+        if not _matches_parameter_type(value, expected):
+            errors.append(f"{path} 类型应为 {expected}")
+            continue
+        minimum = rule.get("min")
+        maximum = rule.get("max")
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            if isinstance(minimum, (int, float)) and value < minimum:
+                errors.append(f"{path} 不能小于 {minimum}")
+            if isinstance(maximum, (int, float)) and value > maximum:
+                errors.append(f"{path} 不能大于 {maximum}")
+        options = rule.get("options")
+        if isinstance(options, list) and options:
+            allowed = [
+                option.get("value") if isinstance(option, dict) else option
+                for option in options
+            ]
+            if value not in allowed:
+                errors.append(f"{path} 不在允许选项中")
+    if errors:
+        raise _validation_error(errors)
+
+
+def _matches_parameter_type(value: Any, expected: Any) -> bool:
+    if expected in {"string", "text"}:
+        return isinstance(value, str)
+    if expected in {"int", "integer"}:
+        return isinstance(value, int) and not isinstance(value, bool)
+    if expected in {"float", "number"}:
+        return isinstance(value, (int, float)) and not isinstance(value, bool)
+    if expected in {"bool", "boolean"}:
+        return isinstance(value, bool)
+    if expected in {"array", "list"}:
+        return isinstance(value, list)
+    if expected in {"object", "dict"}:
+        return isinstance(value, dict)
+    return True
+
+
+def _json_path(parts: list[Any]) -> str:
+    path = ""
+    for part in parts:
+        if isinstance(part, int):
+            path += f"[{part}]"
+        else:
+            path += f".{part}" if path else str(part)
+    return path
+
+
+def _validation_error(errors: list[str]) -> TacoError:
+    return TacoError(
+        code="AGENT_DSL_VALIDATION_FAILED",
+        message="Agent DSL 校验失败：" + "；".join(errors),
+        exit_code=6,
+        hint="请执行 taco schema agent -o json 后修正本地 DSL。",
+    )