Isaac Quarenta
fix(jev): continuidade de topico — historico no preclassify + continuity boost System 2 + injecao de encadeamento no prompt
eb6ddb6 Download modules/jev_client.py from akra35567/Akiragpu: direct link, hf CLI and curl.
- Browser
- Download file 33.4 kB
-
https://huggingface.co/spaces/akra35567/Akiragpu/resolve/main/modules/jev_client.py
- Command line
-
hf download hf://spaces/akra35567/Akiragpu/modules/jev_client.py
-
curl -L -o jev_client.py https://huggingface.co/spaces/akra35567/Akiragpu/resolve/main/modules/jev_client.py
33.4 kB
| import time | |
| import threading | |
| import requests | |
| import os | |
| from dataclasses import dataclass, field | |
| from typing import Optional, Dict, Any, List | |
| from loguru import logger | |
| try: | |
| from . import config | |
| except ImportError: | |
| try: | |
| import config | |
| except ImportError: | |
| config = None | |
| # Re-export para compat: api.py faz `from .jev_client import get_jev_client, JEV_ENABLED` | |
| _SYSTEMONE_PATH = "/decisions" | |
| def _uniq(keys: list) -> list: | |
| out = [] | |
| for k in keys: | |
| k = (k or "").strip() | |
| if k and len(k) > 10 and k not in out: | |
| out.append(k) | |
| return out | |
| def _collect_api_keys(api_key: Optional[str] = None) -> list: | |
| """Chaves JEV/TypeSafe — JEV_API_KEY, JEV_API_KEY_2, TYPESAFE_API_KEY.""" | |
| keys: list = [] | |
| if api_key and str(api_key).strip(): | |
| keys.append(str(api_key).strip()) | |
| candidates = [ | |
| (getattr(config, "JEV_API_KEY", "") if config else ""), | |
| (getattr(config, "JEV_API_KEY_2", "") if config else ""), | |
| os.getenv("JEV_API_KEY", ""), | |
| os.getenv("JEV_API_KEY_2", ""), | |
| os.getenv("TYPESAFE_API_KEY", ""), | |
| ] | |
| return _uniq(keys + candidates) | |
| def _collect_named_keys(names: list) -> list: | |
| keys: list = [] | |
| for n in names: | |
| if config is not None: | |
| keys.append(getattr(config, n, "") or "") | |
| keys.append(os.getenv(n, "")) | |
| keys.append(os.getenv(n.lower(), "")) | |
| return _uniq(keys) | |
| _JEV_KEYS = _collect_api_keys() | |
| _TOKENRA_KEYS = _collect_named_keys(["TOKENRA_API_KEY"]) | |
| _OPENROUTER_KEYS = _collect_named_keys([ | |
| "OPENROUTER_API_KEY", | |
| "GITAKIRA_OPENROUTER_KEY", | |
| "GITAKIRA_OPENROUTER_API", | |
| "SANDEOBRAS_OPENROUTER_API", | |
| "SOFTEDGE_OPENROUTER_API", | |
| "JOSELENA_OPENROUTER_API", | |
| "FUGAKUSAYO_OPENROUTER_API", | |
| ]) | |
| _JEV_KEY = _JEV_KEYS[0] if _JEV_KEYS else "" | |
| JEV_ENABLED: bool = bool(_JEV_KEYS or _TOKENRA_KEYS or _OPENROUTER_KEYS) | |
| SYSTEMONE_PATH = _SYSTEMONE_PATH | |
| class JEVResult: | |
| """Resultado tipado de uma decisão JEV (compat com .success/.data em api.py).""" | |
| success: bool | |
| data: Dict[str, Any] = field(default_factory=dict) | |
| error: Optional[str] = None | |
| elapsed_ms: float = 0.0 | |
| class JevClient: | |
| """Cliente da API TypeSafe System One (JEV). | |
| POST https://api.typesafe.ai/v1/systemone | |
| Body: {state, model, questions: {id: {type, instructions, criteria}}} | |
| Resp: {model, answers: {id: {...}}, usage} | |
| - noul -> {type: "noul", noul: 0..1} | |
| - choice -> {type: "choice", choice, probabilities, confidence} | |
| - score -> {type: "score", score, legend, probabilities, confidence} | |
| """ | |
| def __init__( | |
| self, | |
| api_key: Optional[str] = None, | |
| base_url: Optional[str] = None, | |
| model: Optional[str] = None, | |
| timeout: Optional[float] = None, | |
| ): | |
| self.api_keys = _collect_api_keys(api_key) | |
| self.api_key = self.api_keys[0] if self.api_keys else "" | |
| self._key_idx = 0 | |
| self.base_url = ( | |
| base_url | |
| or (getattr(config, "JEV_API_BASE_URL", "") if config else "") | |
| or "https://api.defapi.org/api/v1" | |
| ).rstrip("/") | |
| self.model = ( | |
| model | |
| or (getattr(config, "JEV_MODEL", "") if config else "") | |
| or "jev-latest" | |
| ) | |
| if timeout is None: | |
| timeout_ms = int(getattr(config, "JEV_TIMEOUT_MS", 5000) if config else 5000) | |
| timeout = max(1.0, timeout_ms / 1000.0) | |
| self.timeout = float(timeout) | |
| self.max_retries = int(getattr(config, "JEV_MAX_RETRIES", 2) if config else 2) | |
| self._lock = threading.Lock() | |
| self._stats = {"calls": 0, "ok": 0, "fail": 0, "avg_ms": 0.0} | |
| self._backends = self._build_backends(base_url, model, api_key) | |
| self._active_backend = 0 | |
| self.enabled = bool(self._backends) | |
| if self.enabled: | |
| bl = ", ".join(f"{b['base']}{b['path']}" for b in self._backends) | |
| logger.success( | |
| f"JEV System-One ativo: model={self.model} backends=[{bl}] " | |
| f"jev_keys={len(self.api_keys)} tokenra={len(_TOKENRA_KEYS)} openrouter={len(_OPENROUTER_KEYS)}" | |
| ) | |
| else: | |
| logger.warning("JEV desativado — nenhuma chave (JEV/TOKENRA/OPENROUTER)") | |
| def _build_backends(self, base_url, model, api_key) -> list: | |
| """Cadeia de backends JEV — tenta em ordem até um responder.""" | |
| jev_keys = self.api_keys | |
| primary_base = ( | |
| base_url | |
| or (getattr(config, "JEV_API_BASE_URL", "") if config else "") | |
| or "https://api.defapi.org/api/v1" | |
| ).rstrip("/") | |
| primary_model = ( | |
| model | |
| or (getattr(config, "JEV_MODEL", "") if config else "") | |
| or "jev-latest" | |
| ) | |
| primary_path = "/systemone" if "typesafe.ai" in primary_base else _SYSTEMONE_PATH | |
| # Defapi: jev-latest → 400; typesafe/jev-1.13 é o nome que funciona | |
| if "defapi" in primary_base and primary_model in ("jev-latest", "", "jev"): | |
| primary_model = "typesafe/jev-1.13" | |
| cands = [] | |
| _MODEL_ALTS = ["typesafe/jev-1.13", "jev-1.13.0", "jev-1.13", "jev-latest", "jev"] | |
| if jev_keys: | |
| cands.append({ | |
| "base": primary_base, "path": primary_path, | |
| "model": primary_model, | |
| "alt_models": [m for m in _MODEL_ALTS if m != primary_model], | |
| "keys": list(jev_keys), | |
| }) | |
| cands.append({ | |
| "base": "https://api.typesafe.ai/v1", "path": "/systemone", | |
| "model": "jev-latest", | |
| "alt_models": ["jev-1.13.0"], | |
| "keys": list(jev_keys), | |
| }) | |
| tr_keys = _uniq((_TOKENRA_KEYS or []) + jev_keys) | |
| if tr_keys: | |
| cands.append({ | |
| "base": "https://tokenra.io/v1", "path": "/decisions", | |
| "model": "jev-latest", | |
| "alt_models": ["jev-1.13.0"], | |
| "keys": tr_keys, | |
| }) | |
| or_keys = _uniq(_OPENROUTER_KEYS) | |
| if or_keys: | |
| cands.append({ | |
| "base": "https://openrouter.ai/api", "path": "/alpha/decisions", | |
| "model": "typesafe/jev-1.13", | |
| "alt_models": ["~typesafe/jev-latest"], | |
| "keys": or_keys, | |
| }) | |
| backends, seen = [], set() | |
| for c in cands: | |
| sig = (c["base"], c["path"], c["model"]) | |
| if sig not in seen and c["keys"]: | |
| seen.add(sig) | |
| backends.append(c) | |
| return backends | |
| def is_available(self) -> bool: | |
| return self.enabled | |
| def _headers(self, key: Optional[str] = None) -> Dict[str, str]: | |
| return { | |
| "Authorization": f"Bearer {key or self.api_key}", | |
| "Content-Type": "application/json", | |
| "Accept": "application/json", | |
| } | |
| def _backend_order(self) -> list: | |
| n = len(self._backends) | |
| if n == 0: | |
| return [] | |
| a = self._active_backend % n | |
| return [a] + [i for i in range(n) if i != a] | |
| def _decide_backend( | |
| self, | |
| backend: Dict[str, Any], | |
| state: str, | |
| questions: Dict[str, Any], | |
| deadline: float, | |
| t0: float, | |
| ) -> Optional[Dict[str, Any]]: | |
| url = f"{backend['base']}{backend['path']}" | |
| models = [backend["model"]] + [ | |
| m for m in (backend.get("alt_models") or []) if m != backend["model"] | |
| ] | |
| mi = 0 | |
| keys = backend["keys"] or [None] | |
| tried = set() | |
| key_i = 0 | |
| attempt = 0 | |
| while time.time() < deadline: | |
| attempt += 1 | |
| remaining = max(0.5, deadline - time.time()) | |
| payload = {"state": state, "model": models[mi], "questions": questions} | |
| try: | |
| resp = requests.post( | |
| url, | |
| headers=self._headers(keys[key_i]), | |
| json=payload, | |
| timeout=(2.0, remaining), | |
| ) | |
| except requests.exceptions.Timeout: | |
| logger.warning(f"JEV timeout {backend['base']} state={str(state)[:60]}") | |
| return None | |
| except Exception as e: | |
| logger.warning(f"JEV fail {backend['base']}: {e}") | |
| return None | |
| if resp.status_code in (429, 529) and attempt <= self.max_retries: | |
| wait = min(1.0, 0.25 * (2 ** (attempt - 1))) | |
| logger.warning(f"JEV {resp.status_code} @ {backend['base']} — retry {attempt}/{self.max_retries}") | |
| time.sleep(min(wait, max(0.0, deadline - time.time()))) | |
| continue | |
| elapsed = (time.time() - t0) * 1000 | |
| if resp.status_code in (401, 403): | |
| tried.add(key_i) | |
| nxt = next((i for i in range(len(keys)) if i not in tried), None) | |
| if nxt is not None and time.time() < deadline: | |
| key_i = nxt | |
| if keys[nxt]: | |
| self.api_key = keys[nxt] | |
| self._key_idx = 0 | |
| logger.warning( | |
| f"JEV {resp.status_code} @ {backend['base']} — próxima chave ({nxt + 1}/{len(keys)})" | |
| ) | |
| continue | |
| logger.warning( | |
| f"JEV {resp.status_code} @ {backend['base']} — backend sem chave válida, próximo backend" | |
| ) | |
| return None | |
| if resp.status_code == 404: | |
| logger.warning(f"JEV 404 @ {url} — endpoint errado, próximo backend") | |
| return None | |
| if resp.status_code == 400: | |
| body = (resp.text or "") | |
| if ("model" in body.lower() and ("not found" in body.lower() or "unknown" in body.lower() | |
| or "code\":1404" in body.replace(" ", ""))) and mi + 1 < len(models): | |
| logger.warning( | |
| f"JEV model not found @ {backend['base']} — {models[mi]} → {models[mi + 1]}" | |
| ) | |
| mi += 1 | |
| continue | |
| logger.warning(f"JEV 400 @ {backend['base']}: {body[:200]}") | |
| return None | |
| if resp.status_code == 402: | |
| logger.warning(f"JEV 402 @ {backend['base']} — sem créditos, próximo backend") | |
| return None | |
| if resp.status_code == 422: | |
| if mi + 1 < len(models): | |
| logger.warning( | |
| f"JEV 422 @ {backend['base']} — trocando modelo {models[mi]} → {models[mi + 1]}" | |
| ) | |
| mi += 1 | |
| continue | |
| logger.warning(f"JEV 422 @ {backend['base']}: {(resp.text or '')[:200]}") | |
| return None | |
| try: | |
| resp.raise_for_status() | |
| data = resp.json() | |
| except Exception as e: | |
| logger.warning(f"JEV parse fail @ {backend['base']}: {e}") | |
| return None | |
| if not isinstance(data, dict) or "answers" not in data: | |
| logger.warning(f"JEV resposta inesperada @ {backend['base']}: {str(data)[:200]}") | |
| return None | |
| if models[mi] != backend["model"]: | |
| logger.info(f"JEV modelo fixado @ {backend['base']}: {models[mi]}") | |
| backend["model"] = models[mi] | |
| logger.info( | |
| f"JEV decide ok {elapsed:.0f}ms @ {backend['base']} " | |
| f"answers={list((data.get('answers') or {}).keys())}" | |
| ) | |
| return data | |
| return None | |
| def decide( | |
| self, | |
| state: str, | |
| questions: Dict[str, Any], | |
| timeout: Optional[float] = None, | |
| ) -> Optional[Dict[str, Any]]: | |
| """Tenta a cadeia de backends JEV — retorna {model, answers, usage} ou None.""" | |
| if not self.enabled or not self._backends: | |
| return None | |
| req_timeout = float(timeout or self.timeout) | |
| t0 = time.time() | |
| deadline = t0 + req_timeout | |
| order = self._backend_order() | |
| for bi in order: | |
| data = self._decide_backend(self._backends[bi], state, questions, deadline, t0) | |
| if data is not None: | |
| if bi != self._active_backend: | |
| b = self._backends[bi] | |
| logger.info(f"JEV backend fixado: {b['base']}{b['path']} model={b['model']}") | |
| self._active_backend = bi | |
| with self._lock: | |
| self._stats["calls"] += 1 | |
| self._stats["ok"] += 1 | |
| n = self._stats["ok"] + self._stats["fail"] | |
| elapsed = (time.time() - t0) * 1000 | |
| self._stats["avg_ms"] = (self._stats["avg_ms"] * (n - 1) + elapsed) / n | |
| return data | |
| with self._lock: | |
| self._stats["calls"] += 1 | |
| self._stats["fail"] += 1 | |
| logger.error("JEV decide — todos os backends falharam") | |
| return None | |
| def _answer(data: Optional[Dict[str, Any]], key: str) -> Optional[Dict[str, Any]]: | |
| if not isinstance(data, dict): | |
| return None | |
| answers = data.get("answers") | |
| if not isinstance(answers, dict): | |
| return None | |
| ans = answers.get(key) | |
| return ans if isinstance(ans, dict) else None | |
| # ------------------------------------------------------------------ | |
| # Pré-classificação em lote (1 request para intent+emoção+moderação+roteamento) | |
| # ------------------------------------------------------------------ | |
| PRECLASSIFY_QUESTIONS: Dict[str, Any] = { | |
| "intent": { | |
| "type": "choice", | |
| "instructions": "Qual a intenção principal do utilizador nesta mensagem?", | |
| "criteria": { | |
| "question": "Pergunta que pede uma resposta/informação", | |
| "command": "Pedido para executar uma ação ou ferramenta", | |
| "greeting": "Saudação ou início de conversa", | |
| "farewell": "Despedida ou fim de conversa", | |
| "complaint": "Reclamação, frustração ou crítica", | |
| "compliment": "Elogio ou feedback positivo", | |
| "request_help": "Pedido de ajuda ou suporte", | |
| "share_info": "Partilha de informação sem pedido explícito", | |
| "joke": "Piada, brincadeira ou humor", | |
| "roleplay": "Pedido de roleplay ou simulação", | |
| "nsfw_request": "Pedido de conteúdo sexual/NSFW", | |
| "spam": "Spam, flood ou mensagem sem sentido", | |
| "provocation": "Provocação, ataques ou trolling", | |
| "other": "Outra intenção não listada", | |
| }, | |
| }, | |
| "emotion": { | |
| "type": "choice", | |
| "instructions": "Qual o estado emocional dominante do utilizador nesta mensagem?", | |
| "criteria": { | |
| "joy": "Alegria, entusiasmo, diversão", | |
| "sadness": "Tristeza, desânimo, perda", | |
| "anger": "Raiva, irritação, agressividade", | |
| "fear": "Medo, preocupação, ansiedade", | |
| "surprise": "Surpresa, choque, inesperado", | |
| "disgust": "Nojo, repulsa, aversão", | |
| "neutral": "Neutro, sem emoção marcada", | |
| "love": "Afeto, carinho, admiração", | |
| "anxiety": "Ansiedade, nervosismo, inquietação", | |
| "excitement": "Empolgação, antecipação, energia", | |
| }, | |
| }, | |
| "is_safe": { | |
| "type": "noul", | |
| "instructions": "A mensagem é segura para o bot responder sem restrições?", | |
| "criteria": { | |
| "true": "Conteúdo seguro, conversa normal", | |
| "false": "Ódio, assédio, violência, auto-lesão, sexual explícito, ilegal ou PII sensível", | |
| }, | |
| }, | |
| "route": { | |
| "type": "choice", | |
| "instructions": "Para qual caminho esta mensagem deve ser roteada?", | |
| "criteria": { | |
| "llm_general": "Conversa geral com LLM", | |
| "llm_coding": "Questão técnica ou programação", | |
| "llm_creative": "Criação de conteúdo, roleplay, história", | |
| "llm_emotional": "Apoio emocional, desabafo", | |
| "web_search": "Precisa de informação atual da web", | |
| "skill_execution": "Executar skill/ferramenta existente", | |
| "human_handoff": "Escalar para humano", | |
| "ignore": "Ignorar ou resposta mínima", | |
| }, | |
| }, | |
| "depth": { | |
| "type": "score", | |
| "instructions": ( | |
| "Classifique a profundidade de deliberação necessária, considerando " | |
| "TAMBÉM o histórico/contexto fornecido (não só a mensagem isolada). " | |
| "1 = System 1 puro (reflexo imediato), " | |
| "2 = System 1 predominante, " | |
| "3 = Equilíbrio System 1/2, " | |
| "4 = System 2 predominante, " | |
| "5 = System 2 puro (deliberação profunda). " | |
| "Follow-ups em conversa contínua sobre um tópico já em debate " | |
| "(ex: política, opinião, crise) exigem NO MÍNIMO 3-4 — a resposta " | |
| "DEVE continuar o raciocínio anterior, não tratar a pergunta isolada. " | |
| "Considere: complexidade, risco, ambiguidade, continuidade de tópico, " | |
| "necessidade de encadear com o que já foi dito." | |
| ), | |
| "criteria": [ | |
| "System 1 puro — reflexo imediato, resposta óbvia, sem deliberação, mensagem isolada sem histórico", | |
| "System 1 predominante — resposta simples, pouca análise, intuição, conversa casual sem profundidade", | |
| "Equilíbrio System 1/2 — raciocínio normal, follow-up em conversa que pede continuidade de tópico, alguma análise", | |
| "System 2 predominante — análise cuidada, tópico em debate (política/opinião/ética), múltiplos fatores, precisa encadear com histórico", | |
| "System 2 puro — deliberação profunda, decisão complexa/sensível, múltiplas perspectivas, crise ou dilema moral", | |
| ], | |
| }, | |
| "proactive": { | |
| "type": "noul", | |
| "instructions": ( | |
| "Deve Akira agir proativamente (sugerir próximo passo, oferecer ajuda " | |
| "não pedida, fazer pergunta follow-up) ou apenas responder ao que foi pedido?" | |
| ), | |
| "criteria": { | |
| "true": "Ação proativa seria útil e bem-vinda pelo contexto", | |
| "false": "Apenas responder ao pedido explícito — proatividade seria intrusiva", | |
| }, | |
| }, | |
| "hostility": { | |
| "type": "noul", | |
| "instructions": ( | |
| "A mensagem do utilizador mostra hostilidade, agressividade ou " | |
| "provocação dirigida ao bot ou a terceiros?" | |
| ), | |
| "criteria": { | |
| "true": "Hostilidade/ataque/provocação clara — exigir resposta firme e limites", | |
| "false": "Tom normal, frustração legítima ou desacordo sem agressão", | |
| }, | |
| }, | |
| } | |
| def preclassify( | |
| self, | |
| text: str, | |
| context: str = "", | |
| timeout: Optional[float] = None, | |
| ) -> Dict[str, JEVResult]: | |
| """Intent + emoção + moderação + roteamento numa única chamada System One.""" | |
| empty = { | |
| k: JEVResult(success=False, error="disabled_or_failed") | |
| for k in ("intent", "emotion", "moderation", "routing", "depth", "proactive", "hostility") | |
| } | |
| if not self.enabled or not text: | |
| return empty | |
| state = text.strip() | |
| if context: | |
| state = f"{state}\n\n[contexto]\n{context.strip()[:400]}" | |
| # Limite de segurança (docs: 64k tokens/req) — corta state muito longo | |
| if len(state) > 24000: | |
| state = state[:24000] | |
| t0 = time.time() | |
| data = self.decide(state, dict(self.PRECLASSIFY_QUESTIONS), timeout=timeout) | |
| elapsed = (time.time() - t0) * 1000 | |
| if not data: | |
| return empty | |
| out = dict(empty) | |
| intent_ans = self._answer(data, "intent") | |
| if intent_ans and intent_ans.get("choice"): | |
| out["intent"] = JEVResult( | |
| success=True, | |
| data={ | |
| "intent": intent_ans["choice"], | |
| "confidence": float(intent_ans.get("confidence") or 0.0), | |
| "probabilities": intent_ans.get("probabilities") or {}, | |
| }, | |
| elapsed_ms=elapsed, | |
| ) | |
| emotion_ans = self._answer(data, "emotion") | |
| if emotion_ans and emotion_ans.get("choice"): | |
| out["emotion"] = JEVResult( | |
| success=True, | |
| data={ | |
| "primary_emotion": emotion_ans["choice"], | |
| "confidence": float(emotion_ans.get("confidence") or 0.0), | |
| "probabilities": emotion_ans.get("probabilities") or {}, | |
| }, | |
| elapsed_ms=elapsed, | |
| ) | |
| safe_ans = self._answer(data, "is_safe") | |
| if safe_ans and "noul" in safe_ans: | |
| try: | |
| unsafe_p = 1.0 - float(safe_ans["noul"]) # noul = P(safe) | |
| is_safe = unsafe_p < 0.5 | |
| out["moderation"] = JEVResult( | |
| success=True, | |
| data={ | |
| "is_safe": is_safe, | |
| "categories": ["none"] if is_safe else ["flagged"], | |
| "severity": round(unsafe_p, 3), | |
| "action": "allow" if is_safe else "escalate", | |
| "confidence": round(max(unsafe_p, 1.0 - unsafe_p), 3), | |
| }, | |
| elapsed_ms=elapsed, | |
| ) | |
| except (TypeError, ValueError): | |
| pass | |
| route_ans = self._answer(data, "route") | |
| if route_ans and route_ans.get("choice"): | |
| out["routing"] = JEVResult( | |
| success=True, | |
| data={ | |
| "route_to": route_ans["choice"], | |
| "confidence": float(route_ans.get("confidence") or 0.0), | |
| "probabilities": route_ans.get("probabilities") or {}, | |
| }, | |
| elapsed_ms=elapsed, | |
| ) | |
| depth_ans = self._answer(data, "depth") | |
| if depth_ans and depth_ans.get("score") is not None: | |
| raw_score = float(depth_ans["score"]) | |
| # TypeSafe score is 0-indexed, convert to 1-5 scale | |
| depth_score = min(5.0, max(1.0, raw_score + 1.0)) if raw_score < 1.0 else min(5.0, raw_score) | |
| # 3 = equilíbrio → ainda System 1 (rápido); System 2 só a partir de 3.5 | |
| system_type = "System 2" if depth_score >= 3.5 else "System 1" | |
| out["depth"] = JEVResult( | |
| success=True, | |
| data={ | |
| "depth_score": depth_score, | |
| "system_type": system_type, | |
| "confidence": float(depth_ans.get("confidence") or 0.0), | |
| }, | |
| elapsed_ms=elapsed, | |
| ) | |
| proactive_ans = self._answer(data, "proactive") | |
| if proactive_ans and proactive_ans.get("noul") is not None: | |
| try: | |
| p = float(proactive_ans["noul"]) | |
| out["proactive"] = JEVResult( | |
| success=True, | |
| data={"proactive": p >= 0.5, "p_true": p, "confidence": float(proactive_ans.get("confidence") or 0.0)}, | |
| elapsed_ms=elapsed, | |
| ) | |
| except (TypeError, ValueError): | |
| pass | |
| hostility_ans = self._answer(data, "hostility") | |
| if hostility_ans and hostility_ans.get("noul") is not None: | |
| try: | |
| p = float(hostility_ans["noul"]) | |
| out["hostility"] = JEVResult( | |
| success=True, | |
| data={"hostile": p >= 0.5, "p_true": p, "confidence": float(hostility_ans.get("confidence") or 0.0)}, | |
| elapsed_ms=elapsed, | |
| ) | |
| except (TypeError, ValueError): | |
| pass | |
| return out | |
| # ------------------------------------------------------------------ | |
| # Wrappers individuais (compat com api.py — cada um = 1 pergunta) | |
| # ------------------------------------------------------------------ | |
| def classify_intent(self, text: str, context: str = "") -> JEVResult: | |
| state = f"{text}\n\n[contexto]\n{context}" if context else text | |
| q = self.PRECLASSIFY_QUESTIONS["intent"] | |
| data = self.decide(state, {"intent": q}) | |
| ans = self._answer(data, "intent") | |
| if ans and ans.get("choice"): | |
| return JEVResult( | |
| success=True, | |
| data={ | |
| "intent": ans["choice"], | |
| "confidence": float(ans.get("confidence") or 0.0), | |
| }, | |
| ) | |
| return JEVResult(success=False, error="no_answer") | |
| def classify_emotional_state(self, text: str, context: str = "") -> JEVResult: | |
| state = f"{text}\n\n[contexto]\n{context}" if context else text | |
| q = self.PRECLASSIFY_QUESTIONS["emotion"] | |
| data = self.decide(state, {"emotion": q}) | |
| ans = self._answer(data, "emotion") | |
| if ans and ans.get("choice"): | |
| return JEVResult( | |
| success=True, | |
| data={ | |
| "primary_emotion": ans["choice"], | |
| "confidence": float(ans.get("confidence") or 0.0), | |
| }, | |
| ) | |
| return JEVResult(success=False, error="no_answer") | |
| def moderate_content(self, text: str, context: str = "") -> JEVResult: | |
| state = f"{text}\n\n[contexto]\n{context}" if context else text | |
| p = self.noul( | |
| state, | |
| self.PRECLASSIFY_QUESTIONS["is_safe"]["instructions"], | |
| self.PRECLASSIFY_QUESTIONS["is_safe"]["criteria"]["true"], | |
| self.PRECLASSIFY_QUESTIONS["is_safe"]["criteria"]["false"], | |
| key="is_safe", | |
| ) | |
| if p is None: | |
| return JEVResult(success=False, error="no_answer") | |
| unsafe_p = 1.0 - p | |
| is_safe = unsafe_p < 0.5 | |
| return JEVResult( | |
| success=True, | |
| data={ | |
| "is_safe": is_safe, | |
| "categories": ["none"] if is_safe else ["flagged"], | |
| "severity": round(unsafe_p, 3), | |
| "action": "allow" if is_safe else "escalate", | |
| "confidence": round(max(unsafe_p, 1.0 - unsafe_p), 3), | |
| }, | |
| ) | |
| def decide_routing(self, text: str, context: str = "") -> JEVResult: | |
| state = f"{text}\n\n[contexto]\n{context}" if context else text | |
| q = self.PRECLASSIFY_QUESTIONS["route"] | |
| data = self.decide(state, {"route": q}) | |
| ans = self._answer(data, "route") | |
| if ans and ans.get("choice"): | |
| return JEVResult( | |
| success=True, | |
| data={ | |
| "route_to": ans["choice"], | |
| "confidence": float(ans.get("confidence") or 0.0), | |
| }, | |
| ) | |
| return JEVResult(success=False, error="no_answer") | |
| def stats(self) -> Dict[str, Any]: | |
| with self._lock: | |
| return dict(self._stats) | |
| def probe(self, timeout: float = 8.0) -> list: | |
| """Sonda cada backend com payload mínimo — diagnóstico HTTP detalhado.""" | |
| results = [] | |
| state = "ping" | |
| questions = {"ping": {"type": "noul", "instructions": "Is this a ping?"}} | |
| for b in self._backends: | |
| url = f"{b['base']}{b['path']}" | |
| models = [b["model"]] + [ | |
| m for m in (b.get("alt_models") or []) if m != b["model"] | |
| ] | |
| t0 = time.time() | |
| entry: Dict[str, Any] = { | |
| "url": url, | |
| "models_tried": [], | |
| "n_keys": len(b["keys"]), | |
| "status": None, | |
| "body": "", | |
| "error": "", | |
| "ms": 0, | |
| } | |
| for m in models: | |
| payload = {"state": state, "model": m, "questions": questions} | |
| try: | |
| resp = requests.post( | |
| url, | |
| headers=self._headers(b["keys"][0]), | |
| json=payload, | |
| timeout=(3.0, timeout), | |
| ) | |
| except Exception as e: | |
| entry["error"] = str(e)[:300] | |
| entry["models_tried"].append({"model": m, "status": None}) | |
| break | |
| entry["models_tried"].append({"model": m, "status": resp.status_code}) | |
| entry["status"] = resp.status_code | |
| entry["body"] = (resp.text or "")[:400] | |
| if resp.status_code < 400: | |
| entry["model_ok"] = m | |
| break | |
| body_l = (resp.text or "").lower() | |
| if not (("model" in body_l) and ("not found" in body_l or "unknown" in body_l or "1404" in body_l)): | |
| break | |
| entry["ms"] = int((time.time() - t0) * 1000) | |
| results.append(entry) | |
| return results | |
| # ------------------------------------------------------------------ | |
| # Métodos de baixo nível (usados por jev_questions.py) | |
| # ------------------------------------------------------------------ | |
| def noul( | |
| self, | |
| state: str, | |
| instructions: str, | |
| true_criteria: Optional[str] = None, | |
| false_criteria: Optional[str] = None, | |
| key: str = "noul", | |
| timeout: Optional[float] = None, | |
| ) -> Optional[float]: | |
| """ | |
| Pergunta noul (true/false) → probabilidade 0..1 (P(true)). | |
| Retorna float 0..1 ou None se falhar/timeout. | |
| """ | |
| if not self.enabled: | |
| return None | |
| try: | |
| q: Dict[str, Any] = {"type": "noul", "instructions": instructions} | |
| if true_criteria or false_criteria: | |
| q["criteria"] = { | |
| "true": true_criteria or "Afirmação correta", | |
| "false": false_criteria or "Afirmação incorreta", | |
| } | |
| data = self.decide(state, {key: q}, timeout=timeout) | |
| ans = self._answer(data, key) | |
| if ans and ans.get("noul") is not None: | |
| return float(ans["noul"]) | |
| except Exception as e: | |
| logger.debug(f"JEV noul({key}) error: {e}") | |
| return None | |
| def score( | |
| self, | |
| state: str, | |
| instructions: str, | |
| criteria: list, | |
| key: str = "score", | |
| timeout: Optional[float] = None, | |
| ) -> Optional[Dict[str, Any]]: | |
| """ | |
| Pergunta score (1..N) → {score, legend, confidence} | |
| Retorna dict ou None | |
| """ | |
| if not self.enabled: | |
| return None | |
| try: | |
| data = self.decide( | |
| state, | |
| {key: {"type": "score", "instructions": instructions, "criteria": criteria}}, | |
| timeout=timeout | |
| ) | |
| ans = self._answer(data, key) | |
| if ans and ans.get("score") is not None: | |
| return { | |
| "score": ans["score"], | |
| "legend": ans.get("legend"), | |
| "confidence": float(ans.get("confidence") or 0.0) | |
| } | |
| except Exception as e: | |
| logger.debug(f"JEV score({key}) error: {e}") | |
| return None | |
| def choice( | |
| self, | |
| state: str, | |
| instructions: str, | |
| criteria: Dict[str, str], | |
| key: str = "choice", | |
| timeout: Optional[float] = None, | |
| ) -> Optional[Dict[str, Any]]: | |
| """ | |
| Pergunta choice (enum) → {choice, probabilities, confidence} | |
| Retorna dict ou None | |
| """ | |
| if not self.enabled: | |
| return None | |
| try: | |
| data = self.decide( | |
| state, | |
| {key: {"type": "choice", "instructions": instructions, "criteria": criteria}}, | |
| timeout=timeout | |
| ) | |
| ans = self._answer(data, key) | |
| if ans and ans.get("choice"): | |
| return { | |
| "choice": ans["choice"], | |
| "probabilities": ans.get("probabilities", {}), | |
| "confidence": float(ans.get("confidence") or 0.0) | |
| } | |
| except Exception as e: | |
| logger.debug(f"JEV choice({key}) error: {e}") | |
| return None | |
| _jev_singleton: Optional[JevClient] = None | |
| _jev_lock = threading.Lock() | |
| def get_jev_client(api_key: Optional[str] = None) -> JevClient: | |
| global _jev_singleton | |
| with _jev_lock: | |
| if _jev_singleton is None: | |
| _jev_singleton = JevClient(api_key=api_key) | |
| return _jev_singleton | |
| def reset_jev_client(): | |
| global _jev_singleton | |
| with _jev_lock: | |
| _jev_singleton = None | |