hanuscode 1.0.0__py3-none-any.whl

hanus/connectors/gemini_connector.py

@@ -0,0 +1,141 @@
+# connectors/gemini_connector.py
+"""
+Conector Google Gemini. NATIVE_TOOLS = False.
+Autocontenido — usa la API REST de Gemini directamente via urllib.
+No depende de ia_integrations ni del SDK de Google.
+"""
+from __future__ import annotations
+import json
+import urllib.request
+import urllib.parse
+from typing import List, Dict, Optional, Any, Callable
+
+from .base import BaseConnector, ModelResponse
+from .registry import ConnectorRegistry
+
+PRICING = {
+    "gemini-1.5-pro":          {"in": 3.5,   "out": 10.5},
+    "gemini-1.5-flash":        {"in": 0.075, "out": 0.30},
+    "gemini-1.5-flash-8b":     {"in": 0.0375,"out": 0.15},
+    "gemini-2.0-flash":        {"in": 0.10,  "out": 0.40},
+    "gemini-2.0-flash-lite":   {"in": 0.075, "out": 0.30},
+    "gemini-pro":              {"in": 0.5,   "out": 1.5},
+}
+MODELS = list(PRICING.keys())
+API_BASE = "https://generativelanguage.googleapis.com/v1beta/models"
+
+
+@ConnectorRegistry.register("gemini")
+class GeminiConnector(BaseConnector):
+
+    NATIVE_TOOLS = False   # Usa XML fallback en el engine
+
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.api_key    = config.get("api_key", "")
+        self.model_id   = config.get("model_id", "gemini-1.5-flash")
+        self.max_tokens = config.get("max_tokens", 4096)
+        self.temperature = float(config.get("temperature", 0.3))
+
+    def validate(self) -> bool:
+        try:
+            url = f"{API_BASE}/{self.model_id}?key={self.api_key}"
+            with urllib.request.urlopen(url, timeout=5) as r:
+                return r.status == 200
+        except Exception:
+            return False
+
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        resp = ModelResponse(model_id=self.model_id)
+
+        # Convertir historial al formato de Gemini
+        system_parts = []
+        gemini_contents = []
+
+        for m in messages:
+            role    = m["role"]
+            content = str(m["content"])
+            if role == "system":
+                system_parts.append({"text": content})
+            elif role == "user":
+                gemini_contents.append({"role": "user",  "parts": [{"text": content}]})
+            elif role == "assistant":
+                gemini_contents.append({"role": "model", "parts": [{"text": content}]})
+
+        # Asegurar que empiece con user
+        if not gemini_contents:
+            resp.text = "[Error Gemini] Sin mensajes de usuario"
+            resp.stop_reason = "error"
+            return resp
+
+        # Si el último mensaje es del model, añadir dummy user para continuar
+        if gemini_contents[-1]["role"] == "model":
+            gemini_contents.append({"role": "user", "parts": [{"text": "Continúa."}]})
+
+        body: Dict[str, Any] = {
+            "contents": gemini_contents,
+            "generationConfig": {
+                "temperature": self.temperature,
+                "maxOutputTokens": self.max_tokens,
+            },
+        }
+        if system_parts:
+            body["systemInstruction"] = {"parts": system_parts}
+
+        url = f"{API_BASE}/{self.model_id}:generateContent?key={self.api_key}"
+        payload = json.dumps(body).encode("utf-8")
+
+        try:
+            req = urllib.request.Request(
+                url,
+                data=payload,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(req, timeout=60) as r:
+                data = json.loads(r.read())
+
+            # Extraer texto
+            candidates = data.get("candidates", [])
+            if not candidates:
+                resp.text        = f"[Gemini] Sin candidatos en respuesta: {data}"
+                resp.stop_reason = "error"
+                return resp
+
+            parts = candidates[0].get("content", {}).get("parts", [])
+            text  = "".join(p.get("text", "") for p in parts)
+            resp.text = text
+
+            if stream_callback and text:
+                stream_callback(text)
+
+            # Tokens
+            usage = data.get("usageMetadata", {})
+            resp.input_tokens  = usage.get("promptTokenCount", len(str(body)) // 4)
+            resp.output_tokens = usage.get("candidatesTokenCount", len(text) // 4)
+            resp.stop_reason   = "end_turn"
+
+        except urllib.error.HTTPError as e:
+            body_err = e.read().decode("utf-8", errors="replace")
+            resp.text        = f"[Error Gemini HTTP {e.code}] {body_err[:300]}"
+            resp.stop_reason = "error"
+        except Exception as e:
+            resp.text        = f"[Error Gemini] {type(e).__name__}: {e}"
+            resp.stop_reason = "error"
+
+        p = PRICING.get(self.model_id, {"in": 0.5, "out": 1.5})
+        resp.calc_cost(p["in"], p["out"])
+        self.record(resp)
+        return resp
+
+    def count_tokens(self, text: str) -> int:
+        return len(text) // 4
+
+    @property
+    def provider_name(self) -> str:        return "Google Gemini"
+    @property
+    def available_models(self) -> List[str]: return MODELS

hanus/connectors/glm_connector.py

@@ -0,0 +1,160 @@
+# connectors/glm_connector.py
+"""
+Conector GLM Cloud (ZhipuAI). NATIVE_TOOLS = False.
+Soporta modelos GLM-4, GLM-4-Flash, GLM-5, etc.
+"""
+from __future__ import annotations
+import json
+import time
+import urllib.request
+import urllib.error
+from typing import List, Dict, Optional, Any, Callable
+
+from .base import BaseConnector, ModelResponse
+from .registry import ConnectorRegistry
+
+# Modelos disponibles
+GLM_MODELS = {
+    "glm-4":           "glm-4",
+    "glm-4-flash":     "glm-4-flash",
+    "glm-4-plus":      "glm-4-plus",
+    "glm-5":           "glm-5",
+    "glm-5:cloud":     "glm-5",  # Alias
+    "glm-5-cloud":     "glm-5",
+}
+
+API_URL = "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+
+
+@ConnectorRegistry.register("glm")
+class GLMConnector(BaseConnector):
+
+    NATIVE_TOOLS = False   # Usa XML fallback en el engine
+
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.api_key = config.get("glm_api_key", "") or config.get("api_key", "")
+        self.model_id = GLM_MODELS.get(config.get("model_id", "glm-4"), "glm-4")
+        self.max_tokens = config.get("max_tokens", 4096)
+        self.temperature = float(config.get("temperature", 0.7))
+
+    def validate(self) -> bool:
+        if not self.api_key:
+            return False
+        try:
+            resp = self.chat([{"role": "user", "content": "hi"}])
+            return resp.stop_reason != "error"
+        except Exception:
+            return False
+
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        resp = ModelResponse(model_id=f"glm/{self.model_id}")
+
+        if not self.api_key:
+            resp.text = "[Error GLM] No hay API key configurada.\nConfigura glm_api_key en ~/.hanus/config.yaml"
+            resp.stop_reason = "error"
+            return resp
+
+        # Construir mensajes para la API
+        api_messages = []
+        for m in messages:
+            role = m["role"]
+            if role not in ("system", "user", "assistant"):
+                continue
+            api_messages.append({"role": role, "content": str(m["content"])})
+
+        payload = json.dumps({
+            "model": self.model_id,
+            "messages": api_messages,
+            "stream": False,
+            "max_tokens": self.max_tokens,
+            "temperature": self.temperature,
+        }).encode("utf-8")
+
+        MAX_RETRIES = 3
+        for attempt in range(MAX_RETRIES):
+            try:
+                req = urllib.request.Request(
+                    API_URL,
+                    data=payload,
+                    headers={
+                        "Content-Type": "application/json",
+                        "Authorization": f"Bearer {self.api_key}",
+                    },
+                    method="POST",
+                )
+                with urllib.request.urlopen(req, timeout=120) as r:
+                    data = json.loads(r.read().decode("utf-8"))
+
+                # Extraer respuesta
+                choices = data.get("choices", [])
+                if choices:
+                    content = choices[0].get("message", {}).get("content", "")
+                else:
+                    content = data.get("content", "") or json.dumps(data, ensure_ascii=False)
+
+                if not content.strip() and attempt < MAX_RETRIES - 1:
+                    time.sleep(2)
+                    continue
+
+                resp.text = content
+                resp.stop_reason = "end_turn"
+
+                # Tokens
+                usage = data.get("usage", {})
+                resp.input_tokens = usage.get("prompt_tokens", len(str(api_messages)) // 4)
+                resp.output_tokens = usage.get("completion_tokens", len(content) // 4)
+                resp.cost_usd = 0.0
+
+                if stream_callback and content:
+                    stream_callback(content)
+
+                break
+
+            except urllib.error.HTTPError as e:
+                error_body = e.read().decode("utf-8", errors="replace") if e.fp else ""
+                if e.code == 401:
+                    resp.text = "[Error GLM] API key inválida. Verifica tu glm_api_key"
+                elif e.code == 429:
+                    resp.text = f"[Error GLM] Rate limit alcanzado. Espera un momento."
+                else:
+                    resp.text = f"[Error GLM HTTP {e.code}] {error_body[:300]}"
+                resp.stop_reason = "error"
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                break
+
+            except urllib.error.URLError as e:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                resp.text = f"[Error GLM] No se pudo conectar a {API_URL}\nError: {e}"
+                resp.stop_reason = "error"
+                break
+
+            except Exception as e:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                resp.text = f"[Error GLM] {type(e).__name__}: {e}"
+                resp.stop_reason = "error"
+                break
+
+        self.record(resp)
+        return resp
+
+    def count_tokens(self, text: str) -> int:
+        return len(text) // 4
+
+    @property
+    def provider_name(self) -> str:
+        return f"GLM Cloud ({self.model_id})"
+
+    @property
+    def available_models(self) -> List[str]:
+        return list(GLM_MODELS.keys())

hanus/connectors/ollama_connector.py

@@ -0,0 +1,174 @@
+# connectors/ollama_connector.py
+"""
+Conector Ollama para modelos locales. NATIVE_TOOLS = False.
+Completamente autocontenido — sin dependencias de ia_integrations.
+Usa la API REST de Ollama directamente via urllib.
+"""
+from __future__ import annotations
+import json
+import time
+import urllib.request
+import urllib.error
+from typing import List, Dict, Optional, Any, Callable
+
+from .base import BaseConnector, ModelResponse
+from .registry import ConnectorRegistry
+
+COMMON_MODELS = [
+    "llama3", "llama3:8b", "llama3:70b",
+    "llama3.1", "llama3.2",
+    "mistral", "mistral:7b", "mixtral",
+    "codellama", "codellama:7b", "codellama:34b",
+    "phi3", "phi3:mini", "phi3:medium",
+    "qwen2.5:3b-instruct", "qwen2.5:7b", "qwen2.5-coder",
+    "deepseek-coder", "deepseek-coder-v2",
+    "gemma2", "gemma2:9b",
+    "neural-chat", "dolphin-mistral",
+]
+
+
+@ConnectorRegistry.register("ollama")
+class OllamaConnector(BaseConnector):
+
+    NATIVE_TOOLS = False   # Usa XML fallback en el engine
+
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.base_url   = config.get("ollama_url", "http://localhost:11434").rstrip("/")
+        self.model_id   = config.get("model_id", "llama3")
+        self.max_tokens = config.get("max_tokens", 4096)
+        self.temperature = float(config.get("temperature", 0.3))
+
+    def validate(self) -> bool:
+        try:
+            req = urllib.request.Request(f"{self.base_url}/api/tags")
+            with urllib.request.urlopen(req, timeout=4) as r:
+                return r.status == 200
+        except Exception:
+            return False
+
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        resp = ModelResponse(model_id=self.model_id)
+
+        # Extraer system y construir lista de mensajes para /api/chat
+        api_messages = []
+        for m in messages:
+            role = m["role"]
+            if role not in ("system", "user", "assistant"):
+                continue
+            api_messages.append({"role": role, "content": str(m["content"])})
+
+        payload = json.dumps({
+            "model": self.model_id,
+            "messages": api_messages,
+            "stream": True,
+            "options": {
+                "temperature": self.temperature,
+                "num_predict": self.max_tokens,
+            },
+        }).encode("utf-8")
+
+        MAX_RETRIES = 3
+        for attempt in range(MAX_RETRIES):
+            try:
+                req = urllib.request.Request(
+                    f"{self.base_url}/api/chat",
+                    data=payload,
+                    headers={"Content-Type": "application/json"},
+                    method="POST",
+                )
+                with urllib.request.urlopen(req, timeout=300) as r:
+                    full_text = ""
+                    for raw_line in r:
+                        line = raw_line.decode("utf-8").strip()
+                        if not line:
+                            continue
+                        try:
+                            chunk = json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+
+                        # Check for error in response
+                        if "error" in chunk:
+                            resp.text = f"[Error Ollama] {chunk['error']}"
+                            resp.stop_reason = "error"
+                            return resp
+
+                        token = chunk.get("message", {}).get("content", "")
+                        if token:
+                            full_text += token
+                            if stream_callback:
+                                stream_callback(token)
+
+                        if chunk.get("done"):
+                            resp.input_tokens  = chunk.get("prompt_eval_count", len(full_text) // 8)
+                            resp.output_tokens = chunk.get("eval_count", len(full_text) // 4)
+                            break
+
+                # Respuesta vacía → reintentar
+                if not full_text.strip() and attempt < MAX_RETRIES - 1:
+                    time.sleep(2)
+                    continue
+
+                resp.text        = full_text
+                resp.stop_reason = "end_turn"
+                break
+
+            except urllib.error.HTTPError as e:
+                error_body = e.read().decode("utf-8", errors="replace") if e.fp else ""
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                resp.text = (
+                    f"[Error Ollama HTTP {e.code}] {error_body[:500]}\n"
+                    f"URL: {self.base_url}/api/chat\n"
+                    f"Modelo: {self.model_id}"
+                )
+                resp.stop_reason = "error"
+                break
+            except urllib.error.URLError as e:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                resp.text = (
+                    f"[Error Ollama] No se pudo conectar a {self.base_url}.\n"
+                    f"Inicia Ollama con: ollama serve\n"
+                    f"Error: {e.reason}"
+                )
+                resp.stop_reason = "error"
+                break
+            except Exception as e:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(3)
+                    continue
+                resp.text = f"[Error Ollama] {type(e).__name__}: {e}"
+                resp.stop_reason = "error"
+                break
+
+        resp.cost_usd = 0.0   # Sin costo monetario
+        self.record(resp)
+        return resp
+
+    def list_local_models(self) -> List[str]:
+        """Retorna modelos instalados localmente."""
+        try:
+            req = urllib.request.Request(f"{self.base_url}/api/tags")
+            with urllib.request.urlopen(req, timeout=4) as r:
+                data = json.loads(r.read())
+                return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return []
+
+    def count_tokens(self, text: str) -> int:
+        return len(text) // 4
+
+    @property
+    def provider_name(self) -> str: return "Ollama (Local)"
+    @property
+    def available_models(self) -> List[str]:
+        local = self.list_local_models()
+        return local if local else COMMON_MODELS

hanus/connectors/openai_connector.py

@@ -0,0 +1,122 @@
+# connectors/openai_connector.py
+"""Conector OpenAI. NATIVE_TOOLS = True. Soporta function calling y streaming."""
+from __future__ import annotations
+import json
+from typing import List, Dict, Optional, Any, Callable
+
+from .base import BaseConnector, ModelResponse, ToolCall
+from .registry import ConnectorRegistry
+
+PRICING = {
+    "gpt-4o":        {"in": 5.0,  "out": 15.0},
+    "gpt-4o-mini":   {"in": 0.15, "out": 0.60},
+    "gpt-4-turbo":   {"in": 10.0, "out": 30.0},
+    "gpt-3.5-turbo": {"in": 0.5,  "out": 1.5},
+    "o1":            {"in": 15.0, "out": 60.0},
+    "o1-mini":       {"in": 3.0,  "out": 12.0},
+    "o3-mini":       {"in": 1.1,  "out": 4.4},
+}
+MODELS = list(PRICING.keys())
+
+
+@ConnectorRegistry.register("openai")
+class OpenAIConnector(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", "gpt-4o")
+        self.max_tokens = config.get("max_tokens", 4096)
+        self._client    = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from openai import OpenAI
+                self._client = OpenAI(api_key=self.api_key)
+            except ImportError:
+                raise RuntimeError("Instala: pip install openai")
+        return self._client
+
+    def validate(self) -> bool:
+        try:
+            self._get_client().models.list()
+            return True
+        except Exception:
+            return False
+
+    def chat(
+        self,
+        messages: List[Dict],
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> ModelResponse:
+        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:
+        return self._do_chat(messages, tools=tools, stream_callback=stream_callback)
+
+    def _do_chat(self, messages, tools, stream_callback) -> ModelResponse:
+        client = self._get_client()
+        resp   = ModelResponse(model_id=self.model_id)
+
+        oai_tools = [{"type": "function", "function": t} for t in tools] if tools else None
+        kwargs: Dict[str, Any] = {
+            "model": self.model_id,
+            "messages": messages,
+            "max_tokens": self.max_tokens,
+        }
+        if oai_tools:
+            kwargs["tools"] = oai_tools
+
+        try:
+            if stream_callback:
+                stream = self._get_client().chat.completions.create(**kwargs, stream=True)
+                for chunk in stream:
+                    delta = chunk.choices[0].delta if chunk.choices else None
+                    if delta and delta.content:
+                        resp.text += delta.content
+                        stream_callback(delta.content)
+                resp.stop_reason = "end_turn"
+            else:
+                msg    = client.chat.completions.create(**kwargs)
+                choice = msg.choices[0]
+                resp.text          = choice.message.content or ""
+                resp.input_tokens  = msg.usage.prompt_tokens
+                resp.output_tokens = msg.usage.completion_tokens
+                resp.stop_reason   = "end_turn"
+                if choice.finish_reason == "tool_calls" and choice.message.tool_calls:
+                    resp.stop_reason = "tool_use"
+                    for tc in choice.message.tool_calls:
+                        try:   args = json.loads(tc.function.arguments)
+                        except: args = {}
+                        resp.tool_calls.append(ToolCall(
+                            id=tc.id, name=tc.function.name,
+                            arguments=args, raw=tc,
+                        ))
+        except Exception as e:
+            resp.text        = f"[Error OpenAI] {type(e).__name__}: {e}"
+            resp.stop_reason = "error"
+
+        p = PRICING.get(self.model_id, {"in": 5.0, "out": 15.0})
+        resp.calc_cost(p["in"], p["out"])
+        self.record(resp)
+        return resp
+
+    def count_tokens(self, text: str) -> int:
+        try:
+            import tiktoken
+            return len(tiktoken.encoding_for_model(self.model_id).encode(text))
+        except Exception:
+            return len(text) // 4
+
+    @property
+    def provider_name(self) -> str:        return "OpenAI"
+    @property
+    def available_models(self) -> List[str]: return MODELS

hanus/connectors/registry.py

@@ -0,0 +1,26 @@
+# connectors/registry.py
+from __future__ import annotations
+from typing import Dict, Type, Any
+from .base import BaseConnector
+
+
+class ConnectorRegistry:
+    _r: Dict[str, Type[BaseConnector]] = {}
+
+    @classmethod
+    def register(cls, provider: str):
+        def decorator(klass: Type[BaseConnector]):
+            cls._r[provider.lower()] = klass
+            return klass
+        return decorator
+
+    @classmethod
+    def get(cls, provider: str, config: Dict[str, Any]) -> BaseConnector:
+        key = provider.lower()
+        if key not in cls._r:
+            raise ValueError(f"Proveedor '{provider}' no disponible. Disponibles: {cls.available()}")
+        return cls._r[key](config)
+
+    @classmethod
+    def available(cls) -> list:
+        return sorted(cls._r.keys())

hanus/context/__init__.py

@@ -0,0 +1,7 @@
+# hanus/context/__init__.py
+"""
+Sistema de gestión de contexto para conversaciones largas.
+"""
+from hanus.context.manager import ContextManager
+
+__all__ = ["ContextManager"]