yycode 0.3.2__py3-none-any.whl

agent/message_format.py

@@ -0,0 +1,105 @@
+"""Helpers for converting LangChain messages into provider-neutral payloads."""
+
+from typing import Any
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, ToolMessage
+
+
+def messages_to_provider_format(messages: list[BaseMessage]) -> list[dict]:
+    """Convert LangChain messages to the provider-neutral format used by providers."""
+    provider_messages: list[dict] = []
+    index = 0
+    while index < len(messages):
+        msg = messages[index]
+        if isinstance(msg, HumanMessage):
+            provider_messages.append({"role": "user", "content": msg.content})
+        elif isinstance(msg, AIMessage):
+            assistant_message = {
+                "role": "assistant",
+                "content": _assistant_content(msg),
+            }
+            reasoning_content = _assistant_reasoning_content(msg)
+            if reasoning_content:
+                assistant_message["reasoning_content"] = reasoning_content
+            provider_messages.append(assistant_message)
+        elif isinstance(msg, ToolMessage):
+            tool_results: list[dict[str, Any]] = []
+            while index < len(messages) and isinstance(messages[index], ToolMessage):
+                tool_msg = messages[index]
+                tool_results.append(
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": tool_msg.tool_call_id,
+                        "content": tool_msg.content,
+                    }
+                )
+                index += 1
+            provider_messages.append(
+                {
+                    "role": "user",
+                    "content": tool_results,
+                }
+            )
+            continue
+        index += 1
+    return provider_messages
+
+
+def _assistant_content(message: AIMessage) -> Any:
+    provider_blocks = message.additional_kwargs.get("provider_blocks")
+    tool_calls = message.additional_kwargs.get("tool_calls_data") or message.tool_calls or []
+    if provider_blocks:
+        content_blocks = [
+            block
+            for block in provider_blocks
+            if not (
+                isinstance(block, dict)
+                and block.get("type") in {"reasoning_content", "tool_use"}
+            )
+        ]
+        content_blocks.extend(_tool_use_blocks(tool_calls))
+        return content_blocks or message.content
+
+    if not tool_calls:
+        return message.content
+
+    content: list[dict[str, Any]] = []
+    if message.content:
+        content.append({"type": "text", "text": str(message.content)})
+    content.extend(_tool_use_blocks(tool_calls))
+    return content
+
+
+def _assistant_reasoning_content(message: AIMessage) -> str | None:
+    reasoning_content = message.additional_kwargs.get("reasoning_content")
+    if reasoning_content:
+        return str(reasoning_content)
+
+    provider_blocks = message.additional_kwargs.get("provider_blocks") or []
+    for block in provider_blocks:
+        if not isinstance(block, dict) or block.get("type") != "reasoning_content":
+            continue
+        value = block.get("reasoning_content") or block.get("text")
+        if value:
+            return str(value)
+    return None
+
+
+def _tool_use_blocks(tool_calls: list[Any]) -> list[dict[str, Any]]:
+    blocks: list[dict[str, Any]] = []
+    for tool_call in tool_calls:
+        blocks.append(
+            {
+                "type": "tool_use",
+                "id": _tool_call_field(tool_call, "id"),
+                "name": _tool_call_field(tool_call, "name"),
+                "input": _tool_call_field(tool_call, "args") or {},
+            }
+        )
+    return blocks
+
+
+def _tool_call_field(tool_call: Any, field: str) -> Any:
+    if isinstance(tool_call, dict):
+        return tool_call.get(field)
+    return getattr(tool_call, field, None)

agent/nodes/llm_node.py

@@ -0,0 +1,58 @@
+"""LLM graph node."""
+
+from langchain_core.messages import AIMessage
+
+from agent.llm_retry import chat_with_retry
+from agent.message_format import messages_to_provider_format
+from agent.nodes.state import AgentState
+from agent.runtime.context import AgentRuntimeContext
+from agent.streaming import StreamEvent, make_provider_stream_callback
+
+
+def create_llm_node(runtime: AgentRuntimeContext):
+    """Create LLM node with given runtime."""
+    provider_stream_callback = make_provider_stream_callback(
+        runtime.stream_callback,
+        source="main",
+        session_id=runtime.session_id,
+    )
+
+    async def llm_node(state: AgentState) -> AgentState:
+        response = await chat_with_retry(
+            runtime.provider,
+            messages=messages_to_provider_format(state["messages"]),
+            tools=runtime.tools,
+            system_prompt=runtime.system_prompt,
+            stream_callback=provider_stream_callback,
+            event_callback=runtime.stream_callback,
+            source="main",
+            session_id=runtime.session_id,
+        )
+        if runtime.stream_callback and response.usage:
+            await runtime.stream_callback(
+                StreamEvent(
+                    source="main",
+                    session_id=runtime.session_id,
+                    event_type="usage",
+                    usage=response.usage,
+                )
+            )
+
+        tool_calls = [
+            {
+                "name": tc.name,
+                "args": dict(tc.args or {}),
+                "id": tc.id,
+            }
+            for tc in response.tool_calls
+        ]
+
+        ai_msg = AIMessage(content=response.content, tool_calls=tool_calls)
+        ai_msg.additional_kwargs["tool_calls_data"] = response.tool_calls
+        if response.content_blocks:
+            ai_msg.additional_kwargs["provider_blocks"] = response.content_blocks
+        ai_msg.additional_kwargs["raw_response"] = response.raw_response
+        ai_msg.additional_kwargs["usage"] = response.usage
+        return {"messages": [ai_msg]}
+
+    return llm_node

agent/nodes/state.py

@@ -0,0 +1,12 @@
+"""Shared LangGraph state types."""
+
+from typing import Annotated, TypedDict
+
+from langchain_core.messages import BaseMessage
+from langgraph.graph.message import add_messages
+
+
+class AgentState(TypedDict):
+    """Agent graph state."""
+
+    messages: Annotated[list[BaseMessage], add_messages]

agent/nodes/task_guard_node.py

@@ -0,0 +1,50 @@
+"""Task State guard graph node."""
+
+from typing import Literal
+
+from langchain_core.messages import HumanMessage
+from langgraph.graph import END
+
+from agent.nodes.state import AgentState
+from agent.todo_manager import TodoManager
+
+
+def create_task_guard_node(todo_manager: TodoManager):
+    """Create a guard node that prevents finishing before Task State is complete."""
+
+    async def task_guard_node(state: AgentState) -> AgentState:
+        if not todo_manager.has_incomplete_task_state():
+            return {"messages": []}
+        return {
+            "messages": [
+                HumanMessage(
+                    content=todo_manager.get_finish_blocker_message(),
+                    additional_kwargs={
+                        "context_ephemeral": True,
+                        "ephemeral_kind": "task_guard",
+                    },
+                )
+            ]
+        }
+
+    return task_guard_node
+
+
+def route_after_llm(state: AgentState) -> Literal["tools", "task_guard"]:
+    """Route to tools when the model requested tools, otherwise to task guard."""
+    last_msg = state["messages"][-1]
+    tool_calls_data = last_msg.additional_kwargs.get("tool_calls_data", [])
+    return "tools" if tool_calls_data else "task_guard"
+
+
+def route_after_tools(state: AgentState) -> Literal["llm", END]:
+    """End when tools preserved a final answer after completing Task State."""
+    last_msg = state["messages"][-1]
+    if last_msg.additional_kwargs.get("task_completed_final") is True:
+        return END
+    return "llm"
+
+
+def route_after_task_guard(state: AgentState, todo_manager: TodoManager) -> Literal["llm", END]:
+    """Route after task guard."""
+    return END if not todo_manager.has_incomplete_task_state() else "llm"

agent/nodes/tools_node.py

@@ -0,0 +1,70 @@
+"""Tools graph node."""
+
+from langchain_core.messages import AIMessage, HumanMessage
+
+from agent.nodes.state import AgentState
+from agent.runtime.approval_service import ApprovalService
+from agent.runtime.context import AgentRuntimeContext
+from agent.runtime.tool_executor import ToolExecutor
+from agent.runtime.tool_registry import RuntimeToolRegistry
+from agent.runtime.tool_scheduler import execute_tool_calls
+from agent.runtime.workflow_guard import WorkflowGuard
+
+
+def create_tools_node(runtime: AgentRuntimeContext):
+    """Create tools node with runtime-bound handlers."""
+    registry = RuntimeToolRegistry(runtime)
+    workflow_guard = WorkflowGuard(runtime, registry)
+    approval_service = ApprovalService(
+        runtime.approval_callback,
+        runtime.workflow_state,
+        runtime.stream_callback,
+        runtime.session_id,
+        source=runtime.source,
+        role=runtime.role,
+        parent_session_id=runtime.parent_session_id,
+        workdir=runtime.workdir,
+    )
+    executor = ToolExecutor(runtime, registry, workflow_guard, approval_service)
+
+    async def tools_node(state: AgentState) -> AgentState:
+        last_msg = state["messages"][-1]
+        tool_calls_data = last_msg.additional_kwargs.get("tool_calls_data", [])
+        tool_messages = await execute_tool_calls(
+            tool_calls_data,
+            executor.execute,
+            registry.can_run_concurrently,
+        )
+
+        if tool_calls_data:
+            if any(tc.name == "todo" for tc in tool_calls_data):
+                runtime.todo_manager.record_tool_call("todo")
+            else:
+                runtime.todo_manager.record_tool_call(tool_calls_data[0].name)
+
+        additional_messages = workflow_guard.after_batch_messages(tool_calls_data)
+        repeated_todo_message = runtime.todo_manager.consume_repeated_incomplete_message()
+        if repeated_todo_message:
+            additional_messages.append(
+                HumanMessage(
+                    content=repeated_todo_message,
+                    additional_kwargs={
+                        "context_ephemeral": True,
+                        "ephemeral_kind": "task_repeated_reminder",
+                    },
+                )
+            )
+        if (
+            any(tc.name == "todo" for tc in tool_calls_data)
+            and runtime.todo_manager.can_finish_task()
+            and str(last_msg.content or "").strip()
+        ):
+            additional_messages.append(
+                AIMessage(
+                    content=last_msg.content,
+                    additional_kwargs={"task_completed_final": True},
+                )
+            )
+        return {"messages": tool_messages + additional_messages}
+
+    return tools_node

agent/plan_snapshot.py

@@ -0,0 +1,70 @@
+"""Shared task plan snapshot models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+from agent.todo_manager import TodoManager
+
+
+PlanStatus = Literal["pending", "in_progress", "completed"]
+
+
+@dataclass(frozen=True)
+class PlanEntry:
+    """One stable task plan entry for UI/protocol adapters."""
+
+    id: str
+    title: str
+    status: PlanStatus
+    priority: str = "medium"
+
+
+@dataclass(frozen=True)
+class PlanSnapshot:
+    """Public snapshot of the current task plan and compact memory."""
+
+    entries: list[PlanEntry] = field(default_factory=list)
+    memory: dict[str, Any] = field(default_factory=dict)
+    updated_at: str = ""
+    task_started: bool = False
+    task_completed: bool = False
+
+
+def build_plan_snapshot(todo_manager: TodoManager | None) -> PlanSnapshot:
+    """Return a stable task plan snapshot independent of any UI renderer."""
+    if todo_manager is None:
+        return PlanSnapshot(updated_at=_utc_now())
+    state = todo_manager.get_task_state()
+    raw_items = state.get("items") or []
+    entries = [
+        PlanEntry(
+            id=str(item.get("id") or index + 1),
+            title=str(item.get("text") or ""),
+            status=_normalize_status(item.get("status")),
+            priority="high" if item.get("status") == "in_progress" else "medium",
+        )
+        for index, item in enumerate(raw_items)
+        if isinstance(item, dict)
+    ]
+    return PlanSnapshot(
+        entries=entries,
+        memory=dict(state.get("memory") or {}),
+        updated_at=_utc_now(),
+        task_started=bool(todo_manager.task_state_started),
+        task_completed=bool(todo_manager.task_completed),
+    )
+
+
+def _normalize_status(value: object) -> PlanStatus:
+    if value == "completed":
+        return "completed"
+    if value == "in_progress":
+        return "in_progress"
+    return "pending"
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")

agent/providers/__init__.py

@@ -0,0 +1,13 @@
+"""LLM providers package."""
+
+from .base import LLMProvider, ChatResponse, ToolCall
+from .anthropic_provider import AnthropicProvider
+from .openai_provider import OpenAIProvider
+
+__all__ = [
+    "LLMProvider",
+    "ChatResponse",
+    "ToolCall",
+    "AnthropicProvider",
+    "OpenAIProvider",
+]

agent/providers/anthropic_provider.py

@@ -0,0 +1,268 @@
+"""Anthropic LLM provider implementation."""
+
+import json
+from typing import Any, Optional, Callable
+
+from anthropic import AsyncAnthropic
+
+from agent.logger import get_logger
+
+from .base import LLMProvider, ChatResponse, ToolCall
+from .text_tool_calls import TextToolCallStreamFilter, parse_text_tool_calls
+
+logger = get_logger(__name__)
+
+
+class AnthropicProvider(LLMProvider):
+    """Anthropic Claude API provider."""
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str,
+        base_url: Optional[str] = None,
+    ):
+        self.model = model
+        self.client = AsyncAnthropic(
+            api_key=api_key,
+            base_url=base_url
+        )
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system_prompt: Optional[str] = None,
+        stream_callback: Optional[Callable[[str, str], None]] = None,
+    ) -> ChatResponse:
+        """Send chat request to Anthropic API."""
+        import traceback
+
+        kwargs = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": 8000,
+        }
+        if system_prompt:
+            kwargs["system"] = system_prompt
+        if tools:
+            kwargs["tools"] = tools
+
+        try:
+            # First try non-streaming mode (more reliable for compatible APIs)
+            return await self._chat_non_streaming(kwargs, stream_callback)
+        except Exception as e:
+            logger.warning(f"Non-streaming failed, trying streaming: {e}")
+            try:
+                return await self._chat_streaming(kwargs, stream_callback)
+            except Exception as e2:
+                logger.error(f"Both modes failed. Last error: {type(e2).__name__}: {e2}")
+                logger.error(f"Traceback:\n{traceback.format_exc()}")
+                raise
+
+    async def _chat_non_streaming(
+        self,
+        kwargs: dict,
+        stream_callback: Optional[Callable[[str, str], None]] = None,
+    ) -> ChatResponse:
+        """Non-streaming chat mode."""
+        message = await self.client.messages.create(**kwargs)
+
+        current_text = ""
+        tool_calls_data = []
+        text_filter = TextToolCallStreamFilter()
+
+        for block in message.content:
+            if block.type == "text":
+                current_text += block.text
+                if stream_callback:
+                    for safe_text in text_filter.feed(block.text):
+                        await stream_callback("text_delta", safe_text)
+            elif block.type == "tool_use":
+                tool_calls_data.append({
+                    "name": block.name,
+                    "args": block.input,
+                    "id": block.id,
+                })
+
+        usage = self._extract_usage(getattr(message, "usage", None))
+        content_blocks = self._normalize_content_blocks(message.content)
+
+        tool_calls = [
+            ToolCall(id=tc["id"], name=tc["name"], args=tc["args"])
+            for tc in tool_calls_data
+        ]
+        cleaned_text, text_tool_calls = parse_text_tool_calls(current_text)
+        if text_tool_calls:
+            current_text = cleaned_text
+            tool_calls.extend(text_tool_calls)
+        elif stream_callback:
+            for safe_text in text_filter.flush():
+                await stream_callback("text_delta", safe_text)
+
+        return ChatResponse(
+            content=current_text,
+            tool_calls=tool_calls,
+            content_blocks=content_blocks,
+            raw_response=message,
+            usage=usage,
+        )
+
+    async def _chat_streaming(
+        self,
+        kwargs: dict,
+        stream_callback: Optional[Callable[[str, str], None]] = None,
+    ) -> ChatResponse:
+        """Streaming chat mode (fallback)."""
+        current_text = ""
+        tool_calls_data = []
+        current_tool_use = None
+        in_thinking = False
+        text_filter = TextToolCallStreamFilter()
+
+        async with self.client.messages.stream(**kwargs) as stream:
+            async for event in stream:
+                if event.type == "content_block_start":
+                    block = event.content_block
+                    if block.type == "thinking":
+                        in_thinking = True
+                        if stream_callback:
+                            await stream_callback("thinking_start", "")
+                    elif block.type == "text":
+                        in_thinking = False
+                    elif block.type == "tool_use":
+                        in_thinking = False
+                        current_tool_use = {
+                            "name": block.name,
+                            "id": block.id,
+                            "args": "",
+                        }
+                elif event.type == "content_block_delta":
+                    delta = event.delta
+                    if delta.type == "thinking_delta":
+                        if stream_callback:
+                            await stream_callback("thinking_delta", delta.thinking)
+                    elif delta.type == "text_delta":
+                        current_text += delta.text
+                        if stream_callback:
+                            for safe_text in text_filter.feed(delta.text):
+                                await stream_callback("text_delta", safe_text)
+                    elif delta.type == "input_json_delta":
+                        if current_tool_use:
+                            current_tool_use["args"] += delta.partial_json
+                elif event.type == "content_block_stop":
+                    if in_thinking:
+                        if stream_callback:
+                            await stream_callback("thinking_end", "")
+                        in_thinking = False
+                    elif current_tool_use:
+                        try:
+                            args = json.loads(current_tool_use["args"])
+                        except json.JSONDecodeError:
+                            args = {}
+                        tool_calls_data.append({
+                            "name": current_tool_use["name"],
+                            "args": args,
+                            "id": current_tool_use["id"],
+                        })
+                        current_tool_use = None
+
+            final_message = await stream.get_final_message()
+            usage = self._extract_usage(getattr(final_message, "usage", None))
+            content_blocks = self._normalize_content_blocks(final_message.content)
+
+        tool_calls = [
+            ToolCall(id=tc["id"], name=tc["name"], args=tc["args"])
+            for tc in tool_calls_data
+        ]
+        cleaned_text, text_tool_calls = parse_text_tool_calls(current_text)
+        if text_tool_calls:
+            current_text = cleaned_text
+            tool_calls.extend(text_tool_calls)
+        elif stream_callback:
+            for safe_text in text_filter.flush():
+                await stream_callback("text_delta", safe_text)
+
+        return ChatResponse(
+            content=current_text,
+            tool_calls=tool_calls,
+            content_blocks=content_blocks,
+            raw_response=final_message,
+            usage=usage,
+        )
+
+    async def close(self) -> None:
+        """Close the client."""
+        await self.client.close()
+
+    async def count_tokens(
+        self,
+        messages: list[dict],
+        system_prompt: Optional[str] = None,
+        tools: Optional[list[dict]] = None,
+    ) -> Optional[int]:
+        """Count input tokens using the Anthropic-compatible count endpoint."""
+        try:
+            kwargs = {
+                "model": self.model,
+                "messages": messages,
+            }
+            if system_prompt:
+                kwargs["system"] = system_prompt
+            if tools:
+                kwargs["tools"] = tools
+
+            response = await self.client.messages.count_tokens(**kwargs)
+            input_tokens = getattr(response, "input_tokens", None)
+            return int(input_tokens) if input_tokens is not None else None
+        except Exception:
+            logger.warning("Count tokens not supported, falling back to estimation")
+            return None
+
+    def _extract_usage(self, usage: Any) -> Optional[dict[str, int]]:
+        """Normalize Anthropic usage data."""
+        if usage is None:
+            return None
+        input_tokens = getattr(usage, "input_tokens", None)
+        output_tokens = getattr(usage, "output_tokens", None)
+        if input_tokens is None and output_tokens is None:
+            return None
+        return {
+            "input_tokens": input_tokens or 0,
+            "output_tokens": output_tokens or 0,
+            "total_tokens": (input_tokens or 0) + (output_tokens or 0),
+        }
+
+    def _normalize_content_blocks(self, blocks: Any) -> list[dict[str, Any]]:
+        """Convert Anthropic content blocks into provider-neutral serializable dicts."""
+        normalized: list[dict[str, Any]] = []
+        for block in blocks or []:
+            block_type = getattr(block, "type", None)
+            if block_type == "text":
+                normalized.append({"type": "text", "text": getattr(block, "text", "")})
+            elif block_type == "thinking":
+                thinking_block = {
+                    "type": "thinking",
+                    "thinking": getattr(block, "thinking", ""),
+                }
+                signature = getattr(block, "signature", None)
+                if signature:
+                    thinking_block["signature"] = signature
+                normalized.append(thinking_block)
+            elif block_type == "redacted_thinking":
+                data = {"type": "redacted_thinking"}
+                for field in ("data", "signature"):
+                    value = getattr(block, field, None)
+                    if value:
+                        data[field] = value
+                normalized.append(data)
+            elif block_type == "tool_use":
+                normalized.append(
+                    {
+                        "type": "tool_use",
+                        "id": getattr(block, "id", None),
+                        "name": getattr(block, "name", None),
+                        "input": getattr(block, "input", None) or {},
+                    }
+                )
+        return normalized