navaia-code 1.0.50__py3-none-any.whl

navaia/__init__.py

@@ -0,0 +1,3 @@
+"""Navaia Code — AI coding agent, built in Python."""
+
+__version__ = "1.0.50"

navaia/api/client.py

@@ -0,0 +1,72 @@
+"""Provider-agnostic API client factory using the OpenAI SDK.
+
+Supports: OpenRouter, internal vLLM (ngx.tawakkalna.nic.gov.sa), Ollama,
+Groq, or any OpenAI-compatible endpoint — controlled via provider profiles
+or environment variables.
+"""
+
+from __future__ import annotations
+
+import os
+
+import httpx
+from openai import AsyncOpenAI
+
+from navaia.config.providers import (
+    ProviderProfile,
+    resolve_api_key,
+    resolve_base_url,
+    resolve_model,
+    resolve_provider,
+)
+
+
+def create_client(provider_name: str = "") -> AsyncOpenAI:
+    """Create an AsyncOpenAI client from a provider profile.
+
+    Args:
+        provider_name: Provider to use (e.g. "openrouter", "internal",
+            "ollama"). Empty string resolects via NAVAIA_PROVIDER env
+            or config files.
+    """
+    profile = resolve_provider(provider_name)
+    return _build_client(profile)
+
+
+def get_model(provider_name: str = "") -> str:
+    """Return the model identifier, resolved from env or provider profile."""
+    profile = resolve_provider(provider_name)
+    return resolve_model(profile)
+
+
+def get_provider_profile(provider_name: str = "") -> ProviderProfile:
+    """Return the resolved provider profile (for retry/streaming config)."""
+    return resolve_provider(provider_name)
+
+
+def _build_client(profile: ProviderProfile) -> AsyncOpenAI:
+    """Build the AsyncOpenAI client from a resolved profile."""
+    api_key = resolve_api_key(profile)
+    base_url = resolve_base_url(profile)
+
+    # Normalise base URL to end with /v1 — but only for profile defaults,
+    # not for explicit user overrides (which may have custom paths)
+    is_user_override = bool(
+        os.environ.get("OPENAI_BASE_URL") or os.environ.get("ANTHROPIC_BASE_URL")
+    )
+    if base_url and not is_user_override and not base_url.rstrip("/").endswith("/v1"):
+        base_url = base_url.rstrip("/") + "/v1"
+
+    kwargs: dict = dict(
+        api_key=api_key,
+        base_url=base_url,
+        max_retries=0,  # we handle retries ourselves in retry.py
+        timeout=profile.timeout,
+    )
+
+    # Only create a custom httpx client when SSL verification is disabled
+    # (internal/local endpoints). AsyncOpenAI manages its own client otherwise.
+    if not profile.verify_ssl:
+        kwargs["http_client"] = httpx.AsyncClient(verify=False)
+
+    return AsyncOpenAI(**kwargs)

navaia/api/normalise.py

@@ -0,0 +1,148 @@
+"""Translate internal message types to OpenAI API format.
+
+Mirrors normalizeMessagesForAPI() from Claude Code:
+- Strips progress, non-local system messages, synthetic API errors
+- Merges consecutive user messages (some providers require this)
+- Converts internal content blocks to OpenAI format
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from navaia.api.types import (
+    AssistantMessage,
+    CompactBoundaryMessage,
+    Message,
+    SystemMessage,
+    TextBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserMessage,
+)
+
+
+def _convert_message(msg: Message) -> dict[str, Any] | list[dict[str, Any]] | None:
+    """Convert a single internal message to OpenAI format, or None to skip."""
+    if isinstance(msg, SystemMessage):
+        # Only include local_command system messages
+        if msg.subtype == "local_command" and not msg.is_api_error:
+            return {"role": "user", "content": f"[System: {msg.text}]"}
+        return None
+
+    if isinstance(msg, CompactBoundaryMessage):
+        return {
+            "role": "user",
+            "content": (
+                "[Context compacted. Previous conversation summarised below.]\n\n"
+                + msg.summary
+            ),
+        }
+
+    if isinstance(msg, UserMessage):
+        return _convert_user_message(msg)
+
+    if isinstance(msg, AssistantMessage):
+        return _convert_assistant_message(msg)
+
+    return None
+
+
+def _convert_user_message(msg: UserMessage) -> dict[str, Any] | list[dict[str, Any]]:
+    """Convert UserMessage to OpenAI format."""
+    # Simple string content
+    if isinstance(msg.content, str):
+        return {"role": "user", "content": msg.content}
+
+    # Content block list
+    parts: list[str] = []
+    tool_results: list[dict[str, Any]] = []
+
+    for block in msg.content:
+        if isinstance(block, TextBlock):
+            parts.append(block.text)
+        elif isinstance(block, ToolResultBlock):
+            content_str = (
+                block.content
+                if isinstance(block.content, str)
+                else json.dumps(block.content)
+            )
+            tool_results.append({
+                "role": "tool",
+                "tool_call_id": block.tool_use_id,
+                "content": content_str,
+            })
+
+    # If there are tool results, return them as separate messages
+    if tool_results:
+        return tool_results  # type: ignore[return-value]  # handled in normalise
+
+    text = "\n".join(parts).strip()
+    return {"role": "user", "content": text} if text else {"role": "user", "content": ""}
+
+
+def _convert_assistant_message(msg: AssistantMessage) -> dict[str, Any]:
+    """Convert AssistantMessage to OpenAI format."""
+    text_parts: list[str] = []
+    tool_calls: list[dict[str, Any]] = []
+
+    for block in msg.content:
+        if isinstance(block, TextBlock):
+            text_parts.append(block.text)
+        elif isinstance(block, ToolUseBlock):
+            tool_calls.append({
+                "id": block.id,
+                "type": "function",
+                "function": {
+                    "name": block.name,
+                    "arguments": json.dumps(block.input),
+                },
+            })
+
+    result: dict[str, Any] = {"role": "assistant"}
+    content = "\n".join(text_parts).strip() or None
+    result["content"] = content
+
+    if tool_calls:
+        result["tool_calls"] = tool_calls
+
+    return result
+
+
+def normalise_messages_for_api(messages: list[Message]) -> list[dict[str, Any]]:
+    """Convert internal messages to flat OpenAI chat-completions message list."""
+    result: list[dict[str, Any]] = []
+
+    for msg in messages:
+        converted = _convert_message(msg)
+        if converted is None:
+            continue
+        # _convert_user_message may return a list of tool-result dicts
+        if isinstance(converted, list):
+            result.extend(converted)
+        else:
+            result.append(converted)
+
+    return _merge_consecutive_user_messages(result)
+
+
+def _merge_consecutive_user_messages(
+    messages: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Merge consecutive messages with the same role (required by some providers)."""
+    if not messages:
+        return messages
+
+    merged: list[dict[str, Any]] = [messages[0]]
+
+    for msg in messages[1:]:
+        prev = merged[-1]
+        if msg.get("role") == "user" and prev.get("role") == "user":
+            prev_content = prev.get("content", "")
+            new_content = msg.get("content", "")
+            prev["content"] = f"{prev_content}\n\n{new_content}".strip()
+        else:
+            merged.append(msg)
+
+    return merged

navaia/api/retry.py

@@ -0,0 +1,114 @@
+"""Retry logic for API calls — mirrors withRetry.ts exactly.
+
+Retry conditions:
+- 429 (rate limit): retry with exponential backoff
+- 500-503 (server error): retry
+- 529 (overloaded): max 3 consecutive retries
+- Connection errors (ECONNRESET, timeout): retry
+- 401/403/404: do NOT retry (auth/not found)
+
+Numbers from Claude Code source:
+- MAX_RETRIES = 10
+- MAX_529_CONSECUTIVE = 3
+- BASE_DELAY_MS = 500
+- MAX_BACKOFF_MS = 5 minutes
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+from openai import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    RateLimitError,
+)
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+MAX_RETRIES = 10
+MAX_529_CONSECUTIVE = 3
+BASE_DELAY_MS = 500
+MAX_BACKOFF_MS = 5 * 60 * 1000  # 5 minutes
+
+RETRIABLE_STATUS_CODES = {429, 500, 502, 503, 529}
+NON_RETRIABLE_STATUS_CODES = {401, 403, 404}
+
+
+def _is_retriable(error: Exception) -> bool:
+    """Check if an error is retriable."""
+    if isinstance(error, (APIConnectionError, APITimeoutError)):
+        return True
+    if isinstance(error, RateLimitError):
+        return True
+    if isinstance(error, APIStatusError):
+        return error.status_code in RETRIABLE_STATUS_CODES
+    return False
+
+
+def _get_status_code(error: Exception) -> int | None:
+    if isinstance(error, APIStatusError):
+        return error.status_code
+    return None
+
+
+async def with_retry(
+    fn: Callable[[], Awaitable[T]],
+    max_retries: int = MAX_RETRIES,
+    on_retry: Callable[[int, Exception, float], None] | None = None,
+) -> T:
+    """Execute an async function with exponential backoff retry.
+
+    Args:
+        fn: Async function to execute
+        max_retries: Maximum number of retry attempts
+        on_retry: Optional callback(attempt, error, delay_seconds) for UI updates
+    """
+    consecutive_529 = 0
+
+    for attempt in range(max_retries + 1):
+        try:
+            result = await fn()
+            return result
+        except Exception as e:
+            if not _is_retriable(e):
+                raise
+
+            status = _get_status_code(e)
+
+            # Track 529 consecutive count
+            if status == 529:
+                consecutive_529 += 1
+                if consecutive_529 > MAX_529_CONSECUTIVE:
+                    raise
+            else:
+                consecutive_529 = 0
+
+            if attempt >= max_retries:
+                raise
+
+            # Exponential backoff: 500ms, 1s, 2s, 4s, ... capped at 5min
+            delay_ms = min(
+                BASE_DELAY_MS * (2 ** attempt),
+                MAX_BACKOFF_MS,
+            )
+            delay_s = delay_ms / 1000.0
+
+            logger.info(
+                "Retry %d/%d after %s (%.1fs delay)",
+                attempt + 1, max_retries, type(e).__name__, delay_s,
+            )
+
+            if on_retry:
+                on_retry(attempt + 1, e, delay_s)
+
+            await asyncio.sleep(delay_s)
+
+    # Should not reach here, but type safety
+    raise RuntimeError("Exhausted retries")

navaia/api/streaming.py

@@ -0,0 +1,341 @@
+"""Streaming API calls — message assembly and delta-by-delta yielding.
+
+Mirrors src/services/api/claude.ts: stream_message() is the core function
+that yields StreamEvents as they arrive from the provider.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import AsyncIterator
+from typing import Any
+
+from openai import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    AsyncOpenAI,
+    RateLimitError,
+)
+
+from navaia.api.normalise import normalise_messages_for_api
+from navaia.api.retry import (
+    MAX_529_CONSECUTIVE,
+    NON_RETRIABLE_STATUS_CODES,
+    RETRIABLE_STATUS_CODES,
+)
+from navaia.api.types import (
+    FinishEvent,
+    Message,
+    RetryEvent,
+    StreamEvent,
+    TextDeltaEvent,
+    ThinkingDeltaEvent,
+    ToolCallDeltaEvent,
+    ToolCallAccumulator,
+    ToolUseBlock,
+    Usage,
+    UsageEvent,
+)
+
+logger = logging.getLogger(__name__)
+
+STREAM_MAX_RETRIES = 5
+STREAM_BASE_DELAY_S = 1.0
+
+
+def _thinking_extra_body(model: str, thinking_config) -> dict:
+    """Return provider-specific extra_body for extended thinking.
+
+    Different providers expose the thinking/reasoning budget under
+    different parameter names — we detect based on the model id.
+
+    - Anthropic models (claude-*): ``thinking: {type, budget_tokens}``
+    - OpenAI reasoning models (o1, o3, o4-mini, gpt-5): ``reasoning_effort``
+    - OpenRouter passthrough: ``reasoning: {max_tokens}``
+    - Others: inline ``<think>`` handling in the stream parser (no extra body needed)
+    """
+    if thinking_config is None:
+        return {}
+
+    # Import locally to avoid circular imports and optional dependency cost
+    from navaia.thinking.config import ThinkingMode
+
+    if thinking_config.mode == ThinkingMode.DISABLED:
+        return {}
+
+    budget = max(1024, int(thinking_config.budget_tokens))
+    model_lc = model.lower()
+
+    if "claude" in model_lc and ("opus" in model_lc or "sonnet" in model_lc or "haiku" in model_lc):
+        return {"thinking": {"type": "enabled", "budget_tokens": budget}}
+
+    if model_lc.startswith(("o1", "o3", "o4", "gpt-5")):
+        # Translate budget to an effort bucket the reasoning API understands
+        if budget >= 20000:
+            effort = "high"
+        elif budget >= 5000:
+            effort = "medium"
+        else:
+            effort = "low"
+        return {"reasoning_effort": effort}
+
+    if "/" in model_lc:  # OpenRouter-style slug (e.g. "anthropic/claude-opus-4")
+        return {"reasoning": {"max_tokens": budget}}
+
+    # deepseek-r1, qwq, and similar already stream <think> tags inline
+    return {}
+
+
+def _tools_to_openai_schema(tools: list) -> list[dict[str, Any]] | None:
+    """Convert internal tool definitions to OpenAI function-calling schema."""
+    if not tools:
+        return None
+    schemas = []
+    for tool in tools:
+        schema = tool.to_openai_schema()
+        if schema:
+            schemas.append(schema)
+    return schemas or None
+
+
+def _is_retriable_error(error: Exception) -> bool:
+    """Check whether an API error should trigger a retry."""
+    if isinstance(error, (APIConnectionError, APITimeoutError, RateLimitError)):
+        return True
+    if isinstance(error, APIStatusError):
+        return error.status_code in RETRIABLE_STATUS_CODES
+    return False
+
+
+def _is_non_retriable_error(error: Exception) -> bool:
+    """Check whether an API error should be raised immediately."""
+    if isinstance(error, APIStatusError):
+        return error.status_code in NON_RETRIABLE_STATUS_CODES
+    return False
+
+
+def _error_status(error: Exception) -> int | None:
+    """Extract HTTP status code from an API error, if present."""
+    if isinstance(error, APIStatusError):
+        return error.status_code
+    return None
+
+
+async def stream_message(
+    client: AsyncOpenAI,
+    model: str,
+    messages: list[Message],
+    system_prompt: str,
+    tools: list | None = None,
+    temperature: float = 0,
+    max_tokens: int = 16384,
+    thinking_config: Any = None,
+) -> AsyncIterator[StreamEvent]:
+    """Stream a chat completion, yielding events as they arrive.
+
+    Handles:
+    - Text deltas (character by character)
+    - Tool call deltas (incremental id/name/arguments)
+    - <think> tag extraction for models that support thinking (deepseek-r1, etc.)
+    - Finish events with stop reason
+    - Retry with exponential backoff on retriable errors (429, 500, 502, 503, 529)
+    - Mid-stream disconnection recovery (flushes accumulated text)
+    """
+    api_messages = normalise_messages_for_api(messages)
+
+    # Prepend system prompt
+    api_messages = [{"role": "system", "content": system_prompt}] + api_messages
+
+    api_tools = _tools_to_openai_schema(tools or [])
+
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": api_messages,
+        "stream": True,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+    }
+    if api_tools:
+        kwargs["tools"] = api_tools
+
+    # Extended thinking / reasoning — only sent when the model supports it
+    extra = _thinking_extra_body(model, thinking_config)
+    if extra:
+        kwargs["extra_body"] = extra
+
+    # --- Retry loop around stream creation ---
+    stream = None
+    consecutive_529 = 0
+
+    for attempt in range(STREAM_MAX_RETRIES + 1):
+        try:
+            stream = await client.chat.completions.create(**kwargs)
+            break
+        except Exception as e:
+            # Non-retriable errors (401, 403, 404) — raise immediately
+            if _is_non_retriable_error(e):
+                raise
+
+            if not _is_retriable_error(e):
+                raise
+
+            # Track consecutive 529s
+            status = _error_status(e)
+            if status == 529:
+                consecutive_529 += 1
+                if consecutive_529 > MAX_529_CONSECUTIVE:
+                    raise
+            else:
+                consecutive_529 = 0
+
+            if attempt >= STREAM_MAX_RETRIES:
+                raise
+
+            delay_s = STREAM_BASE_DELAY_S * (2 ** attempt)
+
+            logger.warning(
+                "Stream creation failed (attempt %d/%d, %s). "
+                "Retrying in %.1fs...",
+                attempt + 1,
+                STREAM_MAX_RETRIES,
+                type(e).__name__,
+                delay_s,
+            )
+
+            yield RetryEvent(
+                attempt=attempt + 1,
+                max_retries=STREAM_MAX_RETRIES,
+                delay_seconds=delay_s,
+                error_message=str(e),
+            )
+
+            await asyncio.sleep(delay_s)
+
+    if stream is None:
+        raise RuntimeError("Failed to create stream after retries")
+
+    # --- Consume the stream, handling mid-stream disconnections ---
+    usage = Usage()
+    in_thinking = False
+    thinking_buffer = ""
+
+    try:
+        async for chunk in stream:
+            # Extract usage if present
+            if hasattr(chunk, "usage") and chunk.usage:
+                usage = Usage(
+                    input_tokens=getattr(chunk.usage, "prompt_tokens", 0) or 0,
+                    output_tokens=getattr(chunk.usage, "completion_tokens", 0) or 0,
+                    total_tokens=getattr(chunk.usage, "total_tokens", 0) or 0,
+                )
+
+            if not chunk.choices:
+                continue
+
+            choice = chunk.choices[0]
+            delta = choice.delta
+
+            # --- Text deltas ---
+            if delta and delta.content:
+                text = delta.content
+
+                # Handle <think> tags for models that output thinking inline
+                # (deepseek-r1, QwQ, etc.)
+                if "<think>" in text:
+                    in_thinking = True
+                    # Split: part before <think> is text, rest is thinking
+                    before, _, after = text.partition("<think>")
+                    if before:
+                        yield TextDeltaEvent(text=before)
+                    thinking_buffer += after
+                    continue
+
+                if in_thinking:
+                    if "</think>" in text:
+                        before, _, after = text.partition("</think>")
+                        thinking_buffer += before
+                        yield ThinkingDeltaEvent(text=thinking_buffer)
+                        thinking_buffer = ""
+                        in_thinking = False
+                        if after:
+                            yield TextDeltaEvent(text=after)
+                    else:
+                        thinking_buffer += text
+                    continue
+
+                yield TextDeltaEvent(text=text)
+
+            # --- Tool call deltas ---
+            if delta and delta.tool_calls:
+                for tc_delta in delta.tool_calls:
+                    yield ToolCallDeltaEvent(
+                        index=tc_delta.index,
+                        id=tc_delta.id or None,
+                        name=getattr(tc_delta.function, "name", None) if tc_delta.function else None,
+                        arguments_delta=(
+                            tc_delta.function.arguments
+                            if tc_delta.function and tc_delta.function.arguments
+                            else ""
+                        ),
+                    )
+
+            # --- Finish ---
+            if choice.finish_reason:
+                # Flush any remaining thinking buffer
+                if thinking_buffer:
+                    yield ThinkingDeltaEvent(text=thinking_buffer)
+                    thinking_buffer = ""
+
+                yield FinishEvent(reason=choice.finish_reason)
+
+                if usage.input_tokens or usage.output_tokens:
+                    yield UsageEvent(usage=usage)
+
+    except (APIConnectionError, APITimeoutError) as e:
+        # Mid-stream disconnection: flush buffered content so the UI
+        # keeps whatever text was already received
+        logger.warning(
+            "Stream disconnected mid-response (%s). "
+            "Flushing accumulated text.",
+            type(e).__name__,
+        )
+        if thinking_buffer:
+            yield ThinkingDeltaEvent(text=thinking_buffer)
+
+        yield FinishEvent(reason="error")
+
+
+def accumulate_tool_calls(
+    accumulators: dict[int, ToolCallAccumulator],
+    event: ToolCallDeltaEvent,
+) -> dict[int, ToolCallAccumulator]:
+    """Accumulate incremental tool call deltas into complete ToolUseBlocks.
+
+    Tool calls arrive in pieces during streaming:
+    - First delta has `id` and `name`
+    - Subsequent deltas append to `arguments`
+    """
+    idx = event.index
+    if idx not in accumulators:
+        accumulators[idx] = ToolCallAccumulator()
+
+    acc = accumulators[idx]
+    if event.id:
+        acc.id = event.id
+    if event.name:
+        acc.name = event.name
+    acc.args_str += event.arguments_delta
+
+    return accumulators
+
+
+def finalise_tool_calls(
+    accumulators: dict[int, ToolCallAccumulator],
+) -> list[ToolUseBlock]:
+    """Convert accumulated tool call fragments to final ToolUseBlocks."""
+    return [
+        acc.to_tool_use_block()
+        for _, acc in sorted(accumulators.items())
+    ]