yycode 0.3.2__py3-none-any.whl

agent/llm_retry.py

@@ -0,0 +1,434 @@
+"""LLM chat timeout, heartbeat, and retry helpers."""
+
+import asyncio
+import contextlib
+import os
+import math
+import sys
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+from agent.providers.base import ChatResponse, LLMProvider
+from agent.streaming import ProviderStreamCallback, StreamEvent, StreamEventCallback
+from agent.logger import get_logger
+
+
+logger = get_logger(__name__)
+
+
+DEFAULT_LLM_TIMEOUT_SECONDS = 3600.0  # 1 hour for very long tasks
+DEFAULT_LLM_MAX_RETRIES = 10        # More retries for reliability
+DEFAULT_LLM_HEARTBEAT_SECONDS = 15.0  # Reduce noise but still visible
+
+
+def _estimate_context_tokens(messages: list[dict], system_prompt: Optional[str] = None) -> int:
+    """Estimate token count using a lightweight heuristic (1 token ≈ 4 chars)."""
+    total_chars = 0
+    if system_prompt:
+        total_chars += len(system_prompt)
+    for msg in messages:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            total_chars += len(content)
+        elif isinstance(content, list):
+            for item in content:
+                total_chars += len(str(item))
+        if msg.get("role"):
+            total_chars += len(msg["role"])
+    return math.ceil(total_chars / 4) if total_chars > 0 else 0
+
+
+@dataclass
+class LLMCallError(Exception):
+    """Raised when an LLM call fails after retries."""
+
+    message: str
+    attempts: int
+    timeout_seconds: float
+    last_error: str
+
+    def __str__(self) -> str:
+        return self.message
+
+
+async def chat_with_retry(
+    provider: LLMProvider,
+    *,
+    messages: list[dict],
+    tools: list[dict],
+    system_prompt: Optional[str] = None,
+    stream_callback: Optional[ProviderStreamCallback] = None,
+    event_callback: Optional[StreamEventCallback] = None,
+    source: str = "main",
+    session_id: str = "",
+    role: Optional[str] = None,
+    parent_session_id: Optional[str] = None,
+    timeout_seconds: Optional[float] = None,
+    max_retries: Optional[int] = None,
+    heartbeat_seconds: Optional[float] = None,
+) -> ChatResponse:
+    """Call a provider with bounded waiting, visible heartbeat, and retry."""
+    timeout_seconds = _resolve_float_env(
+        "YOYO_LLM_TIMEOUT_SECONDS",
+        timeout_seconds,
+        DEFAULT_LLM_TIMEOUT_SECONDS,
+    )
+    heartbeat_seconds = _resolve_float_env(
+        "YOYO_LLM_HEARTBEAT_SECONDS",
+        heartbeat_seconds,
+        DEFAULT_LLM_HEARTBEAT_SECONDS,
+    )
+    max_retries = _resolve_int_env(
+        "YOYO_LLM_MAX_RETRIES",
+        max_retries,
+        DEFAULT_LLM_MAX_RETRIES,
+    )
+    attempts = max_retries + 1
+    estimated_tokens = _estimate_context_tokens(messages, system_prompt)
+    provider_name = provider.__class__.__name__
+    model_name = str(getattr(provider, "model", "(unknown)"))
+    request_id = f"{source}:{session_id or '-'}:{int(time.time() * 1000) % 1_000_000}"
+
+    logger.debug(
+        "LLM request start request_id=%s source=%s role=%s provider=%s model=%s "
+        "messages=%d tools=%d context_est_tokens=%d stream=%s timeout_s=%.3f "
+        "heartbeat_s=%.3f max_retries=%d attempts=%d",
+        request_id,
+        source,
+        role or "",
+        provider_name,
+        model_name,
+        len(messages),
+        len(tools),
+        estimated_tokens,
+        stream_callback is not None,
+        timeout_seconds,
+        heartbeat_seconds,
+        max_retries,
+        attempts,
+    )
+
+    # Debug log to confirm actual values
+    if _debug_enabled() and event_callback:
+        await _emit_llm_event(
+            event_callback,
+            source=source,
+            session_id=session_id,
+            role=role,
+            parent_session_id=parent_session_id,
+            event_type="llm_waiting",
+            content=f"[debug] Starting request, context≈{estimated_tokens} tokens, timeout={timeout_seconds:.0f}s, max_retries={max_retries}, total_attempts={attempts}",
+        )
+    last_error = ""
+
+    for attempt in range(1, attempts + 1):
+        try:
+            response = await _chat_once_with_heartbeat(
+                provider,
+                messages=messages,
+                tools=tools,
+                system_prompt=system_prompt,
+                stream_callback=stream_callback,
+                event_callback=event_callback,
+                source=source,
+                session_id=session_id,
+                role=role,
+                parent_session_id=parent_session_id,
+                timeout_seconds=timeout_seconds,
+                heartbeat_seconds=heartbeat_seconds,
+                attempt=attempt,
+                attempts=attempts,
+                request_id=request_id,
+            )
+            logger.debug(
+                "LLM request success request_id=%s attempt=%d/%d",
+                request_id,
+                attempt,
+                attempts,
+            )
+            return response
+        except asyncio.TimeoutError:
+            last_error = f"Timeout after {timeout_seconds:g}s"
+            logger.warning(
+                "LLM request timeout request_id=%s attempt=%d/%d timeout_s=%.3f",
+                request_id,
+                attempt,
+                attempts,
+                timeout_seconds,
+            )
+            await _emit_llm_event(
+                event_callback,
+                source=source,
+                session_id=session_id,
+                role=role,
+                parent_session_id=parent_session_id,
+                event_type="llm_timeout",
+                content=f"{last_error} (attempt {attempt}/{attempts})",
+                title="Model request timed out",
+                detail=f"Attempt {attempt}/{attempts}",
+                phase="waiting",
+                status="timeout",
+                metadata={"attempt": attempt, "attempts": attempts},
+            )
+        except Exception as exc:
+            last_error = str(exc) or exc.__class__.__name__
+            logger.warning(
+                "LLM request error request_id=%s attempt=%d/%d error_type=%s error=%s",
+                request_id,
+                attempt,
+                attempts,
+                exc.__class__.__name__,
+                last_error,
+            )
+            await _emit_llm_event(
+                event_callback,
+                source=source,
+                session_id=session_id,
+                role=role,
+                parent_session_id=parent_session_id,
+                event_type="llm_error",
+                content=f"{last_error} (attempt {attempt}/{attempts})",
+                title="Model request failed",
+                detail=f"Attempt {attempt}/{attempts}",
+                phase="waiting",
+                status="failed",
+                metadata={"attempt": attempt, "attempts": attempts},
+            )
+
+        if attempt < attempts:
+            logger.debug(
+                "LLM request retry scheduled request_id=%s next_attempt=%d/%d",
+                request_id,
+                attempt + 1,
+                attempts,
+            )
+            await _emit_llm_event(
+                event_callback,
+                source=source,
+                session_id=session_id,
+                role=role,
+                parent_session_id=parent_session_id,
+                event_type="llm_retry",
+                content=f"retrying model request ({attempt + 1}/{attempts})",
+                title="Retrying model request",
+                detail=f"Attempt {attempt + 1}/{attempts}",
+                phase="waiting",
+                status="retrying",
+                metadata={"attempt": attempt + 1, "attempts": attempts},
+            )
+            await asyncio.sleep(min(2.0, 0.5 * attempt))
+
+    raise LLMCallError(
+        message=f"Model request failed after {attempts} attempt(s): {last_error}",
+        attempts=attempts,
+        timeout_seconds=timeout_seconds,
+        last_error=last_error,
+    )
+
+
+async def _chat_once_with_heartbeat(
+    provider: LLMProvider,
+    *,
+    messages: list[dict],
+    tools: list[dict],
+    system_prompt: Optional[str],
+    stream_callback: Optional[ProviderStreamCallback],
+    event_callback: Optional[StreamEventCallback],
+    source: str,
+    session_id: str,
+    role: Optional[str],
+    parent_session_id: Optional[str],
+    timeout_seconds: float,
+    heartbeat_seconds: float,
+    attempt: int,
+    attempts: int,
+    request_id: str,
+) -> ChatResponse:
+    last_activity = time.monotonic()
+    first_stream_event_at: Optional[float] = None
+    stream_event_count = 0
+
+    async def activity_stream_callback(event_type: str, content: str) -> None:
+        nonlocal first_stream_event_at, last_activity, stream_event_count
+        now = time.monotonic()
+        if first_stream_event_at is None:
+            first_stream_event_at = now
+            logger.debug(
+                "LLM first stream event request_id=%s attempt=%d/%d event_type=%s "
+                "first_token_latency_s=%.3f",
+                request_id,
+                attempt,
+                attempts,
+                event_type,
+                now - start,
+            )
+        stream_event_count += 1
+        last_activity = time.monotonic()
+        if stream_callback is not None:
+            await stream_callback(event_type, content)
+
+    # Update activity before starting to avoid idle_seconds jumping
+    last_activity = time.monotonic()
+    start = time.monotonic()
+
+    task = asyncio.create_task(
+        provider.chat(
+            messages=messages,
+            tools=tools,
+            system_prompt=system_prompt,
+            stream_callback=activity_stream_callback if stream_callback else None,
+        )
+    )
+    logger.debug(
+        "LLM attempt started request_id=%s attempt=%d/%d timeout_s=%.3f",
+        request_id,
+        attempt,
+        attempts,
+        timeout_seconds,
+    )
+
+    try:
+        while True:
+            remaining = timeout_seconds - (time.monotonic() - start)
+            if remaining <= 0:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+                raise asyncio.TimeoutError()
+
+            done, _ = await asyncio.wait({task}, timeout=min(heartbeat_seconds, remaining))
+            if done:
+                response = await task
+                elapsed_seconds = time.monotonic() - start
+                logger.debug(
+                    "LLM attempt completed request_id=%s attempt=%d/%d elapsed_s=%.3f "
+                    "stream_events=%d first_token_latency_s=%s content_chars=%d "
+                    "tool_calls=%d usage=%s",
+                    request_id,
+                    attempt,
+                    attempts,
+                    elapsed_seconds,
+                    stream_event_count,
+                    (
+                        f"{first_stream_event_at - start:.3f}"
+                        if first_stream_event_at is not None
+                        else "none"
+                    ),
+                    len(response.content or ""),
+                    len(response.tool_calls or []),
+                    response.usage,
+                )
+                return response
+
+            idle_seconds = int(time.monotonic() - last_activity)
+            elapsed_seconds = int(time.monotonic() - start)
+            logger.debug(
+                "LLM still waiting request_id=%s attempt=%d/%d elapsed_s=%d "
+                "idle_s=%d stream_events=%d remaining_s=%.3f",
+                request_id,
+                attempt,
+                attempts,
+                elapsed_seconds,
+                idle_seconds,
+                stream_event_count,
+                remaining,
+            )
+            await _emit_llm_event(
+                event_callback,
+                source=source,
+                session_id=session_id,
+                role=role,
+                parent_session_id=parent_session_id,
+                event_type="llm_waiting",
+                content=(
+                    "waiting for model response... "
+                    f"{elapsed_seconds}s elapsed, {idle_seconds}s since last token "
+                    f"(attempt {attempt}/{attempts})"
+                ),
+                title="Waiting for model response",
+                detail=f"Attempt {attempt}/{attempts}, {idle_seconds}s since last token",
+                phase="waiting",
+                status="running",
+                elapsed_ms=elapsed_seconds * 1000,
+                metadata={
+                    "attempt": attempt,
+                    "attempts": attempts,
+                    "idle_seconds": idle_seconds,
+                    "since_last_token_ms": idle_seconds * 1000,
+                    "elapsed_seconds": elapsed_seconds,
+                    "elapsed_ms": elapsed_seconds * 1000,
+                    "source": source,
+                    "role": role,
+                },
+            )
+    finally:
+        if not task.done():
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
+
+
+async def _emit_llm_event(
+    event_callback: Optional[StreamEventCallback],
+    *,
+    source: str,
+    session_id: str,
+    role: Optional[str],
+    parent_session_id: Optional[str],
+    event_type: str,
+    content: str,
+    title: Optional[str] = None,
+    detail: Optional[str] = None,
+    phase: Optional[str] = None,
+    status: Optional[str] = None,
+    elapsed_ms: Optional[int] = None,
+    metadata: Optional[dict] = None,
+) -> None:
+    if event_callback is None:
+        return
+    await event_callback(
+        StreamEvent(
+            source=source,
+            session_id=session_id,
+            role=role,
+            parent_session_id=parent_session_id,
+            event_type=event_type,
+            content=content,
+            title=title,
+            detail=detail,
+            phase=phase,
+            status=status,
+            elapsed_ms=elapsed_ms,
+            metadata=metadata,
+        )
+    )
+
+
+def _resolve_float_env(name: str, explicit: Optional[float], default: float) -> float:
+    if explicit is not None:
+        return max(float(explicit), 0.001)
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    try:
+        return max(float(raw), 0.001)
+    except ValueError:
+        return default
+
+
+def _resolve_int_env(name: str, explicit: Optional[int], default: int) -> int:
+    if explicit is not None:
+        return max(int(explicit), 0)
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    try:
+        return max(int(raw), 0)
+    except ValueError:
+        return default
+
+
+def _debug_enabled() -> bool:
+    logger_module = sys.modules.get("agent.logger")
+    return bool(getattr(logger_module, "DEBUG_ENABLED", False))

agent/logger.py

@@ -0,0 +1,97 @@
+"""Logging configuration for the agent."""
+
+import logging
+import sys
+from pathlib import Path
+
+# Log file path
+LOG_FILE_NAME = "agent_debug.log"
+LOG_FILE = Path(LOG_FILE_NAME)
+
+# Global flag to control debug output
+DEBUG_ENABLED = False
+
+
+def setup_logging(
+    debug: bool = False,
+    log_to_file: bool = False,
+    log_file: str | Path | None = None,
+):
+    """Set up logging configuration.
+
+    Args:
+        debug: Whether to enable debug logging to console.
+        log_to_file: Whether to write logs to file.
+        log_file: Optional path for the log file.
+    """
+    global DEBUG_ENABLED
+    DEBUG_ENABLED = debug
+
+    # Root logger configuration
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+
+    # Clear any existing handlers
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    # File handler - only if log_to_file is True
+    log_path = Path(log_file).expanduser().resolve() if log_file else LOG_FILE
+    if log_to_file:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        file_handler = logging.FileHandler(log_path, encoding="utf-8")
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(file_formatter)
+        root_logger.addHandler(file_handler)
+
+    # Console handler - always present, but level depends on debug
+    console_formatter = logging.Formatter(
+        "%(levelname)s: %(message)s"
+    )
+    console_handler = logging.StreamHandler(sys.stdout)
+
+    if debug:
+        console_handler.setLevel(logging.DEBUG)
+    else:
+        console_handler.setLevel(logging.WARNING)
+
+    console_handler.setFormatter(console_formatter)
+    root_logger.addHandler(console_handler)
+
+    # Confirm logging setup
+    status_parts = []
+    if debug:
+        status_parts.append("debug to console")
+    if log_to_file:
+        status_parts.append(f"logs to {log_path}")
+
+    if status_parts:
+        print(f"\033[90m[INFO] {', '.join(status_parts)}\033[0m")
+    else:
+        print("\033[90m[INFO] No logging configured\033[0m")
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a named logger.
+
+    Args:
+        name: Logger name, usually __name__.
+
+    Returns:
+        Configured logger instance.
+    """
+    return logging.getLogger(name)
+
+
+def debug_print(*args, **kwargs):
+    """Print debug messages only if DEBUG is enabled.
+
+    Args:
+        *args: Positional arguments to print.
+        **kwargs: Keyword arguments to print.
+    """
+    if DEBUG_ENABLED:
+        print(*args, **kwargs)

agent/lsp/__init__.py

@@ -0,0 +1,13 @@
+"""LSP integration package."""
+
+from agent.lsp.manager import LspManager, get_lsp_manager, shutdown_lsp_managers
+from agent.lsp.types import Diagnostic, Location, Symbol
+
+__all__ = [
+    "Diagnostic",
+    "Location",
+    "LspManager",
+    "Symbol",
+    "get_lsp_manager",
+    "shutdown_lsp_managers",
+]

agent/lsp/client.py

@@ -0,0 +1,151 @@
+"""Minimal async JSON-RPC client for Language Server Protocol processes."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+
+class LspClientError(RuntimeError):
+    """Raised when an LSP client operation fails."""
+
+
+class LspClient:
+    """Small JSON-RPC client for a single language server process."""
+
+    def __init__(self, command: Sequence[str], root: Path, timeout: float = 10.0):
+        self.command = list(command)
+        self.root = root.resolve()
+        self.timeout = timeout
+        self.process: asyncio.subprocess.Process | None = None
+        self._next_id = 1
+        self._pending: dict[int, asyncio.Future] = {}
+        self._reader_task: asyncio.Task | None = None
+        self._initialized = False
+
+    async def start(self) -> None:
+        """Start and initialize the language server."""
+        if self.process is not None and self.process.returncode is None:
+            return
+        self.process = await asyncio.create_subprocess_exec(
+            *self.command,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=str(self.root),
+        )
+        self._reader_task = asyncio.create_task(self._read_loop())
+        await self.initialize()
+
+    async def initialize(self) -> None:
+        """Send initialize/initialized handshake."""
+        if self._initialized:
+            return
+        result = await self.request(
+            "initialize",
+            {
+                "processId": None,
+                "rootUri": self.root.as_uri(),
+                "capabilities": {},
+                "workspaceFolders": [{"uri": self.root.as_uri(), "name": self.root.name}],
+            },
+        )
+        if result is None:
+            raise LspClientError("language server returned empty initialize result")
+        await self.notify("initialized", {})
+        self._initialized = True
+
+    async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
+        """Send a JSON-RPC request and return its result."""
+        if self.process is None or self.process.stdin is None:
+            raise LspClientError("language server is not running")
+        request_id = self._next_id
+        self._next_id += 1
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        self._pending[request_id] = future
+        await self._send({"jsonrpc": "2.0", "id": request_id, "method": method, "params": params or {}})
+        try:
+            response = await asyncio.wait_for(future, timeout=self.timeout)
+        finally:
+            self._pending.pop(request_id, None)
+        if "error" in response:
+            error = response["error"]
+            message = error.get("message", str(error)) if isinstance(error, dict) else str(error)
+            raise LspClientError(message)
+        return response.get("result")
+
+    async def notify(self, method: str, params: dict[str, Any] | None = None) -> None:
+        """Send a JSON-RPC notification."""
+        if self.process is None or self.process.stdin is None:
+            raise LspClientError("language server is not running")
+        await self._send({"jsonrpc": "2.0", "method": method, "params": params or {}})
+
+    async def did_open(self, uri: str, text: str, language_id: str = "python") -> None:
+        """Notify the server that a document is open."""
+        await self.notify(
+            "textDocument/didOpen",
+            {"textDocument": {"uri": uri, "languageId": language_id, "version": 1, "text": text}},
+        )
+
+    async def shutdown(self) -> None:
+        """Shutdown the language server process."""
+        proc = self.process
+        if proc is None:
+            return
+        try:
+            if proc.returncode is None:
+                try:
+                    await self.request("shutdown", {})
+                    await self.notify("exit", {})
+                except Exception:
+                    proc.terminate()
+                try:
+                    await asyncio.wait_for(proc.wait(), timeout=2)
+                except asyncio.TimeoutError:
+                    proc.kill()
+                    await proc.wait()
+        finally:
+            if self._reader_task:
+                self._reader_task.cancel()
+            self.process = None
+            self._initialized = False
+
+    async def _send(self, payload: dict[str, Any]) -> None:
+        body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+        header = f"Content-Length: {len(body)}\r\n\r\n".encode("ascii")
+        assert self.process is not None and self.process.stdin is not None
+        self.process.stdin.write(header + body)
+        await self.process.stdin.drain()
+
+    async def _read_loop(self) -> None:
+        assert self.process is not None and self.process.stdout is not None
+        reader = self.process.stdout
+        while True:
+            try:
+                headers: dict[str, str] = {}
+                while True:
+                    line = await reader.readline()
+                    if not line:
+                        raise EOFError("language server stdout closed")
+                    if line in {b"\r\n", b"\n"}:
+                        break
+                    key, _, value = line.decode("ascii", errors="replace").partition(":")
+                    headers[key.lower()] = value.strip()
+                length = int(headers.get("content-length", "0"))
+                if length <= 0:
+                    continue
+                body = await reader.readexactly(length)
+                message = json.loads(body.decode("utf-8"))
+                if "id" in message and (future := self._pending.get(int(message["id"]))) and not future.done():
+                    future.set_result(message)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                for future in list(self._pending.values()):
+                    if not future.done():
+                        future.set_exception(exc)
+                return