agentengine-sdk-python 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

ksadk/conversations/semantic_summary.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Mapping, Sequence
+
+import httpx
+
+from ksadk.configs.settings import settings
+from ksadk.conversations.compaction_prompt import (
+    build_compaction_prompt_messages,
+    extract_summary_text,
+)
+from ksadk.conversations.context import canonical_event_type, extract_event_text, summarize_event_groups
+from ksadk.sessions.base import SessionEvent
+
+SUMMARY_VERSION = "v1"
+DEFAULT_COMPACTION_SUMMARY_TIMEOUT_MS = 45_000
+DEFAULT_COMPACTION_SUMMARY_MAX_GROUPS = 12
+SUMMARY_PREFIX = "Earlier conversation summary:"
+
+# L4 semantic 熔断:独立计数 semantic LLM 调用失败(不复用 governance compact failure counter,
+# 因为 summarize_compaction 捕获异常后返回 extractive,外层看是成功,governance 不触发)。
+# 超过阈值后直接走 extractive,避免 Claude Code 的"1279 会话连续失败 50+ 次"浪费。
+# 已知局限(有意取舍,对齐 Claude Code 行为):
+# - 默认 0(opt-in),避免 transient 失败永久禁用 semantic;用户显式设 N>0 才启用。
+# - 打开后无 half-open 探测,需进程重启或显式 _reset_semantic_failures 恢复(CC 同样如此)。
+# - 计数为模块级全局,跨 session/model 共享;per-model key 化留作 follow-up(对齐 governance per-session 范式)。
+_semantic_summary_failures: int = 0
+
+
+def _max_consecutive_semantic_failures() -> int:
+    raw = os.environ.get("KSADK_MAX_CONSECUTIVE_SEMANTIC_FAILURES", "0")
+    try:
+        return max(0, int(raw))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _semantic_circuit_open() -> bool:
+    """semantic 熔断是否打开(超阈值则跳过 LLM 直接走 extractive)。0 = 禁用熔断。"""
+    threshold = _max_consecutive_semantic_failures()
+    if threshold <= 0:
+        return False
+    return _semantic_summary_failures >= threshold
+
+
+def _record_semantic_failure() -> None:
+    global _semantic_summary_failures
+    _semantic_summary_failures += 1
+
+
+def _reset_semantic_failures() -> None:
+    global _semantic_summary_failures
+    _semantic_summary_failures = 0
+
+
+@dataclass
+class CompactionSummaryResult:
+    """一次 checkpoint 摘要的标准结果。"""
+
+    summary_text: str
+    summary_strategy: str
+    summary_version: str = SUMMARY_VERSION
+    summary_model: str = ""
+    summary_usage: dict[str, Any] = field(default_factory=dict)
+    fallback_reason: str | None = None
+
+
+class SummaryModelClient:
+    """独立的摘要模型客户端。
+
+    注意这里故意不复用 agent runner：
+    - runner 的职责是执行用户 agent；
+    - 摘要器的职责是平台内部的 context compaction。
+    两者拆开后，失败隔离和后续替换模型都会更清晰。
+    """
+
+    def __init__(
+        self,
+        *,
+        api_base: str | None = None,
+        api_key: str | None = None,
+    ):
+        self.api_base = str(api_base or settings.model.api_base or "").rstrip("/")
+        self.api_key = str(api_key or settings.model.api_key or "").strip()
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_base and self.api_key)
+
+    def _chat_completions_url(self) -> str:
+        if self.api_base.endswith("/v1"):
+            return f"{self.api_base}/chat/completions"
+        return f"{self.api_base}/v1/chat/completions"
+
+    async def summarize(
+        self,
+        *,
+        model: str,
+        messages: Sequence[dict[str, str]],
+        timeout_ms: int,
+    ) -> tuple[str, dict[str, Any]]:
+        if not self.is_available:
+            raise RuntimeError("summary model client is not configured")
+        if not model:
+            raise RuntimeError("summary model is not configured")
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        payload = {
+            "model": model,
+            "messages": list(messages),
+            "stream": False,
+            "temperature": 0,
+        }
+        timeout_seconds = max(1.0, float(timeout_ms) / 1000.0)
+        async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+            response = await client.post(self._chat_completions_url(), headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+        choices = data.get("choices") or []
+        message = choices[0].get("message") if choices else {}
+        content = message.get("content") if isinstance(message, Mapping) else ""
+        if isinstance(content, list):
+            fragments: list[str] = []
+            for item in content:
+                if isinstance(item, Mapping) and item.get("text"):
+                    fragments.append(str(item["text"]))
+            content = "\n".join(fragment for fragment in fragments if fragment)
+        text = str(content or "").strip()
+        if not text:
+            raise RuntimeError("summary model returned empty content")
+        return text, dict(data.get("usage") or {})
+
+
+def resolve_summary_model_client() -> SummaryModelClient:
+    return SummaryModelClient()
+
+
+def _ensure_summary_prefix(summary_text: str) -> str:
+    text = str(summary_text or "").strip()
+    if not text or text.startswith(SUMMARY_PREFIX):
+        return text
+    return f"{SUMMARY_PREFIX}\n{text}"
+
+
+def _env_truthy(name: str) -> bool:
+    value = str(os.getenv(name, "")).strip().lower()
+    return value in {"1", "true", "yes", "on"}
+
+
+def semantic_compaction_disabled() -> bool:
+    return _env_truthy("COMPACTION_DISABLE_SEMANTIC")
+
+
+def get_summary_timeout_ms() -> int:
+    raw = os.getenv("COMPACTION_SUMMARY_TIMEOUT_MS", "").strip()
+    try:
+        return max(1_000, int(raw))
+    except (TypeError, ValueError):
+        return DEFAULT_COMPACTION_SUMMARY_TIMEOUT_MS
+
+
+def get_summary_max_groups() -> int:
+    raw = os.getenv("COMPACTION_SUMMARY_MAX_GROUPS", "").strip()
+    try:
+        return max(1, int(raw))
+    except (TypeError, ValueError):
+        return DEFAULT_COMPACTION_SUMMARY_MAX_GROUPS
+
+
+def resolve_summary_model(current_model: str | None) -> str:
+    override = str(os.getenv("COMPACTION_SUMMARY_MODEL", "")).strip()
+    if override:
+        return override
+    if current_model:
+        return str(current_model)
+    return str(settings.model.model_name or "")
+
+
+def find_pinned_group_indexes(groups: Sequence[Sequence[SessionEvent]]) -> set[int]:
+    """找出不能被 compact 的轮次。
+
+    当前先严格保护两类未完成状态：
+    1. approval_request 尚未收到 approval_response
+    2. tool_call 尚未看到 tool_result
+    """
+
+    pending_approval_groups: list[int] = []
+    pending_tool_groups: list[int] = []
+    for index, group in enumerate(groups):
+        for event in group:
+            event_type = canonical_event_type(
+                event.event_type,
+                author=event.author,
+                role=str((event.content or {}).get("role") or ""),
+            )
+            if event_type == "approval_request":
+                pending_approval_groups.append(index)
+                continue
+            if event_type == "approval_response" and pending_approval_groups:
+                pending_approval_groups.pop()
+                continue
+            if event_type == "tool_call":
+                pending_tool_groups.append(index)
+                continue
+            if event_type == "tool_result" and pending_tool_groups:
+                pending_tool_groups.pop()
+    return set(pending_approval_groups + pending_tool_groups)
+
+
+def extract_pinned_state(groups: Sequence[Sequence[SessionEvent]]) -> dict[str, Any]:
+    """提取必须在 checkpoint 里显式保留的状态。"""
+
+    pending_approvals: list[str] = []
+    pending_tools: list[str] = []
+    attachment_refs: list[str] = []
+    current_user_goal = ""
+
+    for group in groups:
+        for event in group:
+            event_type = canonical_event_type(
+                event.event_type,
+                author=event.author,
+                role=str((event.content or {}).get("role") or ""),
+            )
+            text = extract_event_text(event)
+            if event_type == "approval_request" and text:
+                pending_approvals.append(text)
+            elif event_type == "approval_response" and pending_approvals:
+                pending_approvals.pop()
+            elif event_type == "tool_call" and text:
+                pending_tools.append(text)
+            elif event_type == "tool_result" and pending_tools:
+                pending_tools.pop()
+            elif event_type == "attachment_ref":
+                attachment_refs.append(text)
+            elif event_type == "user_message" and text:
+                current_user_goal = text
+                for attachment in (event.metadata or {}).get("attachments") or []:
+                    if not isinstance(attachment, Mapping):
+                        continue
+                    label = str(
+                        attachment.get("display_name")
+                        or attachment.get("file_uri")
+                        or attachment.get("storage_path")
+                        or ""
+                    ).strip()
+                    if label:
+                        attachment_refs.append(label)
+
+    unique_attachments: list[str] = []
+    for item in attachment_refs:
+        normalized = str(item or "").strip()
+        if normalized and normalized not in unique_attachments:
+            unique_attachments.append(normalized)
+
+    return {
+        "pending_approvals": pending_approvals,
+        "pending_tools": pending_tools,
+        "attachment_refs": unique_attachments[-5:],
+        "current_user_goal": current_user_goal,
+    }
+
+
+def _build_semantic_input(
+    *,
+    previous_summary: str,
+    groups_to_compact: Sequence[Sequence[SessionEvent]],
+    pinned_state: Mapping[str, Any],
+    model_metadata: Mapping[str, Any] | None,
+) -> tuple[str, list[list[SessionEvent]]]:
+    max_groups = get_summary_max_groups()
+    selected_groups = [list(group) for group in groups_to_compact]
+    merged_previous_summary = previous_summary.strip()
+    if len(selected_groups) > max_groups:
+        skipped_groups = selected_groups[:-max_groups]
+        selected_groups = selected_groups[-max_groups:]
+        skipped_summary = summarize_event_groups(skipped_groups, previous_summary=merged_previous_summary)
+        merged_previous_summary = skipped_summary
+    return merged_previous_summary, selected_groups
+
+
+async def summarize_compaction(
+    *,
+    groups_to_compact: Sequence[Sequence[SessionEvent]],
+    previous_summary: str,
+    pinned_state: Mapping[str, Any],
+    model_metadata: Mapping[str, Any] | None,
+    model: str | None,
+) -> CompactionSummaryResult:
+    """语义摘要优先，失败后自动回退到 extractive。"""
+
+    fallback_summary = summarize_event_groups(list(groups_to_compact), previous_summary=previous_summary)
+    if semantic_compaction_disabled():
+        return CompactionSummaryResult(
+            summary_text=fallback_summary,
+            summary_strategy="extractive",
+            fallback_reason="semantic summarizer disabled",
+        )
+
+    # L4 semantic 熔断:连续失败超阈值则跳过 LLM 直接走 extractive,直到进程重启或显式 reset。
+    if _semantic_circuit_open():
+        return CompactionSummaryResult(
+            summary_text=fallback_summary,
+            summary_strategy="extractive",
+            fallback_reason="semantic_circuit_open",
+        )
+
+    summary_model = resolve_summary_model(model)
+    client = resolve_summary_model_client()
+    if not client.is_available:
+        return CompactionSummaryResult(
+            summary_text=fallback_summary,
+            summary_strategy="extractive",
+            fallback_reason="summary model client is not configured",
+        )
+
+    try:
+        merged_previous_summary, selected_groups = _build_semantic_input(
+            previous_summary=previous_summary,
+            groups_to_compact=groups_to_compact,
+            pinned_state=pinned_state,
+            model_metadata=model_metadata,
+        )
+        prompt_messages = build_compaction_prompt_messages(
+            previous_summary=merged_previous_summary,
+            groups_to_compact=selected_groups,
+            pinned_state=pinned_state,
+            model_metadata=model_metadata,
+        )
+        raw_text, usage = await client.summarize(
+            model=summary_model,
+            messages=prompt_messages,
+            timeout_ms=get_summary_timeout_ms(),
+        )
+        summary_text = extract_summary_text(raw_text)
+        if not summary_text:
+            raise RuntimeError("summary model returned empty <summary> block")
+        # LLM 调用成功,清零 semantic 失败计数。
+        _reset_semantic_failures()
+        return CompactionSummaryResult(
+            summary_text=_ensure_summary_prefix(summary_text),
+            summary_strategy="semantic",
+            summary_model=summary_model,
+            summary_usage=usage,
+        )
+    except Exception as exc:
+        # LLM 调用失败(非 extractive 主动选择),记录 semantic 失败用于熔断判定。
+        _record_semantic_failure()
+        return CompactionSummaryResult(
+            summary_text=fallback_summary,
+            summary_strategy="extractive",
+            fallback_reason=str(exc) or exc.__class__.__name__,
+        )

ksadk/conversations/session_title.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import Any, Sequence
+
+import httpx
+
+from ksadk.configs.settings import settings
+from ksadk.conversations.model_options import model_options_for_chat_completions
+from ksadk.conversations.reasoning_markup import strip_reasoning_markup
+
+DEFAULT_SESSION_TITLE_TIMEOUT_MS = 8_000
+SESSION_TITLE_MAX_CHARS = 24
+HEURISTIC_SESSION_TITLE_SOURCE = "heuristic"
+SESSION_TITLE_SOURCE_SCAN_LIMIT = 8_000
+
+_TITLE_PROMPT = (
+    "你是会话标题生成器。"
+    "请基于首轮用户问题和首轮助手回答，生成一个适合左侧会话列表的中文标题。\n"
+    "要求：\n"
+    "1. 优先输出 4 到 8 个汉字，最多 12 个汉字\n"
+    "2. 输出主题名或任务名，不要直接复述整句提问\n"
+    "3. 去掉“你好”“请”“帮我”“看看这个”等口语前缀和文件名\n"
+    "4. 如果是自我介绍/能力说明，改写成“能力介绍”“功能概览”这类主题名\n"
+    "5. 如果是在看图或看附件，改写成“架构图分析”“附件分析”“简历分析”这类主题名\n"
+    "6. 不要标点、引号、书名号、解释，只输出标题本身\n"
+    "示例：\n"
+    "- 你好，请介绍一下你自己 -> 招聘助手能力\n"
+    "- 看看这个上传文件，这里还有他画的架构图 -> 架构图分析"
+)
+
+_SELF_INTRO_RE = re.compile(r"(介绍(?:一下)?你自己|你是谁|你的能力|你能做什么|自我介绍)")
+_ARCH_RE = re.compile(r"(架构图|架构|微服务|系统设计|服务拓扑)")
+_RECRUIT_RE = re.compile(r"(简历|候选人|面试|招聘|职位|jd\b)")
+_FILE_RE = re.compile(r"(上传文件|上传图片|附件|file|pdf|png|jpg|jpeg)")
+_ANALYZE_RE = re.compile(r"(分析|解读|评审|review|总结|说明|看下|看看|评估)")
+_PROMPT_FILLERS_RE = re.compile(
+    r"^(你好|您好|请问|请|帮我|麻烦|看看这个|看看|看下|分析一下|分析|介绍一下|介绍|解释一下|解释|总结一下|总结|直接开始分析吧|直接开始|这里还有|这边有|给我看下)+",
+)
+_FILE_MARKER_WORDS = ("上传文件", "上传文件引用", "附件")
+
+
+def _replace_file_markup(text: str) -> str:
+    segments: list[str] = []
+    for line in str(text or "").splitlines():
+        stripped = line.lstrip("#").strip()
+        if stripped.startswith("附件") and any(sep in stripped for sep in ("-", ":", "：")):
+            segments.append(" 附件 ")
+            continue
+
+        current = line
+        while "[" in current and "]" in current:
+            start = current.find("[")
+            end = current.find("]", start + 1)
+            if end < 0:
+                break
+            bracketed = current[start : end + 1]
+            if any(word in bracketed for word in _FILE_MARKER_WORDS):
+                current = f"{current[:start]} 附件 {current[end + 1:]}"
+            else:
+                break
+        segments.append(current)
+    return "\n".join(segments)
+
+
+def _normalize_source_text(text: str) -> str:
+    value = strip_reasoning_markup(str(text or "")[:SESSION_TITLE_SOURCE_SCAN_LIMIT]).strip()
+    if not value:
+        return ""
+    value = _replace_file_markup(value)
+    value = re.sub(r"\s+", " ", value)
+    return value.strip()
+
+
+def _sanitize_title(text: str) -> str:
+    value = strip_reasoning_markup(str(text or "")).strip()
+    if not value:
+        return ""
+    value = value.splitlines()[0].strip()
+    value = re.sub(r"^标题[:：]\s*", "", value)
+    value = value.strip("`'\"“”‘’《》[]()（）")
+    value = re.sub(r"[。！？!?；;：:，,、]+$", "", value).strip()
+    value = " ".join(value.split())
+    if len(value) > SESSION_TITLE_MAX_CHARS:
+        value = value[:SESSION_TITLE_MAX_CHARS].rstrip()
+    return value
+
+
+def _normalize_compare_text(text: str) -> str:
+    value = _normalize_source_text(text)
+    value = _PROMPT_FILLERS_RE.sub("", value).strip()
+    value = re.sub(r"[^\w\u4e00-\u9fff]+", "", value)
+    return value.lower()
+
+
+def _truncate_title(text: str) -> str:
+    value = strip_reasoning_markup(str(text or "")).strip()
+    if len(value) <= SESSION_TITLE_MAX_CHARS:
+        return value
+    return value[:SESSION_TITLE_MAX_CHARS].rstrip()
+
+
+def build_fallback_title(text: str) -> str:
+    value = _normalize_source_text(text)
+    value = _replace_file_markup(value)
+    value = re.sub(r"\s+", " ", value).strip()
+    return _truncate_title(value)
+
+
+def build_heuristic_title(*, first_prompt: str, assistant_text: str) -> str:
+    prompt = _normalize_source_text(first_prompt)
+    assistant = _normalize_source_text(assistant_text)
+    combined = f"{prompt} {assistant}".strip()
+    prompt_lower = prompt.lower()
+    combined_lower = combined.lower()
+
+    if _SELF_INTRO_RE.search(prompt):
+        if _RECRUIT_RE.search(combined_lower):
+            return "招聘助手能力"
+        return "Agent能力介绍"
+
+    if _ARCH_RE.search(combined):
+        return "架构图分析" if _ANALYZE_RE.search(combined) or assistant else "架构讨论"
+
+    if _RECRUIT_RE.search(combined_lower):
+        if "简历" in combined_lower or "候选人" in combined_lower:
+            return "简历分析"
+        if "面试" in combined_lower and (_ANALYZE_RE.search(combined) or _FILE_RE.search(combined_lower)):
+            return "面试分析"
+
+    if _FILE_RE.search(combined_lower):
+        return "附件分析" if _ANALYZE_RE.search(combined) or assistant else "附件内容"
+
+    candidate = _PROMPT_FILLERS_RE.sub("", prompt).strip("，,。！？!?；;：: ")
+    candidate = re.sub(r"^(这个|这份|这张|这段|这个上传文件|上传文件|附件)\s*", "", candidate)
+    candidate = candidate.strip("，,。！？!?；;：: ")
+    if _SELF_INTRO_RE.search(candidate):
+        return "自我介绍"
+    if candidate.endswith("架构图") or candidate == "架构图":
+        return "架构图分析"
+    if _FILE_RE.search(candidate.lower()):
+        return "附件分析"
+    return _truncate_title(candidate)
+
+
+def is_low_quality_title(title: str, *, first_prompt: str) -> bool:
+    cleaned_title = _sanitize_title(title)
+    if not cleaned_title:
+        return True
+    prompt_norm = _normalize_compare_text(first_prompt)
+    title_norm = _normalize_compare_text(cleaned_title)
+    if not title_norm:
+        return True
+    if title_norm == prompt_norm:
+        return True
+    if prompt_norm.startswith(title_norm) and len(prompt_norm) - len(title_norm) <= 4:
+        return True
+    if title_norm.startswith(("你好", "请", "帮我", "看看这个")):
+        return True
+    return False
+
+
+def resolve_session_title_model(current_model: str | None) -> str:
+    override = str(os.getenv("SESSION_TITLE_MODEL", "")).strip()
+    if override:
+        return override
+    if current_model:
+        return str(current_model).strip()
+    return str(settings.model.model_name or "").strip()
+
+
+def build_session_title_messages(*, first_prompt: str, assistant_text: str) -> list[dict[str, str]]:
+    assistant_excerpt = strip_reasoning_markup(str(assistant_text or "")).strip()
+    if len(assistant_excerpt) > 240:
+        assistant_excerpt = assistant_excerpt[:240].rstrip() + "…"
+    return [
+        {"role": "system", "content": _TITLE_PROMPT},
+        {
+            "role": "user",
+            "content": (
+                f"首轮用户问题：\n{str(first_prompt or '').strip()}\n\n"
+                f"首轮助手回答：\n{assistant_excerpt}"
+            ),
+        },
+    ]
+
+
+class SessionTitleClient:
+    def __init__(
+        self,
+        *,
+        api_base: str | None = None,
+        api_key: str | None = None,
+    ):
+        self.api_base = str(api_base or settings.model.api_base or "").rstrip("/")
+        self.api_key = str(api_key or settings.model.api_key or "").strip()
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_base and self.api_key)
+
+    def _chat_completions_url(self) -> str:
+        if self.api_base.endswith("/v1"):
+            return f"{self.api_base}/chat/completions"
+        return f"{self.api_base}/v1/chat/completions"
+
+    async def generate_title(
+        self,
+        *,
+        model: str,
+        messages: Sequence[dict[str, str]],
+        timeout_ms: int = DEFAULT_SESSION_TITLE_TIMEOUT_MS,
+    ) -> tuple[str, dict[str, Any]]:
+        if not self.is_available:
+            raise RuntimeError("session title client is not configured")
+        if not model:
+            raise RuntimeError("session title model is not configured")
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        payload = {
+            "model": model,
+            "messages": list(messages),
+            "stream": False,
+            "temperature": 0,
+            **model_options_for_chat_completions({"thinking": {"type": "disabled"}}),
+        }
+        timeout_seconds = max(1.0, float(timeout_ms) / 1000.0)
+        async with httpx.AsyncClient(timeout=timeout_seconds) as client:
+            response = await client.post(self._chat_completions_url(), headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+        choices = data.get("choices") or []
+        message = choices[0].get("message") if choices else {}
+        content = message.get("content") if isinstance(message, dict) else ""
+        if isinstance(content, list):
+            fragments: list[str] = []
+            for item in content:
+                if isinstance(item, dict) and item.get("text"):
+                    fragments.append(str(item["text"]))
+            content = "\n".join(fragment for fragment in fragments if fragment)
+
+        title = _sanitize_title(str(content or ""))
+        if not title:
+            raise RuntimeError("session title model returned empty content")
+        return title, dict(data.get("usage") or {})
+
+
+def resolve_session_title_client() -> SessionTitleClient:
+    return SessionTitleClient()

ksadk/deployment/__init__.py

@@ -0,0 +1,83 @@
+"""
+部署模块
+
+支持多种部署目标:
+- docker: 本地 Docker 容器
+- k8s: Kubernetes 集群
+- serverless: 金山云 Serverless 计算引擎
+"""
+
+from ksadk.deployment.base import (
+    BaseDeployProvider,
+    DeployTarget,
+    DeployResult,
+    DeployStatus,
+    PackageInfo,
+    ResourceSpec,
+    ScalingConfig,
+    NetworkConfig,
+)
+from ksadk.deployment.registry import DeployProviderRegistry
+
+# 导入并注册所有 Provider
+from ksadk.deployment import providers
+
+
+class DeploymentManager:
+    """部署管理器 - 统一入口
+    
+    使用方式:
+        manager = DeploymentManager()
+        provider = manager.get_provider("docker")
+        result = await provider.deploy(package_info, target)
+    """
+    
+    @staticmethod
+    def get_provider(name: str, config: dict = None) -> BaseDeployProvider:
+        """获取部署 Provider
+        
+        Args:
+            name: Provider 名称 (docker, k8s, serverless)
+            config: Provider 配置
+            
+        Returns:
+            Provider 实例
+        """
+        return DeployProviderRegistry.get(name, config)
+    
+    @staticmethod
+    def list_providers() -> list:
+        """列出所有可用 Provider"""
+        return DeployProviderRegistry.get_provider_info()
+    
+    @staticmethod
+    def has_provider(name: str) -> bool:
+        """检查 Provider 是否存在"""
+        return DeployProviderRegistry.has_provider(name)
+    
+    # 向后兼容: create() 方法
+    @classmethod
+    def create(cls, target: str) -> DeployTarget:
+        """创建部署目标
+        
+        Args:
+            target: 部署目标 (docker, k8s, serverless)
+            
+        Returns:
+            部署目标实例
+        """
+        return cls.get_provider(target)
+
+
+__all__ = [
+    "DeploymentManager",
+    "BaseDeployProvider",
+    "DeployTarget",
+    "DeployResult",
+    "DeployStatus",
+    "PackageInfo",
+    "ResourceSpec",
+    "ScalingConfig",
+    "NetworkConfig",
+    "DeployProviderRegistry",
+]