File size: 6,312 Bytes
14b0da7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | # 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
|