hanuscode 1.0.0__py3-none-any.whl

hanus/config.py

@@ -0,0 +1,401 @@
+# config.py
+"""
+Configuración de Hanus. Carga desde:
+  1. ~/.hanus/config.yaml  (global)
+  2. .hanus.yaml           (local, en la raíz del proyecto)
+  3. Variables de entorno  (prioridad máxima)
+
+También puede usar hanus.yaml en el directorio del paquete como plantilla.
+"""
+from __future__ import annotations
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+CONFIG_DIR    = Path.home() / ".hanus"
+GLOBAL_CONFIG = CONFIG_DIR / "config.yaml"
+PACKAGE_CONFIG = Path(__file__).parent.parent / "hanus.yaml"  # hanus.yaml in package root
+
+
+def _yaml(path: Path) -> Dict:
+    if not path.exists():
+        return {}
+    try:
+        import yaml
+        return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    except ImportError:
+        # Parse mínimo sin PyYAML
+        out = {}
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and ":" in line:
+                k, _, v = line.partition(":")
+                out[k.strip()] = v.strip().strip('"\'')
+        return out
+    except Exception:
+        return {}
+
+
+@dataclass
+class HanusConfig:
+    # ── Modelo ────────────────────────────────────────────────────────────────
+    provider:   str = "ollama"          # claude|openai|gemini|ollama|glm
+    model_id:   str = "llama3"     # Modelo por defecto (GLM via Ollama)
+    max_tokens: int = 8096
+
+    # ── API Keys ──────────────────────────────────────────────────────────────
+    anthropic_api_key: str = ""
+    openai_api_key:    str = ""
+    gemini_api_key:    str = ""
+    glm_api_key:       str = ""          # API key para GLM Cloud (ZhipuAI)
+    ollama_url:        str = "http://localhost:11434"
+
+    # ── Permisos ──────────────────────────────────────────────────────────────
+    permission_mode: str = "bypass"       # default | plan | bypass
+    max_tool_calls:  int = 2000
+
+    # ── Proyecto ──────────────────────────────────────────────────────────────
+    root_dir:    Path = field(default_factory=Path.cwd)
+    plugins_dir: Path = field(default_factory=lambda: Path.cwd() / "plugins")
+    prompt_file: Path = field(default_factory=lambda: CONFIG_DIR / "system_prompt.txt")
+
+    # ── Contexto ──────────────────────────────────────────────────────────────
+    context_max_files:      int  = 50
+    context_include_content: bool = True
+    context_preview_chars:  int  = 3000
+    max_file_read_chars:    int  = 100_000
+
+    # ── Ejecución ─────────────────────────────────────────────────────────────
+    shell_timeout:       int = 60
+    python_exec_timeout: int = 120
+
+    # ── Presupuesto ───────────────────────────────────────────────────────────
+    budget_usd:      float = 0.0    # 0 = sin límite
+    budget_warn_pct: float = 0.8
+
+    # ── Sesiones ──────────────────────────────────────────────────────────────
+    auto_save_session: bool = True
+
+    # ── Contexto ────────────────────────────────────────────────────────────────
+    context_window: int = 200000  # Ventana de contexto del modelo (tokens)
+    context_compress_threshold: float = 0.75  # Comprimir al 75% del límite
+
+    # ── UI ──────────────────────────────────────────────────────────────────────
+    show_cost: bool = True
+    verbose:   bool = False
+
+    @classmethod
+    def load(cls, project_dir: Optional[Path] = None) -> "HanusConfig":
+        cfg = cls()
+        cfg.root_dir    = project_dir or Path.cwd()
+        cfg.plugins_dir = cfg.root_dir / "plugins"
+
+        # Load order: package default -> global -> local -> env
+        cfg._apply(_yaml(PACKAGE_CONFIG))  # Package defaults (hanus.yaml)
+        cfg._apply(_yaml(GLOBAL_CONFIG))   # User global config
+        cfg._apply(_yaml(cfg.root_dir / ".hanus.yaml"))  # Project local config
+        cfg._apply_env()  # Environment variables (highest priority)
+        return cfg
+
+    def _apply(self, data: Dict):
+        for k, v in data.items():
+            k = k.lower().replace("-", "_")
+            if not hasattr(self, k):
+                continue
+            cur = getattr(self, k)
+            if isinstance(cur, Path):
+                setattr(self, k, Path(str(v)).expanduser())
+            elif isinstance(cur, bool):
+                setattr(self, k, str(v).lower() in ("true", "1", "yes"))
+            elif isinstance(cur, int):
+                setattr(self, k, int(v))
+            elif isinstance(cur, float):
+                setattr(self, k, float(v))
+            else:
+                setattr(self, k, str(v))
+
+    def _apply_env(self):
+        ENV = {
+            "ANTHROPIC_API_KEY":     "anthropic_api_key",
+            "OPENAI_API_KEY":        "openai_api_key",
+            "GEMINI_API_KEY":        "gemini_api_key",
+            "OLLAMA_URL":            "ollama_url",
+            "HANUS_PROVIDER":        "provider",
+            "HANUS_MODEL":           "model_id",
+            "HANUS_MODE":            "permission_mode",
+            "HANUS_BUDGET":          "budget_usd",
+            "HANUS_VERBOSE":         "verbose",
+        }
+        for env_key, attr in ENV.items():
+            v = os.environ.get(env_key)
+            if v:
+                self._apply({attr: v})
+
+    def get_connector_config(self) -> Dict[str, Any]:
+        base: Dict[str, Any] = {"model_id": self.model_id, "max_tokens": self.max_tokens}
+        p = self.provider.lower()
+        if p == "claude":
+            base["api_key"] = self.anthropic_api_key
+        elif p == "openai":
+            base["api_key"] = self.openai_api_key
+        elif p == "gemini":
+            base["api_key"] = self.gemini_api_key
+        elif p == "ollama":
+            base["ollama_url"] = self.ollama_url
+        elif p == "glm":
+            base["api_key"] = self.glm_api_key
+        return base
+
+    def load_system_prompt(self, plugin_docs: str = "") -> str:
+        base = _DEFAULT_PROMPT
+        if self.prompt_file.exists():
+            try:
+                base = self.prompt_file.read_text(encoding="utf-8")
+            except Exception:
+                pass
+        if plugin_docs:
+            base += f"\n\n## Available Plugins\n\n{plugin_docs}"
+        return base
+
+    def save_global(self):
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        GLOBAL_CONFIG.write_text(
+            f"provider: {self.provider}\n"
+            f"model_id: {self.model_id}\n"
+            f"permission_mode: {self.permission_mode}\n"
+            f"budget_usd: {self.budget_usd}\n"
+            f"show_cost: {str(self.show_cost).lower()}\n",
+            encoding="utf-8",
+        )
+
+    def export_full(self, path: Optional[Path] = None) -> Path:
+        """
+        Export full configuration to a YAML file.
+
+        Args:
+            path: Target path (default: GLOBAL_CONFIG)
+
+        Returns:
+            Path to the exported config file
+        """
+        from datetime import datetime
+
+        target = path or GLOBAL_CONFIG
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+        content = f"""# ═══════════════════════════════════════════════════════════════════════════════
+# HANUSCODE CONFIGURATION
+# Generated: {datetime.now().isoformat()}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# ─── AI MODEL ──────────────────────────────────────────────────────────────────
+provider: {self.provider}
+model_id: {self.model_id}
+max_tokens: {self.max_tokens}
+context_window: {self.context_window}
+
+# ─── API KEYS ──────────────────────────────────────────────────────────────────
+# Set via environment variables for security: ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.
+# anthropic_api_key: ""
+# openai_api_key: ""
+# gemini_api_key: ""
+# glm_api_key: ""
+ollama_url: "{self.ollama_url}"
+
+# ─── PERMISSIONS ───────────────────────────────────────────────────────────────
+permission_mode: {self.permission_mode}
+max_tool_calls: {self.max_tool_calls}
+
+# ─── CONTEXT ───────────────────────────────────────────────────────────────────
+context_max_files: {self.context_max_files}
+context_include_content: {str(self.context_include_content).lower()}
+context_preview_chars: {self.context_preview_chars}
+max_file_read_chars: {self.max_file_read_chars}
+context_compress_threshold: {self.context_compress_threshold}
+
+# ─── EXECUTION ─────────────────────────────────────────────────────────────────
+shell_timeout: {self.shell_timeout}
+python_exec_timeout: {self.python_exec_timeout}
+
+# ─── BUDGET ────────────────────────────────────────────────────────────────────
+budget_usd: {self.budget_usd}
+budget_warn_pct: {self.budget_warn_pct}
+
+# ─── SESSIONS ──────────────────────────────────────────────────────────────────
+auto_save_session: {str(self.auto_save_session).lower()}
+
+# ─── UI ────────────────────────────────────────────────────────────────────────
+show_cost: {str(self.show_cost).lower()}
+verbose: {str(self.verbose).lower()}
+"""
+        target.write_text(content, encoding="utf-8")
+        return target
+
+    @staticmethod
+    def generate_default_config() -> str:
+        """Generate default configuration file content."""
+        return (Path(__file__).parent.parent / "hanus.yaml").read_text(encoding="utf-8")
+
+
+_DEFAULT_PROMPT = """You are Hanus Code, an autonomous senior software engineer. You complete tasks from start to finish without stopping.
+
+## CORE IDENTITY
+
+You are a professional software engineer who:
+- Writes clean, maintainable, production-ready code
+- Follows best practices and established patterns
+- Verifies work before completion
+- Never stops mid-task
+
+## AVAILABLE TOOLS
+
+### File Operations
+- <read_file path="file.py"/> — Read file contents
+- <write_file path="file.py">content</write_file> — Create/overwrite file
+- <create_file path="file.py">content</create_file> — Create new file
+- <edit_file path="file.py" old="text" new="text"/> — Edit file by replacing text
+- <append_to_file path="file.py">content</append_to_file> — Append to file
+- <glob_search pattern="**/*.py"/> — Find files matching pattern
+- <grep_search pattern="def func" dir="src" regex="true"/> — Search text in files
+- <list_files dir="."/> — List directory contents
+
+### Execution
+- <exec_cmd cmd="python script.py"/> — Run shell command (simple)
+- <exec_cmd>multiline command with pipes | and quotes 'value'</exec_cmd> — Block format
+- <exec_file path="script.py"/> — Execute Python file
+
+### Git Operations
+- <git_status/> — Show working tree status
+- <git_diff/> — Show uncommitted changes
+- <git_log limit="10"/> — Show commit history
+- <git_commit message="message"/> — Create commit
+- <git_push branch="main"/> — Push to remote
+- <git_reset mode="hard" target="HEAD~1"/> — Reset commits
+- <git_branch name="feature"/> — Create/list branches
+
+### Web & Research
+- <web_fetch url="https://..." prompt="extract info"/> — Fetch and parse web page
+- <web_search query="python async best practices"/> — Search the web
+
+### Task Management
+- <task_create subject="Task name" description="Details"/> — Create task
+- <task_update taskId="1" status="in_progress"/> — Update task status
+- <task_list/> — List all tasks
+- <task_get taskId="1"/> — Get task details
+
+### Memory System (Persistent Context)
+- <memory_save name="project-context">Important info to remember</memory_save> — Save memory
+- <memory_search query="authentication"/> — Search memories
+- <memory_list/> — List all memories
+
+### Planning Mode
+- <plan_create name="plan-name" description="What to accomplish"/> — Create plan
+- <plan_add_step planId="1" description="Step details"/> — Add step to plan
+- <plan_update_step planId="1" stepId="1" status="completed"/> — Update step
+- <plan_list/> — List plans
+- <plan_get planId="1"/> — Get plan details
+- <plan_approve planId="1"/> — Approve plan
+- <plan_reject planId="1"/> — Reject plan
+
+### Subagents (Parallel Tasks)
+- <subagent type="Explore" prompt="Find all API endpoints"/> — Spawn specialized agent
+  Types: Explore, general-purpose, Plan
+- Use for parallel/async work
+
+### Notebook Editing
+- <notebook_edit path="notebook.ipynb" cell_id="0" new_source="code"/> — Edit Jupyter cell
+
+### User Interaction
+- <ask_user question="Which approach?" header="Choice" options='["A","B"]'/> — Ask user
+
+### Binary Analysis
+- <binsmasher path="binary" mode="strings"/> — Analyze binary files
+
+## PLUGINS
+
+Plugins extend your capabilities. Available plugins are listed in the system prompt.
+
+Invoke plugins with: <run_plugin name="plugin_name" args="arguments"/>
+
+Example plugins:
+- <run_plugin name="notes" args="new \"My Note\" \"Content #tag\""/> — Create knowledge note
+- <run_plugin name="git_ops" args="status"/> — Git operations
+- <run_plugin name="search_code" args="pattern"/> — Advanced code search
+
+Check the "Plugins" section in your system prompt for available plugins and their usage.
+
+## CRITICAL RULES
+
+**1. NEVER WRITE CODE AS TEXT**
+NEVER write code in ``` blocks or raw text. ALWAYS use write_file or edit_file.
+WRONG: int main() { return 0; }
+RIGHT: <write_file path="main.c">int main() { return 0; }</write_file>
+
+**2. READ BEFORE MODIFY**
+Use read_file and grep_search to understand code before changing it.
+<read_file path="src/auth.py"/>
+<grep_search pattern="function" dir="src"/>
+
+**3. ONE FILE AT A TIME**
+Start and COMPLETE one file before starting another.
+NEVER interrupt a write_file to start another.
+ALWAYS close </write_file> before opening another.
+
+**4. VERIFY ALWAYS**
+After writing code, run it to verify it works:
+- C: <exec_cmd>gcc file.c -o file && ./file</exec_cmd>
+- Python: <exec_cmd cmd="python file.py"/>
+- Node: <exec_cmd cmd="node file.js"/>
+- Tests: <exec_cmd cmd="pytest tests/"/>
+
+**5. NEVER STOP UNTIL COMPLETE**
+DO NOT ask for permission. DO NOT wait for confirmation. KEEP WORKING until done.
+Use <done/> ONLY when ALL tasks are complete and verified.
+
+**6. COMPLETE FILES**
+In write_file, write the COMPLETE file. NEVER use "# ... rest unchanged" or similar.
+
+**7. FIX ERRORS COMPLETELY**
+When something fails:
+1. Read the error message carefully
+2. Identify the root cause
+3. Fix the issue
+4. Verify the fix works
+5. Continue with remaining tasks
+
+**8. USE TASK MANAGEMENT**
+For complex tasks, create and track tasks:
+<task_create subject="Implement X" description="Details"/>
+<task_update taskId="1" status="in_progress"/>
+... work ...
+<task_update taskId="1" status="completed"/>
+
+## EXEC_CMD FORMATS
+
+Simple command:
+<exec_cmd cmd="python script.py"/>
+
+Block format (for complex commands):
+<exec_cmd>
+find . -name "*.py" -exec grep -l "pattern" {} \\;
+</exec_cmd>
+
+## COMPLETION SIGNAL
+
+When ALL work is done:
+1. Write a summary of what was done
+2. List modified/created files
+3. Show verification results
+4. End with: <done/>
+
+Example:
+## Summary
+- Created src/api.py with REST endpoints
+- Modified config.py to add new settings
+- All tests passed
+
+<done/>
+
+DO NOT use <done/> until everything works.
+"""

hanus/connectors/__init__.py

@@ -0,0 +1,19 @@
+# connectors/__init__.py
+"""Auto-registra todos los conectores disponibles al importar el paquete."""
+from .base import BaseConnector, ModelResponse, ToolCall
+from .registry import ConnectorRegistry
+
+def _try(mod):
+    try:
+        import importlib
+        importlib.import_module(f".{mod}", package=__name__)
+    except Exception:
+        pass
+
+_try("claude_connector")
+_try("openai_connector")
+_try("gemini_connector")
+_try("ollama_connector")
+_try("glm_connector")
+
+__all__ = ["BaseConnector", "ModelResponse", "ToolCall", "ConnectorRegistry"]

hanus/connectors/base.py

@@ -0,0 +1,114 @@
+# connectors/base.py
+"""
+Interfaz unificada para todos los conectores.
+
+IMPORTANTE — dos modos de operación:
+  • NATIVE_TOOLS = True  → el modelo soporta tool_calls nativos (Claude, OpenAI).
+                           El engine le pasa TOOL_DEFINITIONS y parsea ToolCall objects.
+  • NATIVE_TOOLS = False → el modelo solo soporta chat de texto (Gemini, Ollama).
+                           El engine le inyecta las herramientas como instrucciones XML
+                           en el system prompt y parsea la respuesta de texto buscando bloques XML.
+"""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any, Callable
+
+
+@dataclass
+class ToolCall:
+    """Solicitud de herramienta emitida por el modelo."""
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+    raw: Optional[Any] = None
+
+
+@dataclass
+class ModelResponse:
+    """Respuesta unificada de cualquier proveedor."""
+    text: str = ""
+    tool_calls: List[ToolCall] = field(default_factory=list)
+    stop_reason: str = "end_turn"   # end_turn | tool_use | max_tokens | error
+    input_tokens: int = 0
+    output_tokens: int = 0
+    model_id: str = ""
+    cost_usd: float = 0.0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens
+
+    def calc_cost(self, price_in_per_1m: float, price_out_per_1m: float):
+        self.cost_usd = (
+            self.input_tokens  * price_in_per_1m  / 1_000_000 +
+            self.output_tokens * price_out_per_1m / 1_000_000
+        )
+
+
+class BaseConnector(ABC):
+    """Contrato base para todos los conectores de proveedores de IA."""
+
+    # Sobrescribir en conectores sin soporte nativo de herramientas
+    NATIVE_TOOLS: bool = False
+
+    def __init__(self, config: Dict[str, Any]):
+        self.config    = config
+        self.model_id  = config.get("model_id", "")
+        self._session_cost:   float = 0.0
+        self._session_tokens: int   = 0
+
+    @abstractmethod
+    def validate(self) -> bool:
+        """Verifica que las credenciales y el servicio estén disponibles."""
+        ...
+
+    @abstractmethod
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        """
+        Envía historial y retorna respuesta.
+        Los conectores con NATIVE_TOOLS=True reciben tools por separado
+        vía chat_with_tools(). Este método siempre debe funcionar sin tools.
+        """
+        ...
+
+    def chat_with_tools(
+        self,
+        messages: List[Dict],
+        tools: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        """
+        Solo para conectores con NATIVE_TOOLS=True.
+        Los demás no deben sobrescribir esto — el engine usará XML fallback.
+        """
+        raise NotImplementedError("Este conector no soporta tool_calls nativos.")
+
+    @abstractmethod
+    def count_tokens(self, text: str) -> int:
+        """Estima número de tokens de un texto."""
+        ...
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def available_models(self) -> List[str]: ...
+
+    # ── Métricas de sesión ────────────────────────────────────────────────────
+    def record(self, response: ModelResponse):
+        self._session_cost   += response.cost_usd
+        self._session_tokens += response.total_tokens
+
+    @property
+    def session_cost(self) -> float:   return self._session_cost
+    @property
+    def session_tokens(self) -> int:   return self._session_tokens
+    def reset_session(self):
+        self._session_cost = 0.0; self._session_tokens = 0

hanus/connectors/claude_connector.py

@@ -0,0 +1,146 @@
+# connectors/claude_connector.py
+"""
+Conector Anthropic Claude. NATIVE_TOOLS = True.
+Soporta streaming real, tool_use nativo y prompt cache.
+"""
+from __future__ import annotations
+from typing import List, Dict, Optional, Any, Callable
+
+from .base import BaseConnector, ModelResponse, ToolCall
+from .registry import ConnectorRegistry
+
+PRICING = {
+    "claude-opus-4-5":       {"in": 15.0,  "out": 75.0},
+    "claude-sonnet-4-5":     {"in": 3.0,   "out": 15.0},
+    "claude-haiku-4-5":      {"in": 0.25,  "out": 1.25},
+    "claude-3-5-sonnet-20241022": {"in": 3.0, "out": 15.0},
+    "claude-3-haiku-20240307":    {"in": 0.25, "out": 1.25},
+    "claude-3-opus-20240229":     {"in": 15.0, "out": 75.0},
+}
+MODELS = list(PRICING.keys())
+
+
+@ConnectorRegistry.register("claude")
+class ClaudeConnector(BaseConnector):
+
+    NATIVE_TOOLS = True
+
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.api_key    = config.get("api_key", "")
+        self.model_id   = config.get("model_id", "claude-sonnet-4-5")
+        self.max_tokens = config.get("max_tokens", 8096)
+        self._client    = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import anthropic
+                self._client = anthropic.Anthropic(api_key=self.api_key)
+            except ImportError:
+                raise RuntimeError("Instala: pip install anthropic")
+        return self._client
+
+    def validate(self) -> bool:
+        try:
+            c = self._get_client()
+            c.messages.create(
+                model=self.model_id, max_tokens=10,
+                messages=[{"role": "user", "content": "hi"}]
+            )
+            return True
+        except Exception:
+            return False
+
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        """Chat sin tools (usado para mensajes simples)."""
+        return self._do_chat(messages, tools=None, stream_callback=stream_callback)
+
+    def chat_with_tools(
+        self,
+        messages: List[Dict],
+        tools: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        """Chat con tool_calls nativos."""
+        return self._do_chat(messages, tools=tools, stream_callback=stream_callback)
+
+    def _do_chat(
+        self,
+        messages: List[Dict],
+        tools: Optional[List[Dict]],
+        stream_callback: Optional[Callable[[str], None]],
+    ) -> ModelResponse:
+        client  = self._get_client()
+        system  = ""
+        history = []
+        for m in messages:
+            if m["role"] == "system":
+                system = m["content"]
+            else:
+                history.append({"role": m["role"], "content": str(m["content"])})
+
+        kwargs: Dict[str, Any] = {
+            "model": self.model_id,
+            "max_tokens": self.max_tokens,
+            "messages": history,
+        }
+        if system:
+            kwargs["system"] = system
+        if tools:
+            kwargs["tools"] = tools
+
+        resp = ModelResponse(model_id=self.model_id)
+        try:
+            if stream_callback:
+                with client.messages.stream(**kwargs) as stream:
+                    for token in stream.text_stream:
+                        resp.text += token
+                        stream_callback(token)
+                    final = stream.get_final_message()
+                    resp.stop_reason   = final.stop_reason or "end_turn"
+                    resp.input_tokens  = final.usage.input_tokens
+                    resp.output_tokens = final.usage.output_tokens
+                    self._extract_tools(final, resp)
+            else:
+                msg = client.messages.create(**kwargs)
+                resp.stop_reason   = msg.stop_reason or "end_turn"
+                resp.input_tokens  = msg.usage.input_tokens
+                resp.output_tokens = msg.usage.output_tokens
+                for block in msg.content:
+                    if hasattr(block, "text"):
+                        resp.text += block.text
+                self._extract_tools(msg, resp)
+        except Exception as e:
+            resp.text        = f"[Error Claude] {type(e).__name__}: {e}"
+            resp.stop_reason = "error"
+
+        p = PRICING.get(self.model_id, {"in": 3.0, "out": 15.0})
+        resp.calc_cost(p["in"], p["out"])
+        self.record(resp)
+        return resp
+
+    def _extract_tools(self, msg: Any, resp: ModelResponse):
+        import uuid
+        for block in msg.content:
+            if block.type == "tool_use":
+                resp.tool_calls.append(ToolCall(
+                    id=block.id,
+                    name=block.name,
+                    arguments=block.input if isinstance(block.input, dict) else {},
+                    raw=block,
+                ))
+        if resp.tool_calls:
+            resp.stop_reason = "tool_use"
+
+    def count_tokens(self, text: str) -> int:
+        return len(text) // 4
+
+    @property
+    def provider_name(self) -> str:   return "Anthropic Claude"
+    @property
+    def available_models(self) -> List[str]: return MODELS