tagword-codeagent 1.1.6__py3-none-any.whl

codeagent/core/team_manager.py

@@ -0,0 +1,245 @@
+"""Team manager — singleton that manages team lifecycle.
+
+Usage::
+
+    from codeagent.core.team_manager import TeamManager
+    tm = TeamManager()
+    tm.init_from_config(".codeagent/config/team.json")
+    
+    # Later, when runtime is available:
+    tm.register_members(session_factory, llm_executor)
+    
+    # Lookup:
+    lead = tm.get_lead()
+    members = tm.get_members()
+    agent = tm.get_agent("frontend_dev")
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
+
+from seed.core.agent_registry import AgentHandle, AgentRegistry
+
+if TYPE_CHECKING:
+    pass
+
+logger = logging.getLogger(__name__)
+
+
+class TeamManager:
+    """Singleton that manages team configuration and agent lifecycle."""
+
+    _instance: Optional["TeamManager"] = None
+
+    def __new__(cls) -> "TeamManager":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._reset_state()
+        return cls._instance
+
+    def _reset_state(self) -> None:
+        """Reset internal state (called from __new__ and _reset)."""
+        self._initialized = False
+        self._config = None
+        self._lead_handle = None
+        self._member_handles: Dict[str, AgentHandle] = {}
+
+    @classmethod
+    def _reset(cls) -> None:
+        """Reset singleton for testing. Clears instance and registry."""
+        from seed.core.agent_registry import AgentRegistry
+        AgentRegistry.clear()
+        cls._instance = None
+
+    def init_from_config(self, config_path: Path | str) -> bool:
+        """Load and parse team.json config.
+
+        Args:
+            config_path: Path to team.json file.
+
+        Returns:
+            True if loaded successfully, False if file not found or invalid.
+        """
+        from codeagent.core.team_config import TeamConfig
+
+        path = Path(config_path)
+        if not path.is_file():
+            logger.info(f"No team config found at {config_path} — running in single-agent mode")
+            return False
+
+        try:
+            self._config = TeamConfig.from_file(path)
+            self._initialized = True
+            logger.info(
+                f"Loaded team config: Lead='{self._config.lead.name}', "
+                f"{len(self._config.members)} members"
+            )
+            return True
+        except Exception as e:
+            logger.warning(f"Failed to load team config: {e} — running in single-agent mode")
+            return False
+
+    @property
+    def is_team_mode(self) -> bool:
+        """True if team config was loaded successfully."""
+        return self._initialized and self._config is not None
+
+    @property
+    def config(self):
+        """The loaded TeamConfig (None if not in team mode)."""
+        return self._config
+
+    def get_lead(self) -> Optional[AgentHandle]:
+        """Return the registered Lead agent handle."""
+        if self._lead_handle:
+            return self._lead_handle
+        # Fall back to registry lookup
+        if self._config and self._config.lead:
+            return AgentRegistry.get(self._config.lead.id)
+        return None
+
+    def get_members(self) -> List[AgentHandle]:
+        """Return list of all registered member agent handles."""
+        return list(self._member_handles.values())
+
+    def get_agent(self, agent_id: str) -> Optional[AgentHandle]:
+        """Look up a registered agent by id.
+
+        Checks members first, then lead.
+        """
+        handle = self._member_handles.get(agent_id)
+        if handle:
+            return handle
+        return AgentRegistry.get(agent_id)
+
+    def register_members(
+        self,
+        create_agent: Callable[[str, str, List[str]], Any],
+    ) -> int:
+        """Register all member agents with AgentRegistry.
+
+        This should be called once the runtime is available to create agents.
+
+        Args:
+            create_agent: Factory function(agent_id, persona_path, tools) -> object
+                The returned object must be suitable for AgentHandle construction.
+                Typically an AutonomousAgent instance or any callable that can
+                be passed to AgentHandle(agent=...).
+
+        Returns:
+            Number of agents registered.
+        """
+        if not self._config:
+            logger.warning("Cannot register members: no team config loaded")
+            return 0
+
+        count = 0
+        # Register lead first
+        if self._config.lead:
+            try:
+                agent_instance = create_agent(
+                    self._config.lead.id,
+                    self._config.lead.persona,
+                    self._config.lead.tools,
+                )
+                handle = AgentHandle(
+                    agent=agent_instance,
+                    metadata={"role": "lead", "name": self._config.lead.name},
+                )
+                AgentRegistry.register(self._config.lead.id, handle)
+                self._lead_handle = handle
+                count += 1
+                logger.info(f"Registered Lead agent: {self._config.lead.id}")
+            except Exception as e:
+                logger.error(f"Failed to register Lead agent '{self._config.lead.id}': {e}")
+
+        # Register members
+        for member in self._config.members:
+            if member.id in self._member_handles:
+                logger.warning(f"Member '{member.id}' already registered, skipping")
+                continue
+            try:
+                agent_instance = create_agent(
+                    member.id,
+                    member.persona,
+                    member.tools,
+                )
+                handle = AgentHandle(
+                    agent=agent_instance,
+                    metadata={"role": "member", "name": member.name},
+                )
+                AgentRegistry.register(member.id, handle)
+                self._member_handles[member.id] = handle
+                count += 1
+                logger.info(f"Registered member agent: {member.id} ({member.name})")
+            except Exception as e:
+                logger.error(f"Failed to register member '{member.id}': {e}")
+
+        logger.info(f"Team registration complete: {count} agents registered")
+        return count
+
+    def unregister_all(self) -> None:
+        """Remove all registered agents from the registry."""
+        if self._lead_handle:
+            AgentRegistry.unregister(self._config.lead.id if self._config else "")
+            self._lead_handle = None
+        for agent_id in list(self._member_handles.keys()):
+            AgentRegistry.unregister(agent_id)
+        self._member_handles.clear()
+        logger.info("All team agents unregistered")
+
+    def get_team_status(self) -> dict:
+        """Return a summary of team status for UI display."""
+        if not self.is_team_mode:
+            return {"mode": "single", "agents": []}
+
+        agents = []
+        if self._config and self._config.lead:
+            agents.append({
+                "id": self._config.lead.id,
+                "name": self._config.lead.name,
+                "role": "lead",
+                "tools": self._config.lead.tools,
+                "registered": self._lead_handle is not None,
+            })
+        if self._config:
+            for m in self._config.members:
+                agents.append({
+                    "id": m.id,
+                    "name": m.name,
+                    "role": "member",
+                    "tools": m.tools,
+                    "registered": m.id in self._member_handles,
+                })
+
+        return {
+            "mode": "team",
+            "version": self._config.version if self._config else "1.0",
+            "total_agents": len(agents),
+            "registered_count": sum(1 for a in agents if a["registered"]),
+            "agents": agents,
+        }
+
+
+def team_config_path() -> Path:
+    """Return the default team config path (.codeagent/config/team.json in project root)."""
+    from seed.core.config_plane import project_root
+
+    root = project_root()
+    return root / "config" / "team.json"
+
+
+def is_team_configured() -> bool:
+    """Check if team.json exists and is valid."""
+    path = team_config_path()
+    if not path.is_file():
+        return False
+    try:
+        from codeagent.core.team_config import TeamConfig
+        TeamConfig.from_file(path)
+        return True
+    except Exception:
+        return False

codeagent/core/token_counter.py

@@ -0,0 +1,41 @@
+"""
+Token 计数适配层 — 基于 seed_model_providers.token_counter，增加 attachment tag 剥离。
+
+如需使用原始 DeepSeek tokenizer 计数，直接 from seed_model_providers.token_counter import count_tokens.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from seed_model_providers.token_counter import count_tokens  # noqa: F401 — re-export
+
+from codeagent.core.attachments import ATTACHMENT_TAG_RE, IMAGE_DIR_TAG_RE
+
+
+def count_messages(messages: list[dict[str, Any]]) -> dict[str, int]:
+    """计算一组消息的总 token 用量（剥离 attachment/image_dir 标记后再计）。"""
+    from seed_model_providers.token_counter import count_tokens as _cnt_tok
+
+    content_tokens = 0
+    for msg in messages:
+        role = str(msg.get("role") or "")
+        content = msg.get("content")
+        if role == "tool":
+            content_tokens += _cnt_tok(str(content or ""))
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict) and part.get("type") == "text":
+                    content_tokens += _cnt_tok(part.get("text", ""))
+        else:
+            text = str(content or "")
+            text = ATTACHMENT_TAG_RE.sub("", text)
+            text = IMAGE_DIR_TAG_RE.sub("", text)
+            content_tokens += _cnt_tok(text)
+        content_tokens += 4
+
+    return {
+        "total_tokens": content_tokens,
+        "content_tokens": content_tokens,
+        "message_count": len(messages),
+    }

codeagent/core/tts_voices.py

@@ -0,0 +1,103 @@
+"""MiniMax system TTS voices and models (curated from platform docs)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from seed_model_providers import list_models_for_provider
+
+# https://platform.minimaxi.com/docs/faq/system-voice-id
+TTS_SYSTEM_VOICES: list[dict[str, str]] = [
+    {"id": "male-qn-qingse", "name": "青涩青年", "lang": "中文"},
+    {"id": "male-qn-jingying", "name": "精英青年", "lang": "中文"},
+    {"id": "male-qn-badao", "name": "霸道青年", "lang": "中文"},
+    {"id": "male-qn-daxuesheng", "name": "青年大学生", "lang": "中文"},
+    {"id": "female-shaonv", "name": "少女", "lang": "中文"},
+    {"id": "female-yujie", "name": "御姐", "lang": "中文"},
+    {"id": "female-chengshu", "name": "成熟女性", "lang": "中文"},
+    {"id": "female-tianmei", "name": "甜美女性", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Lyrical_Voice", "name": "抒情男声", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Gentleman", "name": "温润男声", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Sweet_Lady", "name": "甜美女声", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_News_Anchor", "name": "新闻女声", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Male_Announcer", "name": "播报男声", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Radio_Host", "name": "电台男主播", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Reliable_Executive", "name": "沉稳高管", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Warm_Bestie", "name": "温暖闺蜜", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_HK_Flight_Attendant", "name": "港普空姐", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Humorous_Elder", "name": "搞笑大爷", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Crisp_Girl", "name": "清脆少女", "lang": "中文"},
+    {"id": "Chinese (Mandarin)_Soft_Girl", "name": "柔和少女", "lang": "中文"},
+    {"id": "Cantonese_ProfessionalHost（F)", "name": "粤语女主持", "lang": "粤语"},
+    {"id": "Cantonese_GentleLady", "name": "粤语温柔女声", "lang": "粤语"},
+    {"id": "Cantonese_ProfessionalHost（M)", "name": "粤语男主持", "lang": "粤语"},
+    {"id": "English_Graceful_Lady", "name": "Graceful Lady", "lang": "英文"},
+    {"id": "English_Trustworthy_Man", "name": "Trustworthy Man", "lang": "英文"},
+    {"id": "English_Diligent_Man", "name": "Diligent Man", "lang": "英文"},
+    {"id": "English_Gentle-voiced_man", "name": "Gentle-voiced man", "lang": "英文"},
+    {"id": "English_Whispering_girl", "name": "Whispering girl", "lang": "英文"},
+    {"id": "Japanese_GentleButler", "name": "Gentle Butler", "lang": "日文"},
+    {"id": "Japanese_KindLady", "name": "Kind Lady", "lang": "日文"},
+    {"id": "Korean_SweetGirl", "name": "Sweet Girl", "lang": "韩文"},
+]
+
+DEFAULT_TTS_VOICE_ID = "male-qn-qingse"
+DEFAULT_TTS_MODEL = "speech-2.8-turbo"
+
+
+def _speech_models_from_catalog() -> list[dict[str, str]]:
+    out: list[dict[str, str]] = []
+    for m in list_models_for_provider("minimax", "speech"):
+        mid = str(m.get("id") or "").strip()
+        if not mid:
+            continue
+        label = str(m.get("label") or mid).strip() or mid
+        out.append({"id": mid, "name": label})
+    return out
+
+
+def _allowed_tts_models() -> set[str]:
+    return {m["id"] for m in _speech_models_from_catalog()}
+
+
+def default_tts_voice_id() -> str:
+    v = os.environ.get("CODEAGENT_TTS_VOICE_ID", DEFAULT_TTS_VOICE_ID).strip()
+    return v or DEFAULT_TTS_VOICE_ID
+
+
+def default_tts_model() -> str:
+    m = os.environ.get("CODEAGENT_TTS_MODEL", DEFAULT_TTS_MODEL).strip()
+    return m or DEFAULT_TTS_MODEL
+
+
+def normalize_tts_voice_id(voice_id: str | None) -> str:
+    v = (voice_id or "").strip()
+    if not v:
+        return default_tts_voice_id()
+    if len(v) > 128:
+        return default_tts_voice_id()
+    return v
+
+
+def normalize_tts_model(model: str | None) -> str:
+    m = (model or "").strip()
+    allowed = _allowed_tts_models()
+    if m in allowed:
+        return m
+    if not m:
+        return default_tts_model()
+    env_default = default_tts_model()
+    return env_default if env_default in allowed else DEFAULT_TTS_MODEL
+
+
+def tts_options_payload(*, configured: bool) -> dict[str, Any]:
+    models = _speech_models_from_catalog()
+    return {
+        "configured": configured,
+        "default_voice_id": default_tts_voice_id(),
+        "default_model": default_tts_model(),
+        "voices": TTS_SYSTEM_VOICES,
+        "models": models,
+        "docs_url": "https://platform.minimaxi.com/docs/faq/system-voice-id",
+    }

codeagent/core/usage_billing.py

@@ -0,0 +1,72 @@
+"""Session-level token usage accumulation with per-model cost (billing v2)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Tuple
+
+from codeagent.core.pricing import calculate_cost
+
+USAGE_KEYS = (
+    "prompt_tokens",
+    "completion_tokens",
+    "total_tokens",
+    "prompt_cache_hit_tokens",
+    "prompt_cache_miss_tokens",
+)
+
+
+def _add_usage_keys(target: Dict[str, Any], source: Dict[str, Any]) -> None:
+    for key in USAGE_KEYS:
+        value = source.get(key, 0)
+        if not isinstance(value, (int, float)):
+            value = 0
+        target[key] = int(target.get(key, 0) or 0) + int(value)
+
+
+def merge_accumulated_usage(
+    prev: Dict[str, Any] | None,
+    model_name: str,
+    api_usage: Dict[str, Any] | None,
+) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]]:
+    """Merge one LLM round into session ``accumulated_usage``.
+
+    Returns:
+        ``(accumulated_usage, round_cost, accumulated_cost_summary)``
+    """
+    prev = prev or {}
+    api_usage = dict(api_usage or {})
+
+    acc: Dict[str, Any] = {}
+    _add_usage_keys(acc, prev)
+    _add_usage_keys(acc, api_usage)
+
+    per_model: Dict[str, Dict[str, Any]] = {
+        name: dict(data) for name, data in (prev.get("per_model") or {}).items()
+    }
+    model_usage = dict(per_model.get(model_name) or {})
+    _add_usage_keys(model_usage, api_usage)
+    per_model[model_name] = model_usage
+
+    total_cost_val = 0.0
+    for mname, mdata in per_model.items():
+        mcost = calculate_cost(mname, mdata)
+        cost_val = float(mcost.get("total_cost", 0) or 0)
+        mdata["cost"] = round(cost_val, 6)
+        total_cost_val += cost_val
+
+    acc["per_model"] = per_model
+    acc["total_cost"] = round(total_cost_val, 6)
+    acc["currency"] = "CNY"
+
+    round_cost = calculate_cost(model_name, api_usage)
+    acc["last_request"] = {
+        "model": model_name,
+        "usage": api_usage,
+        "cost": round_cost,
+    }
+
+    accumulated_cost = {
+        "total_cost": acc["total_cost"],
+        "currency": "CNY",
+    }
+    return acc, round_cost, accumulated_cost

codeagent/core/vision_models.py

@@ -0,0 +1,93 @@
+"""Vision preset resolution for vision_analyze tool."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from codeagent.core import env as ca_env
+
+
+def list_vision_presets() -> list[dict[str, Any]]:
+    from seed.core.llm_presets import load_presets
+
+    return [p for p in load_presets() if preset_supports_vision(p)]
+
+
+def preset_supports_vision(preset: dict[str, Any] | None) -> bool:
+    if not isinstance(preset, dict):
+        return False
+    if preset.get("supports_vision") is True:
+        return True
+    return False
+
+
+def preset_supports_vision_id(preset_id: str) -> bool:
+    from seed.core.llm_presets import load_presets
+
+    pid = (preset_id or "").strip()
+    for p in load_presets():
+        if str(p.get("id") or "").strip() == pid:
+            return preset_supports_vision(p)
+    return False
+
+
+def resolve_preset_id(preset_id: Optional[str]) -> Optional[dict[str, Any]]:
+    from seed.core.llm_presets import load_presets, resolve_preset
+
+    pid = (preset_id or "").strip()
+    if pid:
+        for p in load_presets():
+            if str(p.get("id") or "").strip() == pid:
+                return p
+        return None
+    return resolve_preset(None)
+
+
+def get_vision_executor(vision_llm_id: Optional[str] = None):
+    from seed.core.llm_exec import get_llm_executor
+    from seed.core.llm_presets import llm_executor_from_resolved
+
+    pid = (vision_llm_id or "").strip()
+    if not pid:
+        pid = ca_env.pick_default("", "CODEAGENT_VISION_PRESET_ID").strip()
+    preset = resolve_preset_id(pid) if pid else None
+    if preset and preset_supports_vision(preset):
+        return llm_executor_from_resolved(preset)
+    if pid:
+        raise ValueError(f"vision preset not found or not supports_vision: {pid}")
+    raise ValueError("vision_llm_id required (no CODEAGENT_VISION_PRESET_ID fallback)")
+
+
+def resolve_main_llm(llm_id: Optional[str] = None):
+    from seed.core.llm_presets import llm_executor_from_resolved, resolve_preset
+
+    pid = (llm_id or "").strip()
+    if pid:
+        from seed.core.llm_presets import load_presets
+
+        for p in load_presets():
+            if str(p.get("id") or "").strip() == pid:
+                preset = p
+                break
+        else:
+            preset = resolve_preset(None)
+    else:
+        preset = resolve_preset(None)
+
+    cfg = dict(preset)
+
+    # 会话级 max_tokens 覆盖（CODEAGENT_CHAT_MAX_TOKENS / SEED_LLM_MAX_TOKENS）
+    from codeagent.core import env as ca_env
+    from seed.core import env_access as _ea
+
+    mt_override = _ea.pick_nonempty(ca_env.CHAT_MAX_TOKENS)
+    if not mt_override:
+        mt_override = _ea.pick_nonempty(*_ea.LLM_MAX_TOKENS)
+    if mt_override:
+        try:
+            cfg["max_tokens"] = int(mt_override)
+        except (ValueError, TypeError):
+            pass
+
+    return llm_executor_from_resolved(cfg)