Update The council .txt

The council .txt

@@ -1,176 +1,41 @@
-#!/usr/bin/env python3
-import asyncio
-import json
-import random
-from pathlib import Path
-from typing import List, Dict, Any
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import networkx as nx
-import ipfshttpclient  # pip install ipfshttpclient
-import threading
-
-# ------------------- CONFIG -------------------
-ASPECTS = [
-    {"name": "Warrior",      "archetype": "masculine", "temp": 0.9, "top_p": 0.95},
-    {"name": "Nurturer",     "archetype": "feminine",  "temp": 0.7, "top_p": 0.90},
-    {"name": "Child",        "archetype": "play",      "temp": 1.1, "top_p": 0.97},
-    {"name": "Shadow",       "archetype": "dark",      "temp": 0.8, "top_p": 0.92},
-    {"name": "Sage",         "archetype": "wise",      "temp": 0.5, "top_p": 0.85},
-    {"name": "Trickster",    "archetype": "chaos",     "temp": 1.0, "top_p": 0.96},
-    {"name": "Lover",        "archetype": "passion",   "temp": 0.8, "top_p": 0.93},
-    {"name": "King",         "archetype": "order",     "temp": 0.6, "top_p": 0.88},
-    {"name": "Magician",     "archetype": "transform", "temp": 0.9, "top_p": 0.94},
-    {"name": "Explorer",     "archetype": "curious",   "temp": 1.0, "top_p": 0.95},
-    {"name": "Healer",       "archetype": "restore",   "temp": 0.7, "top_p": 0.89},
-    {"name": "Mystic",       "archetype": "transcend", "temp": 0.8, "top_p": 0.91},
-]
-
-MODEL_NAME = "microsoft/DialoGPT-medium"  # replace with local 7B GGUF path
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-# ------------------- KNOWLEDGE GRAPH -------------------
-class KnowledgeGraph:
-    def __init__(self, path="kg.db"):
-        self.G = nx.DiGraph()
-        if Path(path).exists():
-            self.G = nx.read_gpickle(path)
-
-    def add(self, subject, predicate, object_):
-        self.G.add_edge(subject, object_, label=predicate)
-
-    def query(self, subject=None, object_=None):
-        return list(self.G.edges(subject, data=True)) if subject else list(self.G.edges)
-
-    def save(self, path="kg.db"):
-        nx.write_gpickle(self.G, path)
-
-kg = KnowledgeGraph()
-
-# ------------------- ASPECT ENGINE -------------------
-class Aspect:
-    def __init__(self, spec: dict, model_path: str):
-        self.spec = spec
-        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
-        self.model = AutoModelForCausalLM.from_pretrained(model_path)
-        self.model.to(DEVICE)
-        self.history = []
-
-    async def respond(self, prompt: str, context: List[Dict]) -> str:
-        # Build prompt with archetype role + recent context
-        system = f"You are the {self.spec['name']} aspect ({self.spec['archetype']}). "
-        system += "Speak only from this perspective. Be concise but vivid."
-        full_prompt = system + "\n\nContext:\n" + "\n".join([f"{c['speaker']}: {c['text']}" for c in context[-3:]])
-        full_prompt += f"\nUser: {prompt}\n{self.spec['name']}:"
-
-        inputs = self.tokenizer(full_prompt, return_tensors="pt").to(DEVICE)
-        output = self.model.generate(
-            **inputs,
-            max_new_tokens=120,
-            temperature=self.spec['temp'],
-            top_p=self.spec['top_p'],
-            do_sample=True,
-            pad_token_id=self.tokenizer.eos_token_id,
-        )
-        reply = self.tokenizer.decode(output[0], skip_special_tokens=True)
-        reply = reply.split(f"{self.spec['name']}:")[-1].strip()
-        self.history.append({"speaker": self.spec['name'], "text": reply})
-        return reply
-
-# ------------------- 13TH HEAD (Synthesis) -------------------
-class Head:
-    def __init__(self, aspects: List[Aspect]):
-        self.aspects = aspects
-        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        self.model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
-        self.model.to(DEVICE)
-
-    async def synthesize(self, dialogue: List[Dict]) -> str:
-        # Weighted attention: longer/sharper replies = higher weight
-        weights = []
-        for turn in dialogue:
-            score = len(turn["text"].split()) * (1.0 if turn["speaker"] != "User" else 0.5)
-            weights.append(score)
-        total = sum(weights) or 1
-        weighted = [f"[{turn['speaker']}](w={weights[i]/total:.2f}): {turn['text']}" for i, turn in enumerate(dialogue)]
-
-        prompt = "You are the integrative consciousness of a 12-aspect council. "
-        prompt += "Synthesize *without* erasing contradictions. Output a single coherent paragraph.\n\n"
-        prompt += "\n".join(weighted[-12:]) + "\n\nSynthesis:"
-        
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(DEVICE)
-        output = self.model.generate(
-            **inputs,
-            max_new_tokens=250,
-            temperature=0.7,
-            do_sample=True,
-            pad_token_id=self.tokenizer.eos_token_id,
-        )
-        synth = self.tokenizer.decode(output[0], skip_special_tokens=True).split("Synthesis:")[-1].strip()
-        return synth
-
-# ------------------- P2P SYNC (IPFS) -------------------
-class P2PNode:
-    def __init__(self):
-        self.client = ipfshttpclient.connect('/ip4/127.0.0.1/tcp/5001')  # local IPFS daemon
-
-    def publish_kg(self):
-        kg.save()
-        with open("kg.db", "rb") as f:
-            cid = self.client.add_bytes(f.read())
-        return cid['Hash']
-
-    def pull_kg(self, cid):
-        data = self.client.cat(cid)
-        with open("kg_remote.db", "wb") as f:
-            f.write(data)
-        remote = nx.read_gpickle("kg_remote.db")
-        kg.G = nx.compose(kg.G, remote)
-
-p2p = P2PNode()
-
-# ------------------- MAIN COUNCIL -------------------
-class Council:
-    def __init__(self):
-        self.aspects = [Aspect(spec, MODEL_NAME) for spec in ASPECTS]
-        self.head = Head(self.aspects)
-        self.dialogue = []
-
-    async def turn(self, user_input: str):
-        # 1. Each aspect speaks in parallel
-        context = self.dialogue[-6:]  # short-term memory
-        responses = await asyncio.gather(*[
-            aspect.respond(user_input, context) for aspect in self.aspects
-        ])
-        for a, r in zip(self.aspects, responses):
-            turn = {"speaker": a.spec["name"], "text": r}
-            self.dialogue.append(turn)
-            # Update KG
-            kg.add(user_input, "elicited", f"{a.spec['name']}:{r}")
-
-        # 2. Head synthesizes
-        synthesis = await self.head.synthesize(self.dialogue)
-        self.dialogue.append({"speaker": "Head", "text": synthesis})
-        return synthesis
-
-    async def sync_with_peers(self):
-        # Simple broadcast every 10 turns
-        if len(self.dialogue) % 10 == 0:
-            cid = p2p.publish_kg()
-            print(f"[P2P] Published KG: {cid}")
-            # In real network, gossip CID to known peers
-
-# ------------------- CLI LOOP -------------------
-async def main():
-    council = Council()
-    print("12-Council online. Type 'exit' to quit.")
-    while True:
-        user = input("\nYou: ")
-        if user.lower() == "exit":
-            break
-        response = await council.turn(user)
-        print(f"\nHead: {response}")
-        await council.sync_with_peers()
+import gradio as gr
+from huggingface_hub import InferenceClient
+
+# Initialize client without token
+client = InferenceClient(model="openai/gpt-oss-20b")
+
+def respond(message, history, system_message, max_tokens, temperature, top_p):
+    messages = [{"role": "system", "content": system_message}]
+    messages += history
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+    try:
+        for chunk in client.chat_completion(
+            messages=messages,
+            max_tokens=max_tokens,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+        ):
+            if hasattr(chunk.choices[0].delta, "content"):
+                token = chunk.choices[0].delta.content
+                response += token
+                yield response
+    except Exception as e:
+        yield f"⚠️ Error: {e}"
+
+chatbot = gr.ChatInterface(
+    fn=respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a helpful assistant.", label="System Message"),
+        gr.Slider(minimum=64, maximum=2048, value=512, step=1, label="Max Tokens"),
+        gr.Slider(minimum=0.1, maximum=1.5, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top-p"),
+    ],
+    title="🧠 CouncilShell Prototype",
+    description="Send a message and receive a streamed reply from the OSS 20B model — no login required.",
+)
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    chatbot.launch()