yycode 0.3.2__py3-none-any.whl

agent/providers/base.py

@@ -0,0 +1,52 @@
+"""Base LLM provider interface."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Optional, Callable
+
+
+@dataclass
+class ToolCall:
+    """Represents a tool call request."""
+    id: str
+    name: str
+    args: dict[str, Any]
+
+
+@dataclass
+class ChatResponse:
+    """Represents a chat response from LLM."""
+    content: str
+    tool_calls: list[ToolCall] = field(default_factory=list)
+    content_blocks: Optional[list[dict[str, Any]]] = None
+    raw_response: Any = None
+    usage: Optional[dict[str, int]] = None
+
+
+class LLMProvider(ABC):
+    """Abstract base class for LLM providers."""
+
+    @abstractmethod
+    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 a chat request with tool support."""
+        pass
+
+    async def count_tokens(
+        self,
+        messages: list[dict],
+        system_prompt: Optional[str] = None,
+        tools: Optional[list[dict]] = None,
+    ) -> Optional[int]:
+        """Return input token count when supported by the provider."""
+        return None
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the provider client."""
+        pass

agent/providers/openai_provider.py

@@ -0,0 +1,279 @@
+"""OpenAI LLM provider implementation."""
+
+import json
+from typing import Any, Optional, Callable
+
+from openai import AsyncOpenAI
+import tiktoken
+
+from .base import LLMProvider, ChatResponse, ToolCall
+from .text_tool_calls import TextToolCallStreamFilter, parse_text_tool_calls
+
+
+class OpenAIProvider(LLMProvider):
+    """OpenAI API provider (compatible with OpenAI-like APIs)."""
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str,
+        base_url: Optional[str] = None,
+    ):
+        self.model = model
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url
+        )
+
+    def _convert_messages(self, messages: list[dict]) -> list[dict]:
+        """Convert Anthropic-style messages to OpenAI format."""
+        openai_messages = []
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+
+            if role == "user":
+                if isinstance(content, list):
+                    text_parts = []
+                    for block in content:
+                        if block.get("type") == "tool_result":
+                            # OpenAI handles tool results differently
+                            openai_messages.append({
+                                "role": "tool",
+                                "tool_call_id": block["tool_use_id"],
+                                "content": block["content"],
+                            })
+                        elif block.get("type") == "text":
+                            text_parts.append(block["text"])
+                    if text_parts:
+                        openai_messages.append({
+                            "role": "user",
+                            "content": "\n".join(text_parts),
+                        })
+                else:
+                    openai_messages.append({"role": "user", "content": content})
+            elif role == "assistant":
+                if isinstance(content, list):
+                    text_parts = []
+                    tool_calls = []
+                    for block in content:
+                        if block.get("type") == "text":
+                            text_parts.append(block["text"])
+                        elif block.get("type") == "tool_use":
+                            tool_calls.append({
+                                "id": block["id"],
+                                "type": "function",
+                                "function": {
+                                    "name": block["name"],
+                                    "arguments": json.dumps(block["input"]),
+                                },
+                            })
+                    assistant_msg = {
+                        "role": "assistant",
+                        "content": "\n".join(text_parts) if text_parts else None,
+                    }
+                    if tool_calls:
+                        assistant_msg["tool_calls"] = tool_calls
+                    reasoning_content = msg.get("reasoning_content")
+                    if reasoning_content:
+                        assistant_msg["reasoning_content"] = reasoning_content
+                    openai_messages.append(assistant_msg)
+                else:
+                    assistant_msg = {"role": "assistant", "content": content}
+                    reasoning_content = msg.get("reasoning_content")
+                    if reasoning_content:
+                        assistant_msg["reasoning_content"] = reasoning_content
+                    openai_messages.append(assistant_msg)
+
+        return openai_messages
+
+    def _convert_tools(self, tools: list[dict]) -> list[dict]:
+        """Convert Anthropic-style tools to OpenAI format."""
+        openai_tools = []
+        for tool in tools:
+            openai_tools.append({
+                "type": "function",
+                "function": {
+                    "name": tool["name"],
+                    "description": tool["description"],
+                    "parameters": tool["input_schema"],
+                },
+            })
+        return openai_tools
+
+    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 OpenAI API."""
+        openai_messages = self._convert_messages(messages)
+        openai_tools = self._convert_tools(tools) if tools else None
+
+        if system_prompt:
+            openai_messages.insert(0, {"role": "system", "content": system_prompt})
+
+        current_text = ""
+        tool_calls_data = []
+        reasoning_content = None
+        usage = None
+
+        if stream_callback:
+            text_filter = TextToolCallStreamFilter()
+            stream = await self.client.chat.completions.create(
+                model=self.model,
+                messages=openai_messages,
+                tools=openai_tools,
+                stream=True,
+                stream_options={"include_usage": True},
+                max_tokens=4096,
+            )
+
+            current_tool_call = None
+
+            async for chunk in stream:
+                if getattr(chunk, "usage", None):
+                    usage = self._extract_usage(chunk.usage)
+                if not chunk.choices:
+                    continue
+                delta = chunk.choices[0].delta
+
+                delta_reasoning = getattr(delta, "reasoning_content", None)
+                if delta_reasoning:
+                    reasoning_content = (reasoning_content or "") + delta_reasoning
+
+                if delta.content:
+                    current_text += delta.content
+                    for safe_text in text_filter.feed(delta.content):
+                        await stream_callback("text_delta", safe_text)
+
+                if delta.tool_calls:
+                    for tc in delta.tool_calls:
+                        if tc.index >= len(tool_calls_data):
+                            tool_calls_data.append({
+                                "id": tc.id,
+                                "name": tc.function.name if tc.function else None,
+                                "args": "",
+                            })
+                            current_tool_call = tool_calls_data[-1]
+                        if tc.function and tc.function.arguments:
+                            current_tool_call["args"] += tc.function.arguments
+            for safe_text in text_filter.flush():
+                await stream_callback("text_delta", safe_text)
+        else:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=openai_messages,
+                tools=openai_tools,
+                stream=False,
+                max_tokens=4096,
+            )
+            usage = self._extract_usage(getattr(response, "usage", None))
+            choice = response.choices[0]
+            reasoning_content = getattr(choice.message, "reasoning_content", None)
+            if choice.message.content:
+                current_text = choice.message.content
+            if choice.message.tool_calls:
+                for tc in choice.message.tool_calls:
+                    tool_calls_data.append({
+                        "id": tc.id,
+                        "name": tc.function.name,
+                        "args": tc.function.arguments,
+                    })
+
+        tool_calls = []
+        for tc in tool_calls_data:
+            try:
+                args = json.loads(tc["args"]) if tc["args"] else {}
+            except json.JSONDecodeError:
+                args = {}
+            tool_calls.append(ToolCall(id=tc["id"], name=tc["name"], args=args))
+
+        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)
+
+        return ChatResponse(
+            content=current_text,
+            tool_calls=tool_calls,
+            content_blocks=_openai_content_blocks(current_text, reasoning_content),
+            raw_response=None,
+            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 for OpenAI chat-style requests using tiktoken."""
+        openai_messages = self._convert_messages(messages)
+        if system_prompt:
+            openai_messages.insert(0, {"role": "system", "content": system_prompt})
+        openai_tools = self._convert_tools(tools) if tools else None
+
+        encoding = self._encoding_for_model()
+        if encoding is None:
+            return None
+        total = 0
+        for message in openai_messages:
+            total += 3
+            for key, value in message.items():
+                if value is None:
+                    continue
+                total += len(encoding.encode(self._stringify_token_value(value)))
+                if key == "name":
+                    total += 1
+        total += 3
+        if openai_tools:
+            # Tool schema accounting is model-dependent; compact JSON keeps this close.
+            total += len(encoding.encode(json.dumps(openai_tools, separators=(",", ":"))))
+        return total
+
+    def _encoding_for_model(self):
+        try:
+            return tiktoken.encoding_for_model(self.model)
+        except Exception:
+            try:
+                return tiktoken.get_encoding("o200k_base")
+            except Exception:
+                return None
+
+    def _stringify_token_value(self, value: Any) -> str:
+        if isinstance(value, str):
+            return value
+        return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+
+    def _extract_usage(self, usage: Any) -> Optional[dict[str, int]]:
+        """Normalize OpenAI usage data."""
+        if usage is None:
+            return None
+        input_tokens = getattr(usage, "prompt_tokens", None)
+        output_tokens = getattr(usage, "completion_tokens", None)
+        total_tokens = getattr(usage, "total_tokens", None)
+        if input_tokens is None and output_tokens is None and total_tokens is None:
+            return None
+        if total_tokens is None:
+            total_tokens = (input_tokens or 0) + (output_tokens or 0)
+        return {
+            "input_tokens": input_tokens or 0,
+            "output_tokens": output_tokens or 0,
+            "total_tokens": total_tokens or 0,
+        }
+
+
+def _openai_content_blocks(content: str, reasoning_content: Optional[str]) -> Optional[list[dict[str, Any]]]:
+    blocks: list[dict[str, Any]] = []
+    if reasoning_content:
+        blocks.append({"type": "reasoning_content", "reasoning_content": reasoning_content})
+    if content:
+        blocks.append({"type": "text", "text": content})
+    return blocks or None

agent/providers/text_tool_calls.py

@@ -0,0 +1,118 @@
+"""Parse text-encoded tool calls emitted by some OpenAI-compatible models."""
+
+import json
+import re
+from typing import Any
+
+from agent.providers.base import ToolCall
+
+
+FUNCTION_CALL_BEGIN = "<|FunctionCallBegin|>"
+FUNCTION_CALL_END = "<|FunctionCallEnd|>"
+
+_TEXT_TOOL_CALL_RE = re.compile(
+    rf"{re.escape(FUNCTION_CALL_BEGIN)}(.*?){re.escape(FUNCTION_CALL_END)}",
+    re.DOTALL,
+)
+
+
+def parse_text_tool_calls(content: str) -> tuple[str, list[ToolCall]]:
+    """Extract text-encoded tool calls and return cleaned assistant text."""
+    tool_calls: list[ToolCall] = []
+
+    for index, match in enumerate(_TEXT_TOOL_CALL_RE.finditer(content)):
+        payload = match.group(1).strip()
+        for call_index, item in enumerate(_load_call_items(payload)):
+            name = item.get("name")
+            if not name:
+                continue
+            args = _extract_args(item)
+            tool_calls.append(
+                ToolCall(
+                    id=f"text-tool-{index}-{call_index}",
+                    name=str(name),
+                    args=args,
+                )
+            )
+
+    cleaned = _TEXT_TOOL_CALL_RE.sub("", content).strip()
+    return cleaned, tool_calls
+
+
+def _load_call_items(payload: str) -> list[dict[str, Any]]:
+    try:
+        loaded = json.loads(payload)
+    except json.JSONDecodeError:
+        return []
+    if isinstance(loaded, dict):
+        return [loaded]
+    if isinstance(loaded, list):
+        return [item for item in loaded if isinstance(item, dict)]
+    return []
+
+
+def _extract_args(item: dict[str, Any]) -> dict[str, Any]:
+    args = (
+        item.get("parameters")
+        or item.get("arguments")
+        or item.get("args")
+        or item.get("input")
+        or {}
+    )
+    if isinstance(args, str):
+        try:
+            args = json.loads(args)
+        except json.JSONDecodeError:
+            return {}
+    return args if isinstance(args, dict) else {}
+
+
+class TextToolCallStreamFilter:
+    """Suppress text-encoded tool call blocks from streamed text deltas."""
+
+    def __init__(self):
+        self.buffer = ""
+
+    def feed(self, chunk: str) -> list[str]:
+        """Return safe chunks that can be shown to the user."""
+        self.buffer += chunk
+        output: list[str] = []
+
+        while self.buffer:
+            begin = self.buffer.find(FUNCTION_CALL_BEGIN)
+            if begin >= 0:
+                if begin > 0:
+                    output.append(self.buffer[:begin])
+                end = self.buffer.find(FUNCTION_CALL_END, begin)
+                if end < 0:
+                    self.buffer = self.buffer[begin:]
+                    break
+                self.buffer = self.buffer[end + len(FUNCTION_CALL_END):]
+                continue
+
+            keep = self._partial_begin_suffix_len(self.buffer)
+            if keep:
+                output.append(self.buffer[:-keep])
+                self.buffer = self.buffer[-keep:]
+                break
+
+            output.append(self.buffer)
+            self.buffer = ""
+
+        return [text for text in output if text]
+
+    def flush(self) -> list[str]:
+        """Flush remaining safe text at stream end."""
+        if self.buffer.startswith(FUNCTION_CALL_BEGIN):
+            self.buffer = ""
+            return []
+        output = [self.buffer] if self.buffer else []
+        self.buffer = ""
+        return output
+
+    def _partial_begin_suffix_len(self, text: str) -> int:
+        max_len = min(len(text), len(FUNCTION_CALL_BEGIN) - 1)
+        for length in range(max_len, 0, -1):
+            if FUNCTION_CALL_BEGIN.startswith(text[-length:]):
+                return length
+        return 0

agent/runtime/approval_service.py

@@ -0,0 +1,184 @@
+"""Runtime approval orchestration."""
+
+from pathlib import Path
+
+from agent.approval import (
+    ApprovalRequest,
+    ApprovalCallback,
+    ApprovalDenied,
+    approval_cache_key,
+    approval_request_for_tool,
+)
+from agent.runtime.context import WorkflowState
+from agent.streaming import StreamEvent, StreamEventCallback
+
+
+class ApprovalService:
+    """Approve high-risk tool calls and inject approved=true."""
+
+    def __init__(
+        self,
+        approval_callback: ApprovalCallback | None,
+        workflow_state: WorkflowState,
+        stream_callback: StreamEventCallback | None = None,
+        session_id: str = "",
+        source: str = "main",
+        role: str | None = None,
+        parent_session_id: str | None = None,
+        workdir: Path | str | None = None,
+    ):
+        self.approval_callback = approval_callback
+        self.workflow_state = workflow_state
+        self.stream_callback = stream_callback
+        self.session_id = session_id
+        self.source = source
+        self.role = role
+        self.parent_session_id = parent_session_id
+        self.workdir = workdir
+
+    async def approve(self, tool_name: str, args: dict | None) -> dict:
+        """Return tool args after approval, injecting approved=true when needed."""
+        args = dict(args or {})
+        request = approval_request_for_tool(tool_name, args, workdir=self.workdir)
+        if request is None:
+            return args
+
+        cache_key = approval_cache_key(request)
+        if cache_key in self.workflow_state.approved_write_keys:
+            args["approved"] = True
+            await self._emit_approval_resolved(request, "cached_approved")
+            return args
+
+        await self._emit_approval_diff_preview(request)
+        if self.approval_callback is None:
+            await self._emit_approval_required(request)
+            await self._emit_approval_resolved(request, "denied")
+            raise ApprovalDenied(request)
+        await self._emit_approval_required(request)
+        approved = await self.approval_callback(request)
+        if not approved:
+            await self._emit_approval_resolved(request, "denied")
+            raise ApprovalDenied(request)
+
+        self.workflow_state.approved_write_keys.add(cache_key)
+        args["approved"] = True
+        await self._emit_approval_resolved(request, "approved")
+        return args
+
+    async def _emit_approval_required(self, request: ApprovalRequest) -> None:
+        if self.stream_callback is None:
+            return
+        await self.stream_callback(
+            StreamEvent(
+                source=self.source,
+                session_id=self.session_id,
+                role=self.role,
+                parent_session_id=self.parent_session_id,
+                event_type="approval_required",
+                content=request.format(include_diff=False),
+                title=_approval_title(request, "Approve"),
+                detail=_approval_detail(request),
+                phase="blocked",
+                status="waiting_for_user",
+                tool_name=request.tool_name,
+                file_paths=_approval_paths(request),
+                metadata=_approval_metadata(request),
+            )
+        )
+
+    async def _emit_approval_diff_preview(self, request: ApprovalRequest) -> None:
+        if self.stream_callback is None or not request.diff_preview:
+            return
+        await self.stream_callback(
+            StreamEvent(
+                source=self.source,
+                session_id=self.session_id,
+                role=self.role,
+                parent_session_id=self.parent_session_id,
+                event_type="tool_result",
+                content=request.diff_preview,
+                title="Review diff before approval",
+                detail=_approval_detail(request),
+                phase="reviewing",
+                status="waiting_for_user",
+                tool_name=request.tool_name,
+                file_paths=_approval_paths(request),
+                metadata={
+                    **_approval_metadata(request),
+                    "approval_preview": True,
+                },
+            )
+        )
+
+    async def _emit_approval_resolved(self, request: ApprovalRequest, status: str) -> None:
+        if self.stream_callback is None:
+            return
+        phase = "blocked" if status == "denied" else "implementing"
+        await self.stream_callback(
+            StreamEvent(
+                source=self.source,
+                session_id=self.session_id,
+                role=self.role,
+                parent_session_id=self.parent_session_id,
+                event_type="approval_resolved",
+                content=status,
+                title=_approval_title(request, _approval_status_label(status)),
+                detail=_approval_detail(request),
+                phase=phase,
+                status=status,
+                tool_name=request.tool_name,
+                file_paths=_approval_paths(request),
+                metadata=_approval_metadata(request),
+            )
+        )
+
+
+def _approval_title(request: ApprovalRequest, prefix: str) -> str:
+    if request.action == "edit_file":
+        return f"{prefix} file edit"
+    if request.action == "create_file":
+        return f"{prefix} file creation"
+    if request.action == "run_command":
+        return f"{prefix} command"
+    return f"{prefix} action"
+
+
+def _approval_status_label(status: str) -> str:
+    return {
+        "approved": "Approved",
+        "cached_approved": "Approved",
+        "denied": "Denied",
+    }.get(status, status)
+
+
+def _approval_detail(request: ApprovalRequest) -> str:
+    if request.path:
+        return request.path
+    if request.command:
+        return request.command
+    return request.reason
+
+
+def _approval_paths(request: ApprovalRequest) -> list[str] | None:
+    if not request.path:
+        return None
+    return [path.strip() for path in request.path.split(",") if path.strip()]
+
+
+def _approval_metadata(request: ApprovalRequest) -> dict:
+    approval_id = "|".join(
+        [
+            request.action,
+            request.tool_name,
+            request.path or request.command,
+        ]
+    )
+    return {
+        "approval_id": approval_id,
+        "action": request.action,
+        "reason": request.reason,
+        "risk": request.risk,
+        "path": request.path,
+        "command": request.command,
+        "diff_preview": request.diff_preview,
+    }

agent/runtime/context.py

@@ -0,0 +1,43 @@
+"""Runtime context objects for graph execution."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Optional
+
+from agent.approval import ApprovalCallback
+from agent.providers.base import LLMProvider
+from agent.streaming import StreamEventCallback
+from agent.tool_retry import async_run_tool_with_retry
+from agent.todo_manager import TodoManager
+
+
+@dataclass
+class WorkflowState:
+    """Mutable workflow state scoped to a single graph run."""
+
+    workspace_state_checked: bool = False
+    git_diff_checked: bool = False
+    needs_verify: bool = False
+    approved_write_keys: set[tuple[str, str, str]] = field(default_factory=set)
+
+
+@dataclass
+class AgentRuntimeContext:
+    """Dependencies and runtime state needed by graph nodes."""
+
+    provider: LLMProvider
+    system_prompt: str
+    todo_manager: TodoManager
+    workdir: Path
+    session_id: str
+    source: str = "main"
+    role: str | None = None
+    parent_session_id: str | None = None
+    skill_dirs: list[str] | None = None
+    app_root: Path | None = None
+    stream_callback: Optional[StreamEventCallback] = None
+    approval_callback: Optional[ApprovalCallback] = None
+    tools: list[dict] = field(default_factory=list)
+    tool_handlers: dict[str, Callable] = field(default_factory=dict)
+    workflow_state: WorkflowState = field(default_factory=WorkflowState)
+    run_tool: Callable = async_run_tool_with_retry