tagword-codeagent 1.1.6__py3-none-any.whl

codeagent/runtime/orchestrator.py

@@ -0,0 +1,161 @@
+"""Orchestrator: split tasks and dispatch to workers (parallel or sequential)."""
+
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from typing import Any
+
+from .task_split import auto_split_enabled, split_user_tasks
+from .worker import Worker
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Orchestrator:
+    """
+    Dispatch user work to one or more workers.
+
+    - Default: first worker, single task.
+    - ``metadata["subtasks"]``: explicit list of prompts.
+    - ``metadata["parallel"]=true`` or multiple workers + auto-split: parallel run.
+    """
+
+    workers: list[Worker] = field(default_factory=list)
+    parallel: bool = False
+
+    def run(
+        self,
+        *,
+        session_id: str,
+        user_text: str,
+        max_tool_rounds: int = 16,
+        metadata: dict[str, Any] | None = None,
+    ) -> tuple[str, dict[str, Any]]:
+        if not self.workers:
+            raise RuntimeError("Orchestrator has no workers configured")
+
+        meta = dict(metadata or {})
+        subtasks = meta.get("subtasks")
+        if isinstance(subtasks, list):
+            tasks = [str(t).strip() for t in subtasks if str(t).strip()]
+        else:
+            tasks = []
+
+        if not tasks and auto_split_enabled(meta.get("auto_split")):
+            tasks = split_user_tasks(user_text)
+
+        if not tasks:
+            tasks = [user_text]
+
+        if "parallel" in meta:
+            use_parallel = bool(meta.get("parallel"))
+        else:
+            use_parallel = bool(
+                self.parallel and len(tasks) > 1 and len(self.workers) > 1
+            )
+
+        if len(tasks) == 1:
+            reply, wmeta = self.workers[0].run(
+                session_id=session_id,
+                user_text=tasks[0],
+                max_tool_rounds=max_tool_rounds,
+            )
+            out_meta = dict(wmeta or {})
+            out_meta["orchestrator"] = {"mode": "single", "tasks": 1}
+            return reply, out_meta
+
+        if use_parallel and len(self.workers) > 1:
+            return self._run_parallel(
+                tasks,
+                session_id=session_id,
+                max_tool_rounds=max_tool_rounds,
+                meta=meta,
+            )
+        return self._run_sequential(
+            tasks,
+            session_id=session_id,
+            max_tool_rounds=max_tool_rounds,
+            meta=meta,
+        )
+
+    def _run_sequential(
+        self,
+        tasks: list[str],
+        *,
+        session_id: str,
+        max_tool_rounds: int,
+        meta: dict[str, Any],
+    ) -> tuple[str, dict[str, Any]]:
+        parts: list[str] = []
+        metas: list[dict[str, Any]] = []
+        for i, task in enumerate(tasks):
+            worker = self.workers[i % len(self.workers)]
+            sub_sid = f"{session_id}::sub{i}"
+            reply, wmeta = worker.run(
+                session_id=sub_sid,
+                user_text=task,
+                max_tool_rounds=max_tool_rounds,
+            )
+            parts.append(f"### Subtask {i + 1}\n\n{reply}")
+            metas.append(wmeta or {})
+        merged = "\n\n".join(parts)
+        return merged, {
+            "orchestrator": {
+                "mode": "sequential",
+                "tasks": len(tasks),
+                "workers_used": len(self.workers),
+            },
+            "subtask_meta": metas,
+            **meta,
+        }
+
+    def _run_parallel(
+        self,
+        tasks: list[str],
+        *,
+        session_id: str,
+        max_tool_rounds: int,
+        meta: dict[str, Any],
+    ) -> tuple[str, dict[str, Any]]:
+        results: dict[int, tuple[str, dict[str, Any]]] = {}
+        max_workers = min(len(tasks), len(self.workers), 8)
+
+        def _job(i: int, task: str) -> tuple[int, str, dict[str, Any]]:
+            worker = self.workers[i % len(self.workers)]
+            sub_sid = f"{session_id}::sub{i}"
+            reply, wmeta = worker.run(
+                session_id=sub_sid,
+                user_text=task,
+                max_tool_rounds=max_tool_rounds,
+            )
+            return i, reply, wmeta or {}
+
+        with ThreadPoolExecutor(max_workers=max_workers) as pool:
+            futures = [pool.submit(_job, i, t) for i, t in enumerate(tasks)]
+            for fut in as_completed(futures):
+                try:
+                    i, reply, wmeta = fut.result()
+                    results[i] = (reply, wmeta)
+                except Exception as e:
+                    logger.exception("orchestrator subtask failed")
+                    results[len(results)] = (f"[subtask error] {e}", {})
+
+        parts = []
+        metas = []
+        for i in sorted(results.keys()):
+            reply, wmeta = results[i]
+            parts.append(f"### Subtask {i + 1}\n\n{reply}")
+            metas.append(wmeta)
+        merged = "\n\n".join(parts)
+        return merged, {
+            "orchestrator": {
+                "mode": "parallel",
+                "tasks": len(tasks),
+                "workers_used": max_workers,
+            },
+            "subtask_meta": metas,
+            **meta,
+        }

codeagent/runtime/prompt_enrichment.py

@@ -0,0 +1,324 @@
+"""Runtime prompt enrichment: dynamic skills, fresh system prompt, diary."""
+
+from __future__ import annotations
+
+from typing import Optional  # noqa: UP045
+
+import seed.core.env_access as _ea
+from codeagent.core import env as ca_env
+from seed.core.config_plane import build_system_prompt, project_root
+from seed.core.env_access import pick_nonempty
+
+
+def _compute_persona_hash(agent_id: str) -> str:
+    """Hash of all persona files + memory.md + project rules that compose the system prompt.
+
+    Used to detect file changes mid-session so the cache is invalidated.
+    """
+    import hashlib
+
+    from codeagent.core.settings import get_system_prompt_filenames
+    from seed.core.paths import agent_id_default, agent_persona_dir, agent_persona_memory_path
+
+    aid = (agent_id or "").strip() or agent_id_default()
+    persona_dir = agent_persona_dir(aid)
+    h = hashlib.sha256()
+    for fname in sorted(get_system_prompt_filenames()):
+        p = persona_dir / fname
+        if p.is_file():
+            h.update(p.read_bytes())
+    p_mem = agent_persona_memory_path(aid)
+    if p_mem.is_file():
+        h.update(p_mem.read_bytes())
+
+    # Also hash project-level rules files so edits invalidate the cache
+    try:
+        from codeagent.core.paths import read_global_rules, read_agent_rules
+        gr = read_global_rules()
+        if gr:
+            h.update(gr.encode("utf-8"))
+        ar = read_agent_rules(aid)
+        if ar:
+            h.update(ar.encode("utf-8"))
+    except Exception:
+        pass
+
+    return h.hexdigest()
+
+
+def get_cached_system_prompt(session, *, agent_id: str | None = None) -> str:
+    """Return system prompt, building fresh only on first turn or if files changed.
+
+    Caches the result in ``session.metadata["base_system"]`` with a hash
+    in ``session.metadata["base_system_hash"]``.
+    """
+    md = session.metadata
+    if not isinstance(md, dict):
+        md = {}
+    aid = (agent_id or "").strip() or "default"
+    current_hash = _compute_persona_hash(aid)
+    cached = md.get("base_system", "")
+    cached_hash = md.get("base_system_hash", "")
+
+    if cached and cached_hash == current_hash:
+        return cached
+
+    fresh = fresh_system_prompt(agent_id=aid)
+    if isinstance(session.metadata, dict):
+        session.metadata["base_system"] = fresh
+        session.metadata["base_system_hash"] = current_hash
+    return fresh
+
+
+def _codeagent_vars_dict(agent_id: str) -> dict[str, str]:
+    """CodeAgent-specific variables extending Seed's base vars.
+
+    All project working paths are under ``.codeagent/{agent_id}/``.
+    The ``SESSIONS_ARTIFACTS`` remains under the system-level agent home
+    (shared across all projects for cross-session artifact access).
+    """
+    from seed.core.paths import agent_home
+    from codeagent.core.paths import _agent_work_dir
+    from pathlib import Path
+
+    root = Path.cwd().resolve()
+    wd = _agent_work_dir(agent_id, root)
+    return {
+        "SESSIONS_ARTIFACTS": str(agent_home(agent_id) / "sessions" / "_artifacts"),
+        "PLANS": str(wd / "plans"),
+        "SCRIPTS": str(wd / "scripts"),
+        "DOCS": str(wd / "docs"),
+        "TMP": str(wd / "tmp"),
+        "SESSION_LOG": str(wd / "sessions"),
+        "AGENT_STATE": str(wd / "state.md"),
+    }
+
+
+def _codeagent_path_registry(vars_dict: dict[str, str]) -> str:
+    """Build the CodeAgent extension of the path registry table."""
+    rows: list[str] = [
+        "\n\n## 路径基准（CodeAgent 扩展）\n",
+        "| 变量 | 当前值 |",
+        "|------|--------|",
+    ]
+    for key in sorted(vars_dict):
+        rows.append(f"| `${key}` | `{vars_dict[key]}` |")
+    return "\n".join(rows)
+
+
+def _runtime_info_block() -> str:
+    """Build a block with current system environment and datetime.
+
+    Added to the system prompt so the agent knows its OS and the real current
+    time, avoiding cross-platform command errors and stale LLM-training dates.
+    """
+    import datetime
+    import platform
+    import os
+    from pathlib import Path
+
+    now = datetime.datetime.now(datetime.timezone.utc).astimezone()
+    os_name = platform.system()     # Windows / Linux / Darwin
+    os_release = platform.release()
+
+    lines = [
+        "\n\n## 当前环境信息\n",
+        f"- **当前时间**: {now.strftime('%Y-%m-%d %H:%M:%S %Z')}",
+        f"- **操作系统**: {os_name} {os_release}",
+        f"- **主机名**: {platform.node()}",
+        f"- **Shell**: {os.environ.get('SHELL', '') or os.environ.get('ComSpec', '')}",
+        f"- **工作目录**: {Path.cwd().resolve()}",
+    ]
+    if os_name == "Windows":
+        lines.append("\n⚠️ 当前运行在 **Windows** 环境。执行命令时请使用 Windows 兼容的指令")
+        lines.append("（如 `dir` 而非 `ls`，`type` 而非 `cat`），路径使用反斜杠或正斜杠均可。")
+    elif os_name == "Linux":
+        lines.append("\n⚠️ 当前运行在 **Linux** 环境。执行命令时请使用 Linux/POSIX 指令。")
+    elif os_name == "Darwin":
+        lines.append("\n⚠️ 当前运行在 **macOS** 环境。执行命令时请使用 macOS/POSIX 指令。")
+
+    return "\n".join(lines)
+
+
+def fresh_system_prompt(*, agent_id: str | None = None) -> str:
+    """
+    System prompt for chat: respects Web UI ``config_md_enabled``, plugin skills
+    (via ``build_system_prompt``), and optional persona ``memory.md``.
+    """
+    explicit = pick_nonempty(*_ea.SYSTEM_PROMPT)
+    if explicit.strip():
+        return explicit.strip()
+
+    from seed.core.paths import agent_id_default
+
+    aid = (agent_id or "").strip() or agent_id_default()
+
+    from codeagent.core.settings import get_system_prompt_filenames
+
+    base = build_system_prompt(
+        base=project_root(),
+        filenames=get_system_prompt_filenames(),
+        agent_id=aid,
+    )
+
+    # ── Append project-level constraints (rules.md) ──
+    from codeagent.core.paths import read_global_rules, read_agent_rules
+
+    rules_parts: list[str] = []
+    gr = read_global_rules()
+    if gr:
+        rules_parts.append(f"## Project Rules (.codeagent/rules.md)\n\n{gr}")
+    ar = read_agent_rules(aid)
+    if ar:
+        rules_parts.append(f"## Agent Rules (.codeagent/{aid}/rules.md)\n\n{ar}")
+    if rules_parts:
+        base += "\n\n---\n" + "\n\n".join(rules_parts)
+
+    # Merge Seed vars + CodeAgent vars for memory.md rendering
+    from seed.core.config_plane import render_persona, _build_seed_vars_dict
+
+    seed_vars = _build_seed_vars_dict(aid, project_root())
+    ca_vars = _codeagent_vars_dict(aid)
+    all_vars: dict[str, str] = {**seed_vars, **ca_vars}
+
+    try:
+        from seed.core.paths import agent_persona_memory_path
+
+        p = agent_persona_memory_path(aid)
+        if p.is_file():
+            text = p.read_text(encoding="utf-8").strip()
+            if text:
+                # Render memory.md through render_persona (expands $VAR in memory content)
+                text = render_persona(text, all_vars)
+                max_chars = int(pick_nonempty(*_ea.PERSONA_MEMORY_MAX_CHARS) or "4000")
+                max_chars = max(200, min(max_chars, 50_000))
+                if len(text) > max_chars:
+                    text = text[: max_chars - 20].rstrip() + "\n…[已截断]"
+                header_path = f"agents/{aid}/persona/memory.md"
+                base = (
+                    base.rstrip()
+                    + "\n\n---\n"
+                    + f"## Persona core memory (`{header_path}`)\n\n"
+                    + text
+                    + "\n"
+                )
+    except Exception:
+        pass
+
+    # Append CodeAgent extension path registry
+    base += _codeagent_path_registry(ca_vars)
+
+    # Append session-stable runtime info (time, OS, workdir)
+    # — cached once per session so LLM provider prefix-cache stays effective
+    base += _runtime_info_block()
+
+    base = base.rstrip() + vision_multimodal_appendix()
+    return base
+
+
+def build_skills_suffix(
+    agent_id: str,
+    *,
+    user_text: str,
+    workspace_suffix: str = "",
+) -> Optional[str]:
+    """Combine workspace hint + dynamically selected agent skills for ``skills_suffix``."""
+    parts: list[str] = []
+    if workspace_suffix and workspace_suffix.strip():
+        parts.append(workspace_suffix.strip())
+
+    if ca_env.env_truthy(ca_env.SKILLS_AUTO, default="1"):
+        try:
+            from codeagent.core.attachments import content_text_for_skills
+            from codeagent.skills.select import build_selected_skills_appendix
+
+            appendix = build_selected_skills_appendix(
+                agent_id,
+                user_text=content_text_for_skills(user_text),
+            )
+            if appendix:
+                parts.append(appendix)
+        except Exception:
+            pass
+
+    if not parts:
+        return None
+    return "\n".join(parts)
+
+
+def vision_multimodal_appendix() -> str:
+    from codeagent.core.image_understanding import (
+        MCP_QUALIFIED_UNDERSTAND_IMAGE,
+        minimax_mcp_configured,
+    )
+    from codeagent.core.vision_models import list_vision_presets
+
+    mcp = minimax_mcp_configured()
+    has_vision = bool(list_vision_presets())
+    parts = ["\n\n## Multimodal (images)\n\n"]
+
+    if mcp:
+        parts.append(
+            "When the user message contains `[attachment:<id> ...]` and you need to **understand** "
+            "image content, call `attachment_resolve_path` with the attachment id, then "
+            f"`{MCP_QUALIFIED_UNDERSTAND_IMAGE}` with `image_url` set to the returned absolute "
+            "`path` and a clear `prompt` describing what to extract. "
+            "Do not claim to see images without tool results.\n\n"
+        )
+    if has_vision:
+        parts.append(
+            "When `[attachment:...]` or `[image_dir:...]` appears, you may also use "
+            "`vision_analyze` or `vision_analyze_directory` (requires an active vision LLM preset). "
+            "Prefer the tool that matches your available backends.\n\n"
+        )
+    elif not mcp:
+        parts.append(
+            "Image understanding requires a vision LLM preset or MiniMax MCP; "
+            "do not guess image content without tools.\n\n"
+        )
+
+    parts.append(
+        "When the user asks to **create, draw, or generate** an image, call `image_generate` "
+        "with a detailed prompt. For image-to-image (keep subject/style from a photo), pass "
+        "`attachment_ids` or `reference_image_urls`. Share returned `attachment_id` / URL in your reply.\n\n"
+        "When the user asks to **compose, write, or generate music or a song**, call `music_generate` "
+        "with a style `prompt` and `lyrics` (use [Verse]/[Chorus] tags). For instrumental-only, "
+        "set `is_instrumental=true`. If lyrics are missing, use `lyrics_optimizer=true` or ask the user. "
+        "Share the returned `attachment_id` / URL for playback.\n\n"
+        "When the user asks to **create or generate a video** (text-to-video, animate an image, or "
+        "keyframe transition), call `video_generate` with a detailed cinematic `prompt`. For image-to-video, "
+        "pass `attachment_ids` or `image_url`. Share the returned `attachment_id` / URL for playback.\n\n"
+        "For **audio** attachments, call `audio_transcribe` before answering about spoken content.\n"
+        "For **video** attachments, call `video_analyze` (requires server ffmpeg for frame sampling).\n"
+        "Camera captures appear as `[attachment:...]` — analyze them like uploaded photos.\n"
+    )
+    return "".join(parts)
+
+
+def record_chat_turn_diary(
+    agent_id: str,
+    *,
+    user_text: str,
+    reply: str,
+    tools_used: list[str] | None = None,
+    project_id: str | None = None,
+) -> None:
+    """Append a short turn summary to the agent daily diary (best-effort)."""
+    if ca_env.env_falsy(ca_env.DIARY, default="1"):
+        return
+    try:
+        from codeagent.core.attachments import content_text_for_skills
+        from codeagent.memory.diary import append_diary_entry, archive_old_diaries
+
+        u = content_text_for_skills(user_text or "")
+        if not u and (user_text or "").strip():
+            u = "[用户附加了图片或文档]"
+        r = (reply or "").strip()
+        block = f"**用户**: {u[:500]}\n\n**助手**: {r[:800]}"
+        if tools_used:
+            block += f"\n\n**工具**: {', '.join(tools_used[:16])}"
+        append_diary_entry(agent_id, text=block, project_id=project_id or None)
+        keep = ca_env.pick_int(7, ca_env.DIARY_KEEP_DAYS)
+        archive_old_diaries(agent_id, keep_days=max(1, min(keep, 60)))
+    except Exception:
+        pass

codeagent/runtime/session_manager.py

@@ -0,0 +1,30 @@
+"""Session manager with per-session agent binding and locks."""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SessionManager:
+    """Track active agent per session; optional per-session locks."""
+
+    active_agent_by_session: dict[str, str] = field(default_factory=dict)
+    _lock: threading.RLock = field(default_factory=threading.RLock, repr=False)
+    _session_locks: dict[str, threading.Lock] = field(default_factory=dict, repr=False)
+
+    def set_active_agent(self, session_id: str, agent_id: str) -> None:
+        with self._lock:
+            self.active_agent_by_session[str(session_id)] = str(agent_id)
+
+    def get_active_agent(self, session_id: str) -> str | None:
+        with self._lock:
+            return self.active_agent_by_session.get(str(session_id))
+
+    def session_lock(self, session_id: str) -> threading.Lock:
+        with self._lock:
+            sid = str(session_id)
+            if sid not in self._session_locks:
+                self._session_locks[sid] = threading.Lock()
+            return self._session_locks[sid]

codeagent/runtime/task_split.py

@@ -0,0 +1,38 @@
+"""Heuristic task splitting for multi-worker orchestration."""
+
+from __future__ import annotations
+
+import re
+
+from codeagent.core import env as ca_env
+
+
+def auto_split_enabled(explicit: bool | None = None) -> bool:
+    if explicit is not None:
+        return bool(explicit)
+    return ca_env.env_truthy(ca_env.ORCHESTRATOR_AUTO_SPLIT, default="0")
+
+
+def split_user_tasks(user_text: str) -> list[str]:
+    """
+    Split a user message into subtasks.
+
+    Rules (first match wins):
+    1. ``---`` on its own line
+    2. Numbered lines ``1.`` ``2.`` (at least 2 items)
+    3. Otherwise single task
+    """
+    text = (user_text or "").strip()
+    if not text:
+        return []
+
+    if re.search(r"(?m)^---\s*$", text):
+        parts = [p.strip() for p in re.split(r"(?m)^---\s*$", text) if p.strip()]
+        if len(parts) > 1:
+            return parts
+
+    numbered = re.findall(r"(?m)^\s*\d+[.)]\s+(.+)$", text)
+    if len(numbered) >= 2:
+        return [p.strip() for p in numbered if p.strip()]
+
+    return [text]

codeagent/runtime/turn_loop.py

@@ -0,0 +1,13 @@
+"""Turn loop engine (compat wrapper)."""
+
+from __future__ import annotations
+
+from seed.core.turn_loop import (  # noqa: F401
+    AutonomousAgent,
+    AutonomousTurnLoop,
+    TurnLoopConfig,
+    TurnLoopEngine,
+    estimate_tokens,
+    execute_command_as_tool,
+)
+

codeagent/runtime/worker.py

@@ -0,0 +1,48 @@
+"""Worker abstraction (v0 skeleton for multi-agent)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+
+class WorkerProtocol(Protocol):
+    def run(
+        self,
+        *,
+        session_id: str,
+        user_text: str,
+        tools: list[dict[str, Any]] | None = None,
+        max_tool_rounds: int = 16,
+    ) -> tuple[str, dict[str, Any]]:
+        """Run a single user turn, returning assistant text + metadata."""
+
+
+@dataclass
+class Worker:
+    """
+    Minimal worker wrapper.
+
+    Phase 1: delegates to the existing single-agent runtime (HTTP API uses seed.server).
+    Phase 2+: will host an isolated tool-loop with its own tool registry, memory view, etc.
+    """
+
+    impl: WorkerProtocol | None = None
+
+    def run(
+        self,
+        *,
+        session_id: str,
+        user_text: str,
+        tools: list[dict[str, Any]] | None = None,
+        max_tool_rounds: int = 16,
+    ) -> tuple[str, dict[str, Any]]:
+        if self.impl is None:
+            raise RuntimeError("Worker.impl is not configured")
+        return self.impl.run(
+            session_id=session_id,
+            user_text=user_text,
+            tools=tools,
+            max_tool_rounds=max_tool_rounds,
+        )
+