vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/llm/sdk/base.py

@@ -0,0 +1,82 @@
+"""Base SDK class for LLM providers."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Message:
+    role: str
+    content: str
+    metadata: dict[str, Any] | None = None
+    image_parts: list[str] | None = None
+
+
+@dataclass
+class GenerationConfig:
+    model: str
+    temperature: float = 0.7
+    max_tokens: int | None = None
+    top_p: float | None = None
+    frequency_penalty: float | None = None
+    presence_penalty: float | None = None
+    stop_sequences: list[str] | None = None
+    tool_choice: str | dict | bool | None = None
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: str
+
+
+@dataclass
+class GenerationResponse:
+    content: str
+    model: str
+    finish_reason: str | None = None
+    tool_calls: list[ToolCall] | None = None
+    usage: dict[str, int] | None = None
+    reasoning_content: str = ""
+
+
+class BaseLLMSDK(ABC):
+    def __init__(self, api_key: str, base_url: str | None = None):
+        self.api_key = api_key
+        self.base_url = base_url
+
+    @property
+    @abstractmethod
+    def client(self): ...
+
+    @abstractmethod
+    async def generate(
+        self, messages: list[Message], config: GenerationConfig, stream: bool = False
+    ) -> GenerationResponse | AsyncGenerator: ...
+
+    @abstractmethod
+    async def generate_with_tools(
+        self,
+        messages: list[Message],
+        tools: list[dict],
+        config: GenerationConfig,
+        stream: bool = False,
+    ) -> GenerationResponse | AsyncGenerator: ...
+
+    @abstractmethod
+    def get_available_models(self) -> list[str]: ...
+
+    def convert_messages_to_dict(self, messages: list[Message]) -> list[dict]:
+        result = []
+        for msg in messages:
+            if msg.image_parts:
+                content: list[dict[str, Any]] = [{"type": "text", "text": msg.content}]
+                for image_url in msg.image_parts:
+                    content.append({"type": "image_url", "image_url": {"url": image_url}})
+                result.append({"role": msg.role, "content": content, **(msg.metadata or {})})
+            else:
+                result.append({"role": msg.role, "content": msg.content, **(msg.metadata or {})})
+        return result

vtx/llm/sdk/openai.py

@@ -0,0 +1,344 @@
+"""OpenAI GPT SDK using the official openai package."""
+
+import asyncio
+import logging
+import os
+from collections.abc import AsyncGenerator, AsyncIterator
+from typing import Any
+
+from openai import AsyncOpenAI
+from openai.types.chat import ChatCompletionChunk, ChatCompletionToolParam
+
+from .base import BaseLLMSDK, GenerationConfig, GenerationResponse, Message, ToolCall
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MODEL = "gpt-4o"
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 1.0
+
+
+def _is_transient_error(e: Exception) -> bool:
+    msg = str(e).lower()
+    return any(
+        s in msg
+        for s in [
+            "connection",
+            "connect",
+            "timeout",
+            "timed out",
+            "reset",
+            "broken pipe",
+            "eof",
+            "network",
+            "unavailable",
+            "bad gateway",
+            "gateway timeout",
+            "service unavailable",
+        ]
+    )
+
+
+async def _retry_on_transient(coro_factory, max_retries: int = _MAX_RETRIES):
+    last_error = None
+    for attempt in range(max_retries):
+        try:
+            return await coro_factory()
+        except Exception as e:
+            last_error = e
+            if not _is_transient_error(e) or attempt == max_retries - 1:
+                raise
+            delay = _RETRY_BASE_DELAY * (2**attempt)
+            logger.warning(
+                "Transient error (attempt %d/%d), retrying in %.1fs: %s",
+                attempt + 1,
+                max_retries,
+                delay,
+                str(e)[:200],
+            )
+            await asyncio.sleep(delay)
+    if last_error is not None:
+        raise last_error
+
+
+async def _openai_stream_chunks(
+    stream: AsyncIterator[ChatCompletionChunk],
+) -> AsyncGenerator[dict[str, Any], None]:
+    from ..phase_parser import (
+        INLINE_THINK_SIGNATURE,
+        ResponseDelta,
+        ResponseEnd,
+        ResponseStart,
+        ThinkDelta,
+        ThinkEnd,
+        ThinkingPhaseParser,
+        ThinkStart,
+    )
+
+    tool_calls_acc: dict[int, dict[str, Any]] = {}
+    phase_parser = ThinkingPhaseParser()
+    think_emitted_len = 0
+    try:
+        async for chunk in stream:
+            if chunk.usage:
+                yield {"type": "usage", "usage": chunk.usage.model_dump()}
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+            reasoning_delta = getattr(delta, "reasoning_content", None) or getattr(
+                delta, "reasoning", None
+            )
+            if reasoning_delta:
+                yield {
+                    "type": "reasoning",
+                    "content": reasoning_delta,
+                    "signature": "reasoning_content",
+                }
+            elif delta.content:
+                for phase_event in phase_parser.feed(delta.content):
+                    if isinstance(phase_event, ThinkStart):
+                        pass
+                    elif isinstance(phase_event, ThinkDelta):
+                        think_emitted_len += len(phase_event.text)
+                        yield {
+                            "type": "reasoning",
+                            "content": phase_event.text,
+                            "signature": INLINE_THINK_SIGNATURE,
+                        }
+                    elif isinstance(phase_event, ThinkEnd):
+                        remaining = phase_event.full_thinking[think_emitted_len:]
+                        if remaining:
+                            yield {
+                                "type": "reasoning",
+                                "content": remaining,
+                                "signature": INLINE_THINK_SIGNATURE,
+                            }
+                        think_emitted_len = 0
+                    elif isinstance(phase_event, ResponseStart):
+                        pass
+                    elif isinstance(phase_event, ResponseDelta):
+                        yield {"type": "text", "content": phase_event.text}
+                    elif isinstance(phase_event, ResponseEnd):
+                        pass
+            if delta.tool_calls:
+                for tc_delta in delta.tool_calls:
+                    idx = tc_delta.index
+                    if idx not in tool_calls_acc:
+                        tool_calls_acc[idx] = {"id": "", "name": "", "arguments": ""}
+                    if tc_delta.id:
+                        tool_calls_acc[idx]["id"] = tc_delta.id
+                    if tc_delta.function:
+                        if tc_delta.function.name:
+                            tool_calls_acc[idx]["name"] = tc_delta.function.name
+                        if tc_delta.function.arguments:
+                            tool_calls_acc[idx]["arguments"] += tc_delta.function.arguments
+        for phase_event in phase_parser.flush():
+            if isinstance(phase_event, ThinkDelta):
+                think_emitted_len += len(phase_event.text)
+                yield {
+                    "type": "reasoning",
+                    "content": phase_event.text,
+                    "signature": INLINE_THINK_SIGNATURE,
+                }
+            elif isinstance(phase_event, ThinkEnd):
+                remaining = phase_event.full_thinking[think_emitted_len:]
+                if remaining:
+                    yield {
+                        "type": "reasoning",
+                        "content": remaining,
+                        "signature": INLINE_THINK_SIGNATURE,
+                    }
+                think_emitted_len = 0
+            elif isinstance(phase_event, ResponseDelta):
+                yield {"type": "text", "content": phase_event.text}
+        if tool_calls_acc:
+            yield {
+                "type": "tool_calls",
+                "tool_calls": [
+                    ToolCall(id=v["id"], name=v["name"], arguments=v["arguments"])
+                    for v in sorted(tool_calls_acc.values(), key=lambda x: x["id"])
+                ],
+            }
+    finally:
+        if hasattr(stream, "close"):
+            try:
+                from typing import cast as typing_cast
+
+                await typing_cast(Any, stream).close()
+            except Exception:
+                pass
+
+
+class OpenAISDK(BaseLLMSDK):
+    def __init__(self, api_key: str, base_url: str | None = None, rate_limit_hook=None):
+        resolved_url = base_url or "https://api.openai.com/v1"
+        if resolved_url.startswith("http://"):
+            resolved_url = "https://" + resolved_url[7:]
+        super().__init__(api_key, resolved_url)
+        self._async_client: AsyncOpenAI | None = None
+        self._rate_limit_hook = rate_limit_hook
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        if self._async_client is None:
+            self._async_client = AsyncOpenAI(
+                api_key=self.api_key, base_url=self.base_url, timeout=None, max_retries=3
+            )
+        return self._async_client
+
+    def _build_kwargs(
+        self, messages: list[Message], config: GenerationConfig, tools: list[dict] | None = None
+    ) -> dict[str, Any]:
+        openai_messages = self.convert_messages_to_dict(messages)
+        model = (
+            config.model.strip()
+            if config.model and config.model.strip()
+            else os.getenv("VTX_MODEL", "").strip() or _DEFAULT_MODEL
+        )
+        kwargs: dict[str, Any] = {"model": model, "messages": openai_messages}
+        if config.temperature is not None and config.temperature != 0.7:
+            kwargs["temperature"] = config.temperature
+        if config.max_tokens is not None:
+            kwargs["max_tokens"] = config.max_tokens
+        if config.top_p is not None:
+            kwargs["top_p"] = config.top_p
+        if config.frequency_penalty is not None and config.frequency_penalty != 0.0:
+            kwargs["frequency_penalty"] = config.frequency_penalty
+        if config.presence_penalty is not None and config.presence_penalty != 0.0:
+            kwargs["presence_penalty"] = config.presence_penalty
+        if config.stop_sequences:
+            kwargs["stop"] = config.stop_sequences
+        if tools:
+            kwargs["tools"] = [
+                ChatCompletionToolParam(
+                    type="function",
+                    function={
+                        "name": t["function"]["name"],
+                        "description": t["function"].get("description", ""),
+                        "parameters": t["function"]["parameters"],
+                    },
+                )
+                for t in tools
+            ]
+            if config.tool_choice is not None:
+                kwargs["tool_choice"] = config.tool_choice
+        return kwargs
+
+    async def generate(
+        self, messages: list[Message], config: GenerationConfig, stream: bool = False
+    ) -> GenerationResponse | AsyncGenerator:
+        try:
+            kwargs = self._build_kwargs(messages, config)
+            kwargs["stream"] = stream
+            if stream:
+                raw_stream = await _retry_on_transient(
+                    lambda: self.client.chat.completions.create(**kwargs)
+                )
+                return _openai_stream_chunks(raw_stream)
+            else:
+
+                async def _do_generate():
+                    return await self.client.chat.completions.create(**kwargs)
+
+                completion = await _retry_on_transient(_do_generate)
+                choice = completion.choices[0]
+                msg = choice.message
+                content = msg.content or ""
+                reasoning = (
+                    getattr(msg, "reasoning_content", None) or getattr(msg, "reasoning", "") or ""
+                )
+                usage = completion.usage
+                return GenerationResponse(
+                    content=content,
+                    model=completion.model,
+                    finish_reason=choice.finish_reason,
+                    usage=(
+                        {
+                            "input_tokens": usage.prompt_tokens if usage else 0,
+                            "output_tokens": usage.completion_tokens if usage else 0,
+                            "total_tokens": usage.total_tokens if usage else 0,
+                        }
+                        if usage
+                        else None
+                    ),
+                    reasoning_content=reasoning,
+                )
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "rate limit" in error_msg or "too many requests" in error_msg or "429" in error_msg:
+                raise RuntimeError(f"Rate limit exceeded: {e!s}") from e
+            raise RuntimeError(f"OpenAI generation failed: {e!s}") from e
+
+    async def generate_with_tools(
+        self,
+        messages: list[Message],
+        tools: list[dict],
+        config: GenerationConfig,
+        stream: bool = False,
+    ) -> GenerationResponse | AsyncGenerator:
+        try:
+            kwargs = self._build_kwargs(messages, config, tools)
+            kwargs["stream"] = stream
+            if stream:
+                kwargs["stream_options"] = {"include_usage": True}
+                raw_stream = await _retry_on_transient(
+                    lambda: self.client.chat.completions.create(**kwargs)
+                )
+                return _openai_stream_chunks(raw_stream)
+            else:
+
+                async def _do_generate():
+                    return await self.client.chat.completions.create(**kwargs)
+
+                completion = await _retry_on_transient(_do_generate)
+                choice = completion.choices[0]
+                msg = choice.message
+                content = msg.content or ""
+                reasoning = (
+                    getattr(msg, "reasoning_content", None) or getattr(msg, "reasoning", "") or ""
+                )
+                tool_calls = []
+                if msg.tool_calls:
+                    for tc in msg.tool_calls:
+                        tool_calls.append(
+                            ToolCall(
+                                id=tc.id, name=tc.function.name, arguments=tc.function.arguments
+                            )
+                        )
+                usage = completion.usage
+                return GenerationResponse(
+                    content=content,
+                    model=completion.model,
+                    finish_reason=choice.finish_reason,
+                    tool_calls=tool_calls or None,
+                    usage=(
+                        {
+                            "input_tokens": usage.prompt_tokens if usage else 0,
+                            "output_tokens": usage.completion_tokens if usage else 0,
+                            "total_tokens": usage.total_tokens if usage else 0,
+                        }
+                        if usage
+                        else None
+                    ),
+                    reasoning_content=reasoning,
+                )
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "rate limit" in error_msg or "too many requests" in error_msg or "429" in error_msg:
+                raise RuntimeError(f"Rate limit exceeded: {e!s}") from e
+            raise RuntimeError(f"OpenAI tool generation failed: {e!s}") from e
+
+    def get_available_models(self) -> list[str]:
+        return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"]
+
+    def convert_messages_to_dict(self, messages: list[Message]) -> list[dict]:
+        result = []
+        for msg in messages:
+            if msg.image_parts:
+                content: list[dict[str, Any]] = [{"type": "text", "text": msg.content}]
+                for image_url in msg.image_parts:
+                    content.append({"type": "image_url", "image_url": {"url": image_url}})
+                result.append({"role": msg.role, "content": content, **(msg.metadata or {})})
+            else:
+                result.append({"role": msg.role, "content": msg.content, **(msg.metadata or {})})
+        return result

vtx/llm/tool_parser.py

@@ -0,0 +1,161 @@
+"""Tool call parser for handling text-embedded tool calls.
+
+This module parses tool calls embedded in text content, supporting formats like:
+- <function=name>...</function>
+- <function name="name">...</function>
+- With nested <parameter name="x">value</parameter> tags
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+
+def extract_tool_calls_from_text(content: str) -> list[dict[str, Any]]:
+    """Extract tool calls embedded in text content.
+
+    Supports formats:
+    - <function=name>...</function>
+    - <function name="name">...</function>
+    - With nested <parameter name="x">value</parameter> tags
+    - Self-closing: <function=name/> or <function name="name"/>
+
+    Args:
+        content: Text content that may contain embedded tool calls
+
+    Returns:
+        List of dicts: [{"name": "tool_name", "arguments": {...}}]
+    """
+    tool_calls = []
+
+    # Match both self-closing and open/close tag pairs
+    # Pattern for: <function=name ...> or <function name="name" ...>
+    # Then either /> for self-closing or >...</function> for open/close
+
+    # First, find all function tags (both self-closing and with content)
+    # Match: <function=name ...> or <function name="name" ...>
+    function_start_pattern = (
+        r"<function(?:\s+name=[\"\']?([^\"\'\s/>]+)[\"\']?|=[\"\']?([^\"\'\s/>]+)[\"\']?)([^>]*)"
+    )
+
+    for match in re.finditer(function_start_pattern, content):
+        name1 = match.group(1)  # function name="xxx" format
+        name2 = match.group(2)  # function=xxx format
+        attrs = match.group(3)  # Additional attributes
+
+        tool_name = name1 or name2
+        if not tool_name:
+            continue
+
+        # Find the full function tag (self-closing or with content)
+        start_pos = match.start()
+
+        # Check if self-closing
+        if "/>" in content[start_pos : start_pos + 200]:  # Look ahead for />
+            # Self-closing tag
+            arguments = _parse_function_attributes(attrs)
+            tool_calls.append({"name": tool_name, "arguments": arguments})
+        else:
+            # Find matching </function>
+            end_tag = "</function>"
+            end_pos = content.find(end_tag, start_pos)
+            if end_pos == -1:
+                continue
+
+            # Extract body (content between > and </function>)
+            tag_end = content.find(">", start_pos)
+            if tag_end == -1:
+                continue
+
+            body = content[tag_end + 1 : end_pos]
+
+            arguments = _parse_function_attributes(attrs)
+
+            # Parse parameters from body
+            if body:
+                param_pattern = (
+                    r"<parameter\s+name=[\"\']?([^\"\'\s/>]+)[\"\']?[^>]*>(.*?)</parameter>"
+                )
+                for param_match in re.finditer(param_pattern, body, re.DOTALL):
+                    param_name = param_match.group(1)
+                    param_value = param_match.group(2)
+                    arguments[param_name] = param_value
+
+            tool_calls.append({"name": tool_name, "arguments": arguments})
+
+    return tool_calls
+
+
+def _parse_function_attributes(attrs: str) -> dict[str, Any]:
+    """Parse attributes from function tag."""
+    arguments = {}
+    if not attrs:
+        return arguments
+
+    attr_pattern = r'(\w+)=(?:"([^"]*)"|\'([^\']*)\'|([^\s/>]+))'
+    for attr_match in re.finditer(attr_pattern, attrs):
+        key = attr_match.group(1)
+        value = attr_match.group(2) or attr_match.group(3) or attr_match.group(4) or ""
+        if key not in ("name", "function"):
+            arguments[key] = value
+
+    return arguments
+
+
+def has_text_tool_calls(content: str) -> bool:
+    """Check if content contains text-embedded tool calls.
+
+    Args:
+        content: Text content to check
+
+    Returns:
+        True if content contains <function...> tags
+    """
+    if not content:
+        return False
+    return bool(re.search(r"<function[\s=]", content))
+
+
+def normalize_tool_calls(tool_calls: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Normalize tool calls to format compatible with ToolRegistry.
+
+    Converts arguments dict to JSON string for compatibility with
+    the existing tool execution pipeline.
+
+    Args:
+        tool_calls: List of tool call dicts with "name" and "arguments" keys
+
+    Returns:
+        Normalized list with arguments as JSON strings
+    """
+    normalized = []
+    for tc in tool_calls:
+        normalized.append(
+            {"name": tc.get("name", ""), "arguments": json.dumps(tc.get("arguments", {}))}
+        )
+    return normalized
+
+
+def extract_text_and_tool_calls(content: str) -> tuple[str, list[dict[str, Any]]]:
+    """Extract both text content and tool calls from a mixed response.
+
+    Args:
+        content: Text that may contain embedded tool calls
+
+    Returns:
+        Tuple of (cleaned_text, tool_calls)
+        - cleaned_text: Text with tool call tags removed
+        - tool_calls: List of extracted tool calls
+    """
+    if not has_text_tool_calls(content):
+        return content, []
+
+    tool_calls = extract_tool_calls_from_text(content)
+
+    # Remove function tags from text (both self-closing and with content)
+    cleaned = re.sub(r"<function[^>]*(?:/>|>.*?</function>)", "", content, flags=re.DOTALL)
+    cleaned = re.sub(r"\n\s*\n", "\n\n", cleaned).strip()  # Clean up extra newlines
+
+    return cleaned, tool_calls