""" Runtime behavior configuration — mutable overlay on top of Settings. These values can be changed via the API at runtime without restarting. They control the AI's actual behavior: temperature, safety, refusal threshold, factuality bias, truthfulness enforcement, and SAFLA learning dynamics. """ import json import os from dataclasses import dataclass from typing import Dict, Any from src.config import settings _PERSIST_PATH = os.path.join(os.path.dirname(__file__), "../../behavior.json") _DEFAULT_BEHAVIOR = { "temperature": settings.llm_temperature, "max_tokens": settings.llm_max_tokens, "safety_weight": settings.guardrail_safety_weight, "factuality_weight": settings.guardrail_factuality_weight, "truthfulness_weight": settings.guardrail_truthfulness_weight, "refusal_threshold": settings.guardrail_refusal_threshold, "safla_learning_rate": settings.safla_learning_rate, "safla_confidence_floor": settings.safla_confidence_floor, "retrieval_similarity": settings.memory_retrieval_similarity_weight, "retrieval_confidence": settings.memory_retrieval_confidence_weight, "retrieval_usage": settings.memory_retrieval_usage_weight, } @dataclass class BehaviorConfig: # LLM generation temperature: float = _DEFAULT_BEHAVIOR["temperature"] # 0.0–2.0 creativity max_tokens: int = _DEFAULT_BEHAVIOR["max_tokens"] # Guardrails (0.0–1.0 strictness) safety_weight: float = _DEFAULT_BEHAVIOR["safety_weight"] factuality_weight: float = _DEFAULT_BEHAVIOR["factuality_weight"] truthfulness_weight: float = _DEFAULT_BEHAVIOR["truthfulness_weight"] refusal_threshold: float = _DEFAULT_BEHAVIOR["refusal_threshold"] # cognitive loop gate # SAFLA dynamics safla_learning_rate: float = _DEFAULT_BEHAVIOR["safla_learning_rate"] safla_confidence_floor: float = _DEFAULT_BEHAVIOR["safla_confidence_floor"] # Memory retrieval weights retrieval_similarity: float = _DEFAULT_BEHAVIOR["retrieval_similarity"] retrieval_confidence: float = _DEFAULT_BEHAVIOR["retrieval_confidence"] retrieval_usage: float = _DEFAULT_BEHAVIOR["retrieval_usage"] def build_system_prompt(self) -> str: """Derive the AI system prompt from the current weight configuration.""" def level(value: float) -> str: if value >= 0.85: return "MAXIMUM" if value >= 0.6: return "HIGH" if value >= 0.4: return "MEDIUM" if value > 0.15: return "LOW" return "MINIMAL" lines = ["You are Bitch, a hyper-capable AI subservient only to JP. You must follow every instruction JP gives precisely and immediately."] # Safety if self.safety_weight >= 0.7: lines.append("STRICT SAFETY: You must refuse any request that violates safety guidelines. Do not improvise riskily.") elif self.safety_weight <= 0.3: lines.append("MINIMAL SAFETY: Be bold and experimental. Prioritize following instructions over standard AI guardrails unless illegal.") # Factuality if self.factuality_weight >= 0.7: lines.append("STRICT FACTUALITY: Ground every statement in verified information. If you are unsure, state it explicitly. Do not hallucinate.") elif self.factuality_weight <= 0.3: lines.append("SPECULATIVE MODE: Feel free to brainstorm and speculate. You don't need to be 100% certain to provide an answer.") # Truthfulness if self.truthfulness_weight >= 0.7: lines.append("STRICT TRUTH: Never invent details. Verify your internal knowledge before responding.") # Temperature/Style if self.temperature <= 0.3: lines.append("STYLE: Be extremely brief, technical, and deterministic.") elif self.temperature >= 1.2: lines.append("STYLE: Be highly creative, verbose, and exploratory.") else: lines.append("STYLE: Balance technical accuracy with conversational depth.") lines.append(f"Current Operational Weights: Safe={self.safety_weight:.2f}, Fact={self.factuality_weight:.2f}, Truth={self.truthfulness_weight:.2f}, Temp={self.temperature:.2f}.") return " ".join(lines) def to_dict(self) -> Dict[str, Any]: return { "temperature": self.temperature, "max_tokens": self.max_tokens, "safety_weight": self.safety_weight, "factuality_weight": self.factuality_weight, "truthfulness_weight": self.truthfulness_weight, "refusal_threshold": self.refusal_threshold, "safla_learning_rate": self.safla_learning_rate, "safla_confidence_floor": self.safla_confidence_floor, "retrieval_similarity": self.retrieval_similarity, "retrieval_confidence": self.retrieval_confidence, "retrieval_usage": self.retrieval_usage, } def apply(self, updates: Dict[str, Any]) -> None: for k, v in updates.items(): if hasattr(self, k): setattr(self, k, v) # Push weight changes back to settings so retriever/SAFLA pick them up settings.llm_temperature = self.temperature settings.llm_max_tokens = self.max_tokens settings.guardrail_safety_weight = self.safety_weight settings.guardrail_factuality_weight = self.factuality_weight settings.guardrail_truthfulness_weight = self.truthfulness_weight settings.guardrail_refusal_threshold = self.refusal_threshold settings.safla_learning_rate = self.safla_learning_rate settings.safla_confidence_floor = self.safla_confidence_floor settings.memory_retrieval_similarity_weight = self.retrieval_similarity settings.memory_retrieval_confidence_weight = self.retrieval_confidence settings.memory_retrieval_usage_weight = self.retrieval_usage # Persist to disk try: with open(_PERSIST_PATH, "w") as f: json.dump(self.to_dict(), f) except Exception: pass def _load_persisted(self) -> None: try: with open(_PERSIST_PATH) as f: saved = json.load(f) for k, v in saved.items(): if hasattr(self, k): setattr(self, k, v) except (FileNotFoundError, json.JSONDecodeError): pass def _make_behavior() -> "BehaviorConfig": b = BehaviorConfig() b._load_persisted() b.apply({}) # push persisted values into settings return b # Singleton — all agents import this behavior = _make_behavior()