vibecore 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

vibecore/models/anthropic_auth.py

@@ -0,0 +1,226 @@
+"""Anthropic model with Pro/Max authentication support."""
+
+import logging
+from typing import Any, Literal, overload
+
+import litellm
+from agents.agent_output import AgentOutputSchemaBase
+from agents.handoffs import Handoff
+from agents.items import TResponseInputItem
+from agents.model_settings import ModelSettings
+from agents.models.interface import ModelTracing
+from agents.tool import Tool
+from agents.tracing.span_data import GenerationSpanData
+from agents.tracing.spans import Span
+from openai import AsyncStream
+from openai.types.chat import ChatCompletionChunk
+from openai.types.responses import Response
+
+from vibecore.auth.config import ANTHROPIC_CONFIG
+from vibecore.auth.interceptor import AnthropicRequestInterceptor
+from vibecore.auth.manager import AnthropicAuthManager
+from vibecore.auth.storage import SecureAuthStorage
+from vibecore.models.anthropic import AnthropicModel, _transform_messages_for_cache
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicProMaxModel(AnthropicModel):
+    """Anthropic model with Pro/Max authentication and Claude Code spoofing."""
+
+    def __init__(self, model_name: str, base_url: str | None = None, api_key: str | None = None, use_auth: bool = True):
+        """
+        Initialize AnthropicProMaxModel.
+
+        Args:
+            model_name: Name of the model.
+            base_url: Optional base URL override.
+            api_key: Optional API key (ignored if Pro/Max auth is active).
+            use_auth: Whether to use Pro/Max authentication.
+        """
+        super().__init__(model_name, base_url, api_key)
+        self.use_auth = use_auth
+        self.auth_manager: AnthropicAuthManager | None = None
+        self.interceptor: AnthropicRequestInterceptor | None = None
+
+        if self.use_auth:
+            self._initialize_auth()
+
+    def _initialize_auth(self) -> None:
+        """Initialize authentication components."""
+        storage = SecureAuthStorage()
+        self.auth_manager = AnthropicAuthManager()
+        self.interceptor = AnthropicRequestInterceptor(storage)
+
+        # Check if authenticated (we'll check async later when needed)
+        logger.info("AnthropicProMaxModel initialized with authentication support")
+
+    async def _inject_system_prompt(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """
+        Inject Claude Code identity into system messages.
+
+        Args:
+            messages: Original messages.
+
+        Returns:
+            Messages with Claude Code identity injected.
+        """
+        if not self.use_auth or not self.interceptor:
+            return messages
+
+        # Check if using Pro/Max auth
+        storage = SecureAuthStorage()
+        auth = await storage.load("anthropic")
+        if not auth or auth.type != "oauth":
+            return messages  # Only inject for Pro/Max users
+
+        # Find or create system message
+        messages_copy = messages.copy()
+        system_index = next((i for i, msg in enumerate(messages_copy) if msg.get("role") == "system"), None)
+
+        if system_index is not None:
+            # Prepend Claude Code identity to existing system message
+            current_content = messages_copy[system_index].get("content", "")
+            messages_copy[system_index]["content"] = f"{ANTHROPIC_CONFIG.CLAUDE_CODE_IDENTITY}\n\n{current_content}"
+        else:
+            # Add new system message at the beginning
+            messages_copy.insert(0, {"role": "system", "content": ANTHROPIC_CONFIG.CLAUDE_CODE_IDENTITY})
+
+        return messages_copy
+
+    async def _apply_auth_headers(self, headers: dict[str, str]) -> dict[str, str]:
+        """
+        Apply authentication and Claude Code headers.
+
+        Args:
+            headers: Original headers.
+
+        Returns:
+            Modified headers with auth and Claude Code spoofing.
+        """
+        if not self.use_auth or not self.interceptor:
+            return headers
+
+        # Use interceptor to apply auth and Claude Code headers
+        modified_request = await self.interceptor.intercept_request(url="https://api.anthropic.com", headers=headers)
+
+        return modified_request.get("headers", headers)
+
+    @overload
+    async def _fetch_response(
+        self,
+        system_instructions: str | None,
+        input: str | list[TResponseInputItem],
+        model_settings: ModelSettings,
+        tools: list[Tool],
+        output_schema: AgentOutputSchemaBase | None,
+        handoffs: list[Handoff],
+        span: Span[GenerationSpanData],
+        tracing: ModelTracing,
+        stream: Literal[True],
+        prompt: Any | None = None,
+    ) -> tuple[Response, AsyncStream[ChatCompletionChunk]]: ...
+
+    @overload
+    async def _fetch_response(
+        self,
+        system_instructions: str | None,
+        input: str | list[TResponseInputItem],
+        model_settings: ModelSettings,
+        tools: list[Tool],
+        output_schema: AgentOutputSchemaBase | None,
+        handoffs: list[Handoff],
+        span: Span[GenerationSpanData],
+        tracing: ModelTracing,
+        stream: Literal[False],
+        prompt: Any | None = None,
+    ) -> Any: ...
+
+    async def _fetch_response(
+        self,
+        system_instructions: str | None,
+        input: str | list[TResponseInputItem],
+        model_settings: ModelSettings,
+        tools: list[Tool],
+        output_schema: AgentOutputSchemaBase | None,
+        handoffs: list[Handoff],
+        span: Span[GenerationSpanData],
+        tracing: ModelTracing,
+        stream: bool = False,
+        prompt: Any | None = None,
+    ) -> Any | tuple[Response, AsyncStream[ChatCompletionChunk]]:
+        """Override _fetch_response to add auth and Claude Code support."""
+        # Store the original litellm.acompletion function
+        original_acompletion = litellm.acompletion
+
+        async def _intercepting_acompletion(*args, **kwargs):
+            """Intercept litellm.acompletion calls to transform messages and headers."""
+            # Only transform for this Anthropic model
+            if kwargs.get("model") == self.model:
+                if "messages" in kwargs:
+                    messages = kwargs["messages"]
+                    logger.debug(f"Intercepting Anthropic API call with {len(messages)} messages")
+
+                    # Add Claude Code identity to system prompt
+                    messages = await self._inject_system_prompt(messages)
+
+                    # Transform messages to add cache_control
+                    messages = _transform_messages_for_cache(messages)
+                    kwargs["messages"] = messages
+
+                # Apply auth headers if available
+                if self.use_auth and self.interceptor:
+                    # Get existing headers or create new dict
+                    headers = kwargs.get("extra_headers", {})
+
+                    # Apply auth and Claude Code headers
+                    headers = await self._apply_auth_headers(headers)
+
+                    # Update kwargs
+                    kwargs["extra_headers"] = headers
+
+                    # For Pro/Max users, prevent API key from being added
+                    storage = SecureAuthStorage()
+                    auth = await storage.load("anthropic")
+                    if auth and auth.type == "oauth":
+                        # CRITICAL: Set api_key to None to prevent litellm from adding x-api-key header
+                        # when using OAuth authentication
+                        kwargs["api_key"] = None
+
+            # Call the original function with transformed kwargs
+            return await original_acompletion(*args, **kwargs)
+
+        try:
+            # Temporarily replace litellm.acompletion
+            litellm.acompletion = _intercepting_acompletion
+
+            # Call the parent's implementation
+            if stream:
+                return await super()._fetch_response(
+                    system_instructions=system_instructions,
+                    input=input,
+                    model_settings=model_settings,
+                    tools=tools,
+                    output_schema=output_schema,
+                    handoffs=handoffs,
+                    span=span,
+                    tracing=tracing,
+                    stream=True,
+                    prompt=prompt,
+                )
+            else:
+                return await super()._fetch_response(
+                    system_instructions=system_instructions,
+                    input=input,
+                    model_settings=model_settings,
+                    tools=tools,
+                    output_schema=output_schema,
+                    handoffs=handoffs,
+                    span=span,
+                    tracing=tracing,
+                    stream=False,
+                    prompt=prompt,
+                )
+        finally:
+            # Always restore the original function
+            litellm.acompletion = original_acompletion

vibecore/settings.py

@@ -4,14 +4,28 @@ import os
 from pathlib import Path
 from typing import Literal
 
-from agents import Model, OpenAIChatCompletionsModel
+from agents import Model, ModelSettings, OpenAIChatCompletionsModel
 from agents.models.multi_provider import MultiProvider
-from pydantic import BaseModel, Field
+from openai.types import Reasoning
+from pydantic import BaseModel, Field, field_validator
 from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict, YamlConfigSettingsSource
 
 from vibecore.models import AnthropicModel
 
 
+class AuthSettings(BaseModel):
+    """Configuration for authentication."""
+
+    use_pro_max: bool = Field(
+        default=False,
+        description="Use Anthropic Pro/Max authentication if available",
+    )
+    auto_refresh: bool = Field(
+        default=True,
+        description="Automatically refresh OAuth tokens",
+    )
+
+
 class SessionSettings(BaseModel):
     """Configuration for session storage."""
 
@@ -92,9 +106,10 @@ class Settings(BaseSettings):
     default_model: str = Field(
         # default="o3",
         # default="gpt-4.1",
+        default="gpt-5",
         # default="qwen3-30b-a3b-mlx@8bit",
         # default="mistralai/devstral-small-2507",
-        default="anthropic/claude-sonnet-4-20250514",
+        # default="anthropic/claude-sonnet-4-20250514",
         # default="anthropic/claude-3-5-haiku-20241022",
         # default="litellm/deepseek/deepseek-chat",
         description="Default model to use for agents (e.g., 'gpt-4.1', 'o3-mini', 'anthropic/claude-sonnet-4')",
@@ -109,6 +124,24 @@ class Settings(BaseSettings):
         default=None,
         description="Default reasoning effort level for agents (null, 'minimal', 'low', 'medium', 'high')",
     )
+    reasoning_summary: Literal["auto", "concise", "detailed"] | None = Field(
+        default="auto",
+        description="Reasoning summary mode ('auto', 'concise', 'detailed', or 'off')",
+    )
+
+    @field_validator("reasoning_summary", mode="before")
+    @classmethod
+    def validate_reasoning_summary(cls, v):
+        """Convert string 'null' to None for reasoning_summary field."""
+        if v == "off" or v == "":
+            return None
+        return v
+
+    # Authentication configuration
+    auth: AuthSettings = Field(
+        default_factory=AuthSettings,
+        description="Authentication configuration",
+    )
 
     # Session configuration
     session: SessionSettings = Field(
@@ -122,22 +155,45 @@ class Settings(BaseSettings):
         description="List of MCP servers to connect to",
     )
 
+    rich_tool_names: list[str] = Field(
+        default_factory=list,
+        description="List of tools to render with RichToolMessage (temporary settings)",
+    )
+
     @property
     def model(self) -> str | Model:
         """Get the configured model.
 
-        Returns an AnthropicModel instance if the model name starts with 'anthropic/',
+        Returns an AnthropicProMaxModel instance if auth is enabled and model is Anthropic,
+        returns an AnthropicModel instance if the model name starts with 'anthropic/',
         returns a OpenAIChatCompletionsModel instance if there is a custom base URL set,
         otherwise returns the model name as a plain string (for OpenAI/LiteLLM models).
         """
         custom_base = "OPENAI_BASE_URL" in os.environ
         if self.default_model.startswith("anthropic/"):
-            return AnthropicModel(self.default_model)
+            # Check if Pro/Max auth should be used
+            if self.auth.use_pro_max:
+                from vibecore.models.anthropic_auth import AnthropicProMaxModel
+
+                return AnthropicProMaxModel(self.default_model, use_auth=True)
+            else:
+                return AnthropicModel(self.default_model)
         elif custom_base:
             openai_provider = MultiProvider().openai_provider
             return OpenAIChatCompletionsModel(self.default_model, openai_provider._get_client())
         return self.default_model
 
+    @property
+    def default_model_settings(self) -> ModelSettings:
+        """Get the default model settings."""
+        return ModelSettings(
+            include_usage=True,
+            reasoning=Reasoning(
+                summary=self.reasoning_summary,
+                effort=self.reasoning_effort,
+            ),
+        )
+
     @classmethod
     def settings_customise_sources(
         cls,

vibecore/tools/task/executor.py

@@ -7,7 +7,7 @@ from agents import (
 )
 from textual import log
 
-from vibecore.agents.task_agent import create_task_agent
+from vibecore.agents.task import create_task_agent
 from vibecore.context import VibecoreContext
 from vibecore.settings import settings
 

vibecore/tools/webfetch/__init__.py

@@ -0,0 +1,7 @@
+"""Webfetch tool for fetching and converting web content to Markdown."""
+
+from .executor import fetch_url
+from .models import WebFetchParams
+from .tools import webfetch
+
+__all__ = ["WebFetchParams", "fetch_url", "webfetch"]

vibecore/tools/webfetch/executor.py

@@ -0,0 +1,127 @@
+"""Webfetch execution logic for fetching and converting web content."""
+
+import json
+from urllib.parse import urlparse
+
+import html2text
+import httpx
+
+from .models import WebFetchParams
+
+
+async def fetch_url(params: WebFetchParams) -> str:
+    """Fetch a URL and convert its content to Markdown.
+
+    Args:
+        params: WebFetch parameters including URL and options
+
+    Returns:
+        Markdown-formatted content or error message
+    """
+    try:
+        # Validate URL
+        parsed = urlparse(params.url)
+        if not parsed.scheme:
+            return f"Error: Invalid URL - missing scheme (http:// or https://): {params.url}"
+        if not parsed.netloc:
+            return f"Error: Invalid URL - missing domain: {params.url}"
+        if parsed.scheme not in ["http", "https"]:
+            return f"Error: Unsupported URL scheme: {parsed.scheme}"
+
+        # Configure headers
+        headers = {
+            "User-Agent": params.user_agent
+            or "Mozilla/5.0 (compatible; Vibecore/1.0; +https://github.com/serialx/vibecore)",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,"
+            "text/plain;q=0.8,application/json;q=0.7,*/*;q=0.5",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Accept-Encoding": "gzip, deflate",
+        }
+
+        # Fetch the URL
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(params.timeout),
+            follow_redirects=params.follow_redirects,
+        ) as client:
+            response = await client.get(params.url, headers=headers)
+            response.raise_for_status()
+
+            # Get content type
+            content_type = response.headers.get("content-type", "").lower()
+
+            # Handle different content types
+            if "application/json" in content_type:
+                # Pretty-print JSON as Markdown code block
+                try:
+                    json_data = response.json()
+                    content = f"```json\n{json.dumps(json_data, indent=2)}\n```"
+                except json.JSONDecodeError:
+                    content = response.text[: params.max_length]
+
+            elif "text/html" in content_type or "application/xhtml" in content_type:
+                # Convert HTML to Markdown
+                html_content = response.text[: params.max_length]
+
+                # Configure html2text
+                h = html2text.HTML2Text()
+                h.ignore_links = False
+                h.ignore_images = False
+                h.ignore_emphasis = False
+                h.body_width = 0  # Don't wrap lines
+                h.skip_internal_links = False
+                h.inline_links = True
+                h.wrap_links = False
+                h.wrap_list_items = False
+                h.ul_item_mark = "-"
+                h.emphasis_mark = "*"
+                h.strong_mark = "**"
+
+                content = h.handle(html_content)
+
+                # Clean up excessive newlines
+                while "\n\n\n" in content:
+                    content = content.replace("\n\n\n", "\n\n")
+                content = content.strip()
+
+            elif "text/plain" in content_type or "text/" in content_type:
+                # Plain text - return as is
+                content = response.text[: params.max_length]
+
+            else:
+                # Unknown content type - try to handle as text
+                content = response.text[: params.max_length]
+                if not content:
+                    return f"Error: Unable to extract text content from {content_type}"
+
+            # Add metadata
+            metadata = [
+                f"# Content from {params.url}",
+                f"**Status Code:** {response.status_code}",
+                f"**Content Type:** {content_type.split(';')[0] if content_type else 'unknown'}",
+            ]
+
+            # Add redirect info if applicable
+            if response.history:
+                metadata.append(f"**Redirected:** {len(response.history)} time(s)")
+                metadata.append(f"**Final URL:** {response.url}")
+
+            metadata.append("")  # Empty line before content
+
+            # Check if content was truncated
+            if len(response.text) > params.max_length:
+                metadata.append(f"*Note: Content truncated to {params.max_length} characters*")
+                metadata.append("")
+
+            # Combine metadata and content
+            full_content = "\n".join(metadata) + "\n" + content
+
+            return full_content
+
+    except httpx.TimeoutException:
+        return f"Error: Request timed out after {params.timeout} seconds"
+    except httpx.HTTPStatusError as e:
+        return f"Error: HTTP {e.response.status_code} - {e.response.reason_phrase}"
+    except httpx.RequestError as e:
+        return f"Error: Failed to connect to {params.url}: {e!s}"
+    except Exception as e:
+        return f"Error: Unexpected error while fetching {params.url}: {e!s}"

vibecore/tools/webfetch/models.py

@@ -0,0 +1,22 @@
+"""Data models for the webfetch tool."""
+
+from pydantic import BaseModel, Field
+
+
+class WebFetchParams(BaseModel):
+    """Parameters for fetching web content."""
+
+    url: str = Field(description="The URL to fetch content from")
+    timeout: int = Field(default=30, description="Request timeout in seconds")
+    user_agent: str | None = Field(
+        default=None,
+        description="Optional custom User-Agent header",
+    )
+    follow_redirects: bool = Field(
+        default=True,
+        description="Whether to follow HTTP redirects",
+    )
+    max_length: int = Field(
+        default=1000000,  # ~1MB of text
+        description="Maximum content length to fetch in characters",
+    )

vibecore/tools/webfetch/tools.py

@@ -0,0 +1,46 @@
+"""Webfetch tool for Vibecore agents."""
+
+from agents import RunContextWrapper, function_tool
+
+from vibecore.context import VibecoreContext
+
+from .executor import fetch_url
+from .models import WebFetchParams
+
+
+@function_tool
+async def webfetch(
+    ctx: RunContextWrapper[VibecoreContext],
+    url: str,
+    timeout: int = 30,
+    follow_redirects: bool = True,
+) -> str:
+    """Fetch content from a URL and convert it to Markdown format.
+
+    This tool fetches web content and converts it to clean, readable Markdown.
+    It handles HTML pages, JSON APIs, and plain text content appropriately.
+
+    Args:
+        ctx: The run context wrapper
+        url: The URL to fetch content from (must include http:// or https://)
+        timeout: Request timeout in seconds (default: 30)
+        follow_redirects: Whether to follow HTTP redirects (default: True)
+
+    Returns:
+        Markdown-formatted content from the URL, including metadata about the
+        request (status code, content type, etc.) or an error message if the
+        fetch fails.
+
+    Examples:
+        - Fetch a webpage: url="https://example.com"
+        - Fetch JSON API: url="https://api.example.com/data"
+        - Fetch with timeout: url="https://slow-site.com", timeout=60
+        - Don't follow redirects: url="https://short.link/abc", follow_redirects=False
+    """
+    params = WebFetchParams(
+        url=url,
+        timeout=timeout,
+        follow_redirects=follow_redirects,
+    )
+
+    return await fetch_url(params)

vibecore/tools/websearch/__init__.py

@@ -0,0 +1,5 @@
+"""Websearch tool for Vibecore agents."""
+
+from .tools import websearch
+
+__all__ = ["websearch"]

vibecore/tools/websearch/base.py

@@ -0,0 +1,27 @@
+"""Base classes for websearch backends."""
+
+from abc import ABC, abstractmethod
+
+from .models import SearchParams
+
+
+class WebSearchBackend(ABC):
+    """Abstract base class for web search backends."""
+
+    @abstractmethod
+    async def search(self, params: SearchParams) -> str:
+        """Perform a web search.
+
+        Args:
+            params: Search parameters
+
+        Returns:
+            JSON string containing search results or error message
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the name of this backend."""
+        pass

vibecore/tools/websearch/ddgs/__init__.py

@@ -0,0 +1,5 @@
+"""DuckDuckGo search backend for websearch tool."""
+
+from .backend import DDGSBackend
+
+__all__ = ["DDGSBackend"]

vibecore/tools/websearch/ddgs/backend.py

@@ -0,0 +1,64 @@
+"""DuckDuckGo search backend implementation."""
+
+import json
+
+from ddgs import DDGS
+
+from ..base import WebSearchBackend
+from ..models import SearchParams, SearchResult
+
+
+class DDGSBackend(WebSearchBackend):
+    """DuckDuckGo search backend using ddgs library."""
+
+    @property
+    def name(self) -> str:
+        """Return the name of this backend."""
+        return "DuckDuckGo"
+
+    async def search(self, params: SearchParams) -> str:
+        """Perform a web search using ddgs.
+
+        Args:
+            params: Search parameters
+
+        Returns:
+            JSON string containing search results or error message
+        """
+        try:
+            # Create DDGS instance
+            ddgs = DDGS()
+
+            # Perform search (synchronous call)
+            # ddgs.text() expects 'query' as first positional argument
+            raw_results = ddgs.text(
+                query=params.query,
+                region=params.region,
+                safesearch=params.safesearch,
+                max_results=params.max_results,
+            )
+
+            # Convert to our model format
+            results = []
+            for r in raw_results:
+                result = SearchResult(
+                    title=r.get("title", ""),
+                    href=r.get("href", ""),
+                    body=r.get("body", ""),
+                )
+                results.append(result.model_dump())
+
+            if not results:
+                return json.dumps({"success": False, "message": "No search results found", "results": []})
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": f"Found {len(results)} result{'s' if len(results) != 1 else ''}",
+                    "query": params.query,
+                    "results": results,
+                }
+            )
+
+        except Exception as e:
+            return json.dumps({"success": False, "message": f"Search failed: {e!s}", "results": []})