voidx 1.0.0__py3-none-any.whl

voidx/agent/graph_components/streaming.py

@@ -0,0 +1,351 @@
+"""LLM streaming helpers for agent execution."""
+
+from __future__ import annotations
+
+import html
+import json
+import re
+import uuid
+
+from langchain_core.messages import AIMessage, AIMessageChunk, ToolMessage
+
+from voidx.ui.console import StreamingRenderer
+
+_REPLAY_UNSAFE_BLOCK_TYPES = {
+    "thinking",
+    "redacted_thinking",
+    "reasoning",
+    "reasoning_content",
+}
+_DSML_TOOL_CALLS_RE = re.compile(
+    r"<\|+DSML\|+tool_calls\b[^>]*>.*?</\|+DSML\|+tool_calls>",
+    re.DOTALL,
+)
+_DSML_INVOKE_RE = re.compile(
+    r"<\|+DSML\|+invoke\b([^>]*)>(.*?)</\|+DSML\|+invoke>",
+    re.DOTALL,
+)
+_DSML_PARAMETER_RE = re.compile(
+    r"<\|+DSML\|+parameter\b([^>]*)>(.*?)</\|+DSML\|+parameter>",
+    re.DOTALL,
+)
+_DSML_ATTR_RE = re.compile(r'([A-Za-z_][\w:-]*)="([^"]*)"')
+_DSML_BOILERPLATE_RE = re.compile(
+    r"(commands?\s*(列表|list).*(注册|register)|注册.*commands?\s*(列表|list))",
+    re.IGNORECASE,
+)
+
+
+async def stream_llm(
+    model,
+    messages: list,
+    renderer: StreamingRenderer,
+    protocol: str = "",
+) -> AIMessage:
+    """Stream LLM response, render live, return merged AIMessage."""
+    from voidx.llm.provider import extract_thinking
+
+    chunks: list[AIMessageChunk] = []
+    renderer.start()
+
+    try:
+        async for chunk in model.astream(_sanitize_messages_for_replay(messages)):
+            chunks.append(chunk)
+            content = chunk.content
+            if isinstance(content, str) and content:
+                if _should_render_text_chunk(content):
+                    renderer.feed_text(content)
+            elif isinstance(content, list):
+                for item in content:
+                    if isinstance(item, dict) and item.get("type") == "text":
+                        text = item.get("text", "")
+                        if isinstance(text, str) and _should_render_text_chunk(text):
+                            renderer.feed_text(text)
+            thinking = extract_thinking(chunk, protocol)
+            if thinking:
+                renderer.feed_thinking(thinking)
+    except Exception:
+        renderer.discard()
+        raise
+    finally:
+        renderer.done()
+
+    if not chunks:
+        return AIMessage(content="")
+
+    merged = chunks[0]
+    for c in chunks[1:]:
+        merged = merged + c
+
+    _, dsml_tool_calls = _extract_dsml_tool_calls(merged.content)
+    content = _sanitize_ai_content_for_replay(merged.content)
+    tool_calls = merged.tool_calls or dsml_tool_calls
+    kwargs = {
+        "content": content,
+        "tool_calls": tool_calls,
+        "response_metadata": merged.response_metadata,
+        "additional_kwargs": merged.additional_kwargs,
+    }
+    usage_metadata = getattr(merged, "usage_metadata", None)
+    if usage_metadata:
+        kwargs["usage_metadata"] = usage_metadata
+    return AIMessage(**kwargs)
+
+
+def _sanitize_messages_for_replay(messages: list) -> list:
+    """Remove reasoning-only blocks before replaying assistant history."""
+    sanitized = []
+    for message in messages:
+        if isinstance(message, AIMessage):
+            content = _sanitize_ai_content_for_replay(message.content)
+            if _is_empty_content(content) and not getattr(message, "tool_calls", None):
+                continue
+            if content != message.content:
+                sanitized.append(message.model_copy(update={"content": content}))
+                continue
+        sanitized.append(message)
+    return _repair_tool_result_adjacency(sanitized)
+
+
+def _repair_tool_result_adjacency(messages: list) -> list:
+    repaired = []
+    i = 0
+
+    while i < len(messages):
+        message = messages[i]
+        if isinstance(message, ToolMessage):
+            i += 1
+            continue
+
+        repaired.append(message)
+        if not isinstance(message, AIMessage):
+            i += 1
+            continue
+
+        tool_call_ids = _ai_tool_call_ids(message)
+        if not tool_call_ids:
+            i += 1
+            continue
+
+        seen: set[str] = set()
+        j = i + 1
+        while j < len(messages) and isinstance(messages[j], ToolMessage):
+            tool_message = messages[j]
+            tool_call_id = str(getattr(tool_message, "tool_call_id", "") or "")
+            if tool_call_id in tool_call_ids and tool_call_id not in seen:
+                repaired.append(tool_message)
+                seen.add(tool_call_id)
+            j += 1
+
+        for tool_call_id in tool_call_ids:
+            if tool_call_id not in seen:
+                repaired.append(ToolMessage(
+                    content="Tool result unavailable: previous tool call was not executed.",
+                    tool_call_id=tool_call_id,
+                ))
+
+        i = j
+
+    return repaired
+
+
+def _ai_tool_call_ids(message: AIMessage) -> list[str]:
+    ids: list[str] = []
+
+    for call in getattr(message, "tool_calls", None) or []:
+        if isinstance(call, dict) and call.get("id"):
+            ids.append(str(call["id"]))
+
+    content = message.content
+    if isinstance(content, list):
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "tool_use" and item.get("id"):
+                ids.append(str(item["id"]))
+
+    result: list[str] = []
+    seen: set[str] = set()
+    for tool_call_id in ids:
+        if tool_call_id not in seen:
+            result.append(tool_call_id)
+            seen.add(tool_call_id)
+    return result
+
+
+def _sanitize_ai_content_for_replay(content: object) -> object:
+    if isinstance(content, str):
+        cleaned, _ = _extract_dsml_tool_calls_from_text(content)
+        return cleaned
+    if not isinstance(content, list):
+        return content
+
+    blocks: list[object] = []
+    text_parts: list[str] = []
+    has_non_text = False
+
+    def flush_text() -> None:
+        if text_parts:
+            blocks.append({"type": "text", "text": "".join(text_parts)})
+            text_parts.clear()
+
+    for item in content:
+        if isinstance(item, str):
+            if item:
+                cleaned, _ = _extract_dsml_tool_calls_from_text(item)
+                if cleaned:
+                    text_parts.append(cleaned)
+            continue
+        if not isinstance(item, dict):
+            if item is not None:
+                text_parts.append(str(item))
+            continue
+
+        block_type = item.get("type")
+        if block_type in _REPLAY_UNSAFE_BLOCK_TYPES:
+            continue
+        if block_type == "text":
+            text = item.get("text", "")
+            if isinstance(text, str) and text:
+                cleaned, _ = _extract_dsml_tool_calls_from_text(text)
+                if cleaned:
+                    text_parts.append(cleaned)
+            continue
+
+        flush_text()
+        blocks.append(item)
+        has_non_text = True
+
+    if not has_non_text:
+        return "".join(text_parts)
+
+    flush_text()
+    return blocks
+
+
+def _is_empty_content(content: object) -> bool:
+    if content is None:
+        return True
+    if isinstance(content, str):
+        return content == ""
+    if isinstance(content, list):
+        return not content
+    return False
+
+
+def _should_render_text_chunk(text: str) -> bool:
+    normalized = _normalize_dsml(text).strip()
+    if "DSML" in normalized and "<|" in normalized:
+        return False
+    return not _DSML_BOILERPLATE_RE.search(normalized)
+
+
+def _extract_dsml_tool_calls(content: object) -> tuple[object, list[dict]]:
+    if isinstance(content, str):
+        return _extract_dsml_tool_calls_from_text(content)
+    if not isinstance(content, list):
+        return content, []
+
+    blocks: list[object] = []
+    calls: list[dict] = []
+    for item in content:
+        if isinstance(item, str):
+            cleaned, found = _extract_dsml_tool_calls_from_text(item)
+            calls.extend(found)
+            if cleaned:
+                blocks.append(cleaned)
+            continue
+        if isinstance(item, dict) and item.get("type") == "text":
+            text = item.get("text", "")
+            if isinstance(text, str):
+                cleaned, found = _extract_dsml_tool_calls_from_text(text)
+                calls.extend(found)
+                if cleaned:
+                    updated = dict(item)
+                    updated["text"] = cleaned
+                    blocks.append(updated)
+                continue
+        blocks.append(item)
+
+    return (blocks if blocks else ""), calls
+
+
+def _extract_dsml_tool_calls_from_text(text: str) -> tuple[str, list[dict]]:
+    normalized = _normalize_dsml(text)
+    calls: list[dict] = []
+
+    for block_match in _DSML_TOOL_CALLS_RE.finditer(normalized):
+        block = block_match.group(0)
+        for invoke_match in _DSML_INVOKE_RE.finditer(block):
+            attrs = _parse_dsml_attrs(invoke_match.group(1))
+            name = attrs.get("name", "").strip()
+            if not name:
+                continue
+            args: dict[str, object] = {}
+            body = invoke_match.group(2)
+            for param_match in _DSML_PARAMETER_RE.finditer(body):
+                param_attrs = _parse_dsml_attrs(param_match.group(1))
+                param_name = param_attrs.get("name", "").strip()
+                if not param_name:
+                    continue
+                args[param_name] = _decode_dsml_parameter(param_match.group(2), param_attrs)
+            calls.append({
+                "name": name,
+                "args": args,
+                "id": f"call_dsml_{uuid.uuid4().hex[:12]}",
+                "type": "tool_call",
+            })
+
+    cleaned = _DSML_TOOL_CALLS_RE.sub("", normalized).strip()
+    if calls and _DSML_BOILERPLATE_RE.search(cleaned) and len(cleaned) <= 160:
+        cleaned = ""
+    return cleaned, calls
+
+
+def _normalize_dsml(text: str) -> str:
+    return text.replace("｜", "|")
+
+
+def _parse_dsml_attrs(raw: str) -> dict[str, str]:
+    return {key: html.unescape(value) for key, value in _DSML_ATTR_RE.findall(raw)}
+
+
+def _decode_dsml_parameter(raw: str, attrs: dict[str, str]) -> object:
+    value = html.unescape(raw)
+    stripped = value.strip()
+
+    if attrs.get("boolean", "").lower() == "true":
+        return stripped.lower() == "true"
+    if attrs.get("integer", "").lower() == "true":
+        try:
+            return int(stripped)
+        except ValueError:
+            return stripped
+    if attrs.get("number", "").lower() == "true":
+        try:
+            return float(stripped)
+        except ValueError:
+            return stripped
+    if attrs.get("json", "").lower() == "true":
+        try:
+            return json.loads(stripped)
+        except json.JSONDecodeError:
+            return stripped
+    if attrs.get("string", "").lower() == "true":
+        return value
+
+    try:
+        return json.loads(stripped)
+    except json.JSONDecodeError:
+        return value
+
+
+def extract_text(msg) -> str:
+    content = msg.content if hasattr(msg, "content") else str(msg)
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                parts.append(item.get("text", ""))
+        return "".join(parts)
+    return str(content)

voidx/agent/graph_components/subagent.py

@@ -0,0 +1,278 @@
+"""Child agent execution loop."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
+
+from voidx.agent.agents import BASE_SYSTEM_PROMPT, PLAN_MODE_APPEND, AgentDef
+from voidx.agent.graph_components.runtime import console, ui
+from voidx.agent.graph_components.streaming import extract_text, stream_llm
+from voidx.agent.runtime_context import InteractionMode, RuntimeContextBuilder
+from voidx.agent.tool_filters import filter_unavailable_lsp_tools
+from voidx.config import Config
+from voidx.llm.provider import create_chat_model, resolve_protocol
+from voidx.llm.usage import (
+    UsageStats,
+    estimate_context_tokens,
+    estimate_message_tokens,
+    extract_token_usage,
+)
+from voidx.memory.context_frames import save_context_frame_from_messages
+from voidx.skills.registry import SkillRegistry
+from voidx.skills.service import SkillService
+from voidx.tools.base import ToolContext
+from voidx.tools.registry import ToolRegistry
+from voidx.tools.task_tracker import TaskTracker
+from voidx.ui.capture import CaptureConsole
+from voidx.ui.tree import OutputTree
+from voidx.ui.console import StreamingRenderer
+
+
+async def run_subagent(
+    agent_def: AgentDef,
+    task_description: str,
+    model_override: str | None,
+    api_key: str,
+    config: Config,
+    tracker: TaskTracker | None = None,
+    capture_tree: OutputTree | None = None,
+    parent_node=None,
+    parent_messages: list | None = None,
+    sub_messages: list | None = None,
+    authorize_tools=None,
+    debug: bool = True,
+    agent_id: int = -1,
+    session_id: str | None = None,
+    usage_stats: UsageStats | None = None,
+    lsp_manager=None,
+    skill_selection=None,
+) -> str:
+    """Run a child agent. Child messages are appended to sub_messages
+    (when provided) so the caller can place them after ToolMessages."""
+    model_cfg = config.model.model_copy()
+    if model_override:
+        model_cfg.model = model_override
+    elif agent_def.model:
+        model_cfg.model = agent_def.model
+
+    # Child agents use their own tool registry and cannot start nested agents.
+    agent_tools = ToolRegistry()
+    all_tool_ids = agent_tools.ids()
+    for tid in list(all_tool_ids):
+        if tid not in agent_def.tools and tid != "agent":
+            agent_tools._tools.pop(tid, None)
+            agent_tools._instances.pop(tid, None)
+    agent_tools._tools.pop("agent", None)
+    agent_tools._instances.pop("agent", None)
+    agent_tools._tools.pop("task_status", None)
+    agent_tools._instances.pop("task_status", None)
+
+    model = create_chat_model(api_key, model_cfg)
+    tool_defs = [
+        t for t in agent_tools.tools_for_llm()
+        if t["function"]["name"] not in ("agent", "task_status")
+    ]
+    tool_defs = filter_unavailable_lsp_tools(tool_defs, lsp_manager)
+
+    if sub_messages is None:
+        sub_messages = []
+
+    if parent_messages is not None:
+        messages = []
+        # Copy parent context: skip system prompts, agent-spawning AIMessages,
+        # and their orphaned ToolMessages.
+        skipped_ids: set[str] = set()
+        for m in parent_messages:
+            if isinstance(m, AIMessage) and m.tool_calls:
+                for tc in m.tool_calls:
+                    name = tc.get("name") if isinstance(tc, dict) else getattr(tc, "name", "")
+                    if name == "agent":
+                        tc_id = tc.get("id") if isinstance(tc, dict) else getattr(tc, "id", "")
+                        if tc_id:
+                            skipped_ids.add(tc_id)
+        for m in parent_messages:
+            if isinstance(m, SystemMessage):
+                continue
+            if isinstance(m, AIMessage) and m.tool_calls:
+                if any(
+                    (tc.get("name") if isinstance(tc, dict) else getattr(tc, "name", "")) == "agent"
+                    for tc in m.tool_calls
+                ):
+                    continue
+            if isinstance(m, ToolMessage):
+                tc_id = getattr(m, "tool_call_id", "")
+                if tc_id in skipped_ids:
+                    continue
+            content = m.content
+            if isinstance(content, list):
+                text_parts = [
+                    item.get("text", "") for item in content
+                    if isinstance(item, dict) and item.get("type") == "text"
+                ]
+                if isinstance(m, AIMessage):
+                    messages.append(AIMessage(content="".join(text_parts), tool_calls=m.tool_calls))
+                elif isinstance(m, HumanMessage):
+                    messages.append(HumanMessage(content="".join(text_parts)))
+                elif isinstance(m, ToolMessage):
+                    messages.append(ToolMessage(content="".join(text_parts), tool_call_id=getattr(m, "tool_call_id", "")))
+                else:
+                    messages.append(type(m)(content="".join(text_parts)))
+            else:
+                messages.append(m)
+        messages.append(HumanMessage(content=task_description))
+    else:
+        messages = [HumanMessage(content=task_description)]
+
+    context_config = config.model_copy(deep=True)
+    context_config.model = model_cfg
+    interaction_mode = InteractionMode.PLAN.value if agent_def.name == "plan" else InteractionMode.AUTO.value
+    mode_prompt = PLAN_MODE_APPEND if InteractionMode.parse(interaction_mode) == InteractionMode.PLAN else ""
+    task_intent = _task_intent_for_agent(agent_def.name)
+    skill_service = SkillService(
+        SkillRegistry(config.workspace),
+        selection=skill_selection,
+    )
+    skill_matches = skill_service.select(
+        task_description,
+        agent=agent_def.name,
+        task_intent=task_intent,
+        interaction_mode=interaction_mode,
+    )
+    RuntimeContextBuilder(
+        config=context_config,
+        workspace=config.workspace,
+        base_system_prompt=BASE_SYSTEM_PROMPT,
+        role_prompt=agent_def.role_prompt,
+        mode_prompt=mode_prompt,
+        tool_contract=agent_def.tool_contract,
+        agent=agent_def.name,
+        interaction_mode=interaction_mode,
+        skill_instructions=[skill_service.render_instruction(match.skill) for match in skill_matches],
+        active_skill_summaries=[f"{match.name} ({match.reason})" for match in skill_matches],
+        current_user_text=task_description,
+        task_intent=task_intent,
+        agent_id=agent_id,
+    ).build().apply_to_messages(messages)
+
+    ctx = ToolContext(
+        workspace=config.workspace,
+        lsp_manager=lsp_manager,
+        sandbox_extra_paths=config.sandbox_workspace_write,
+    )
+
+    # Register with tracker
+    task_id = f"sub_{agent_def.name}_{int(time.time())}"
+    if tracker:
+        tracker.start(task_id, agent_def.name, task_description, agent_def.max_steps)
+
+    try:
+        for step in range(1, agent_def.max_steps + 1):
+            if tracker:
+                tracker.update(task_id, step=step)
+
+            if capture_tree and parent_node is not None:
+                capture = CaptureConsole(capture_tree, parent_node, agent_id=agent_id)
+                capture.step_header(step, agent_def.max_steps, agent_def.name)
+            else:
+                ui.step_header(step, agent_def.max_steps, agent_def.name)
+
+            active_tool_defs = tool_defs if step < agent_def.max_steps else []
+            model_with_tools = model.bind_tools(active_tool_defs) if active_tool_defs else model
+            renderer = StreamingRenderer(console, debug=debug, agent_id=agent_id)
+            context_tokens = estimate_context_tokens(messages, config.model.model)
+            if usage_stats is not None:
+                usage_stats.update_context(context_tokens)
+            if session_id:
+                await save_context_frame_from_messages(
+                    session_id=session_id,
+                    frame_kind="worker",
+                    agent_role=agent_def.name,
+                    provider=config.model.provider,
+                    model=config.model.model,
+                    messages=messages,
+                    token_estimate=context_tokens,
+                    metadata={
+                        "step": step,
+                        "max_steps": agent_def.max_steps,
+                        "tool_count": len(active_tool_defs),
+                        "agent_id": agent_id,
+                    },
+                )
+            assistant_msg = await stream_llm(
+                model_with_tools,
+                messages,
+                renderer,
+                resolve_protocol(config.model),
+            )
+            if usage_stats is not None:
+                usage_stats.record_call(
+                    extract_token_usage(assistant_msg),
+                    fallback_input_tokens=context_tokens,
+                    fallback_output_tokens=estimate_message_tokens(assistant_msg, config.model.model),
+                    messages=messages,
+                    model=config.model.model,
+                    cache_key=f"{config.model.provider}/{config.model.model}",
+                )
+            messages.append(assistant_msg)
+            sub_messages.append(assistant_msg)
+
+            if not assistant_msg.tool_calls:
+                text = extract_text(assistant_msg)
+                if tracker:
+                    tracker.update(task_id, last_output=text[:200])
+                    tracker.finish(task_id, "completed")
+                return text
+
+            # Update tracker with preview
+            text_preview = extract_text(assistant_msg)[:200]
+            if tracker and text_preview:
+                tracker.update(task_id, last_output=text_preview)
+
+            if authorize_tools:
+                approved, denied = await authorize_tools(assistant_msg.tool_calls, agent_def.name)
+            else:
+                approved = list(assistant_msg.tool_calls)
+                denied = []
+
+            async def run_one(tc):
+                tid = tc.get("name", "")
+                targs = tc.get("args", {})
+                cid = tc.get("id", "")
+                if capture_tree and parent_node is not None:
+                    capture.tool_call(tid, targs, tool_call_id=cid)
+                result = await agent_tools.execute_tool(tid, targs, ctx)
+                if capture_tree and parent_node is not None:
+                    capture.tool_done(tid, 0.0, True, tool_call_id=cid)
+                    capture.tool_result(result.output, tool_call_id=cid)
+                return ToolMessage(content=result.output, tool_call_id=cid)
+
+            tool_msgs = await asyncio.gather(*[run_one(tc) for tc in approved])
+            denied_msgs = [
+                ToolMessage(content=reason, tool_call_id=tc.get("id", ""))
+                for tc, reason in denied
+            ]
+            messages.extend(tool_msgs + denied_msgs)
+            sub_messages.extend(tool_msgs + denied_msgs)
+
+        if tracker:
+            tracker.finish(task_id, "completed")
+        return extract_text(messages[-1]) if messages else "Max steps reached."
+
+    except Exception as e:
+        if tracker:
+            tracker.update(task_id, last_output=str(e)[:200])
+            tracker.finish(task_id, "error")
+        raise
+
+
+def _task_intent_for_agent(agent_name: str) -> str:
+    if agent_name == "implement":
+        return "implement"
+    if agent_name == "review":
+        return "review"
+    if agent_name == "plan":
+        return "design"
+    return "inspect"