integration: add chat/core.py

chat/core.py

@@ -0,0 +1,160 @@
+# chat/core.py
+"""
+DeepSeek V4 chat module — sovereign-tuned conversational core.
+
+DeepSeekV4Client speaks the OpenAI-compatible /chat/completions schema
+against a configurable base URL. When no DEEPSEEK_API_KEY is set it runs
+in LOCAL mode: deterministic sovereign-context responses (no network).
+
+Model identity: sovereign/deepseek-v4-sovereign (304B MoE, sovereign-
+tuned, MIT lineage) — see models/deepseek-v4-sovereign/.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+import requests
+
+DEFAULT_BASE_URL = "https://api.deepseek.com/v1"
+DEFAULT_MODEL = "sovereign/deepseek-v4-sovereign"
+
+# System prompt with sovereign context (modules available to the agent)
+SOVEREIGN_SYSTEM_PROMPT = (
+    "You are the DeepSeek-V4-Sovereign conversational core of the Sovereign stack. "
+    "You have access to these modules: kyrexis (quantum-inspired intelligence, 53-qubit "
+    "simulation, quantum skills), pec5d (8-core hierarchy, pattern bridge, invisible "
+    "pressure theory, coral ecosystem), coldcase (PEC5D cold-case grid — hypothesis "
+    "lattice only, never legal conclusions). Be honest: all 'quantum' behavior is "
+    "simulation; annotate confidence; never overclaim."
+)
+
+
+@dataclass
+class ChatMessage:
+    """A chat message."""
+
+    role: str  # system | user | assistant
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ChatSession:
+    """A conversational session with bounded history."""
+
+    session_id: str = field(default_factory=lambda: f"ses_{uuid.uuid4().hex[:12]}")
+    model: str = DEFAULT_MODEL
+    messages: List[ChatMessage] = field(default_factory=list)
+    max_history: int = 50
+    created_at: float = field(default_factory=time.time)
+
+    def add(self, role: str, content: str) -> ChatMessage:
+        msg = ChatMessage(role=role, content=content)
+        self.messages.append(msg)
+        if len(self.messages) > self.max_history:
+            # keep system prompt + most recent window
+            head = [m for m in self.messages if m.role == "system"][:1]
+            tail = self.messages[-self.max_history :]
+            self.messages = head + [m for m in tail if m.role != "system"]
+        return msg
+
+    def to_api(self) -> List[Dict[str, str]]:
+        """Messages in OpenAI chat-completions format."""
+        return [{"role": m.role, "content": m.content} for m in self.messages]
+
+
+class DeepSeekV4Client:
+    """
+    OpenAI-compatible DeepSeek V4 client with local-echo fallback.
+
+    Env config:
+      DEEPSEEK_API_BASE — API base URL (default https://api.deepseek.com/v1)
+      DEEPSEEK_API_KEY  — API key; unset → local mode
+      DEEPSEEK_MODEL    — model id (default sovereign/deepseek-v4-sovereign)
+    """
+
+    def __init__(self, base_url: Optional[str] = None, api_key: Optional[str] = None,
+                 model: Optional[str] = None, timeout: int = 60):
+        self.base_url = (base_url or os.environ.get("DEEPSEEK_API_BASE", DEFAULT_BASE_URL)).rstrip("/")
+        self.api_key = api_key or os.environ.get("DEEPSEEK_API_KEY", "")
+        self.model = model or os.environ.get("DEEPSEEK_MODEL", DEFAULT_MODEL)
+        self.timeout = timeout
+
+    @property
+    def local_mode(self) -> bool:
+        """True when no API key is configured (deterministic local echo)."""
+        return not self.api_key
+
+    def complete(self, session: ChatSession, temperature: float = 0.7,
+                 max_tokens: int = 1024) -> Dict[str, Any]:
+        """Generate an assistant reply for the session."""
+        if self.local_mode:
+            return self._local_complete(session)
+        return self._api_complete(session, temperature, max_tokens)
+
+    def _api_complete(self, session: ChatSession, temperature: float,
+                      max_tokens: int) -> Dict[str, Any]:
+        """Call the OpenAI-compatible chat completions endpoint."""
+        url = f"{self.base_url}/chat/completions"
+        payload = {
+            "model": session.model or self.model,
+            "messages": session.to_api(),
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        response = requests.post(
+            url,
+            headers={"Authorization": f"Bearer {self.api_key}",
+                     "Content-Type": "application/json"},
+            json=payload,
+            timeout=self.timeout,
+        )
+        if response.status_code != 200:
+            raise RuntimeError(f"DeepSeek API error {response.status_code}: {response.text[:300]}")
+        data = response.json()
+        content = data["choices"][0]["message"]["content"]
+        return {
+            "content": content,
+            "model": data.get("model", self.model),
+            "usage": data.get("usage", {}),
+            "mode": "api",
+        }
+
+    def _local_complete(self, session: ChatSession) -> Dict[str, Any]:
+        """Deterministic local fallback �� no network, no key required."""
+        user_msgs = [m for m in session.messages if m.role == "user"]
+        last = user_msgs[-1].content if user_msgs else ""
+        content = (
+            f"🌀 Sovereign local echo (no DEEPSEEK_API_KEY configured — API mode "
+            f"would call {self.base_url}/chat/completions with model {self.model}).\n"
+            f"Received: {last[:200] or '(empty)'}"
+        )
+        return {"content": content, "model": self.model, "usage": {}, "mode": "local"}
+
+    def list_models(self) -> List[Dict[str, str]]:
+        """Available models (local registry summary + API if key set)."""
+        models = [
+            {"id": "sovereign/deepseek-v4-sovereign", "type": "llm", "params": "304B MoE",
+             "license": "MIT", "status": "sovereign-tuned"},
+            {"id": "deepseek-v4-flash-0731", "type": "llm", "params": "304B MoE",
+             "license": "MIT", "status": "upstream-base"},
+            {"id": "gemma-3-12b-it-jailbreak", "type": "llm", "params": "12B",
+             "format": "GGUF", "status": "integrated"},
+        ]
+        return models
+
+
+# Singleton (lazy — reads env at first use)
+_client: Optional[DeepSeekV4Client] = None
+
+
+def get_client() -> DeepSeekV4Client:
+    global _client
+    if _client is None:
+        _client = DeepSeekV4Client()
+    return _client