0xkobold 0.4.3 → 0.5.0

package/dist/src/extensions/core/gateway-extension.js

@@ -1,730 +1,519 @@
 /**
- * Gateway Extension for 0xKobold
+ * 🐉 Draconic Gateway Extension
  *
- * Multi-Agent WebSocket Gateway - Ported from gateway/index.ts
- * Provides WebSocket server for agent spawning and management
+ * Enhanced with:
+ * - DraconicConnectionPool: HTTP/2 multiplexing for API calls
+ * - DraconicTokenPredictor: Pre-send token estimation
+ * - DraconicRunRegistry: Hierarchical agent tracking
+ * - DraconicErrorClassifier: Predictive error handling
+ *
+ * Replaces: gateway-extension.ts with superior performance
  */
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { existsSync, mkdirSync } from 'node:fs';
-// Extension state
+import { Type } from "@sinclair/typebox";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, mkdirSync } from "node:fs";
+// 🐉 DRACONIC IMPORTS
+import { getDraconicConnectionPool, } from "../../infra/DraconicConnectionPool";
+import { getDraconicTokenPredictor, } from "../../agent/DraconicTokenPredictor";
+import { getDraconicRunRegistry, } from "../../agent/DraconicRunRegistry";
+import { getDraconicErrorClassifier, } from "../../agent/DraconicErrorClassifier";
+// Config
+const DEFAULT_GATEWAY_PORT = 18789;
+const GATEWAY_PORT = process.env.GATEWAY_PORT
+    ? parseInt(process.env.GATEWAY_PORT)
+    : DEFAULT_GATEWAY_PORT;
+const AGENTS_DIR = join(homedir(), ".0xkobold", "agents");
+// State
 let server = null;
 const agents = new Map();
-const clients = new Map();
+const clients = new Map(); // Bun ServerWebSocket, not std WebSocket
 let eventSeq = 0;
 let isRunning = false;
-let hasAttemptedStart = false; // Track if we've attempted to start
-const KOBOLD_DIR = join(homedir(), ".0xkobold");
-const AGENTS_DIR = join(KOBOLD_DIR, "agents");
-const DEFAULT_GATEWAY_PORT = 18789;
-const MAX_PORT_RETRIES = 10;
-// Dynamic port state
-let GATEWAY_PORT = DEFAULT_GATEWAY_PORT;
-// Ensure directories exist
-function ensureDirectories() {
-    if (!existsSync(KOBOLD_DIR)) {
-        mkdirSync(KOBOLD_DIR, { recursive: true });
-    }
-    if (!existsSync(AGENTS_DIR)) {
-        mkdirSync(AGENTS_DIR, { recursive: true });
-    }
+// 🐉 Draconic systems
+let draconicPool;
+let draconicPredictor;
+let draconicRegistry;
+let draconicClassifier;
+/**
+ * Initialize Draconic systems
+ */
+function initializeDraconicSystems() {
+    draconicPool = getDraconicConnectionPool();
+    draconicPredictor = getDraconicTokenPredictor();
+    draconicRegistry = getDraconicRunRegistry();
+    draconicClassifier = getDraconicErrorClassifier();
+    console.log("[🐉 DraconicGateway] Performance systems initialized:");
+    console.log("  - HTTP/2 Connection Pool with multiplexing");
+    console.log("  - Token prediction pre-send analysis");
+    console.log("  - Hierarchical agent tracking");
+    console.log("  - Predictive error classification");
 }
-// Check if a port is available
-async function isPortAvailable(port, hostname) {
-    try {
-        const testServer = Bun.serve({
-            port,
-            hostname,
-            fetch() {
-                return new Response('test');
-            },
+/**
+ * Enhanced agent spawn with Draconic prediction
+ */
+async function spawnDraconicAgent(params, pi) {
+    // 🐉 Predict tokens BEFORE creating agent
+    const tokenEstimate = draconicPredictor.estimate({
+        systemPrompt: "You are a helpful coding assistant",
+        history: [],
+        currentPrompt: params.task,
+        contextWindow: 128000,
+        model: params.model || "claude-3-sonnet",
+    });
+    // Warn if context will be tight
+    if (tokenEstimate.suggestedAction === "compact") {
+        console.log(`[🐉 Gateway] Token prediction: ${tokenEstimate.suggestedAction}`);
+        pi.sendMessage({
+            customType: "gateway.token.warning",
+            content: [{ type: "text", text: `⚠️ Context limit may be reached (${tokenEstimate.contextWindow.percent.toFixed(1)}%)` }],
+            display: true,
+            details: tokenEstimate,
         });
-        testServer.stop();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Find an available port starting from the preferred port
-async function findAvailablePort(preferredPort, hostname) {
-    for (let i = 0; i < MAX_PORT_RETRIES; i++) {
-        const port = preferredPort + i;
-        if (await isPortAvailable(port, hostname)) {
-            return port;
-        }
-        console.log(`[Gateway] Port ${port} is in use, trying next...`);
     }
-    throw new Error(`Could not find an available port after ${MAX_PORT_RETRIES} attempts`);
-}
-// Event Bus
-// @ts-ignore Return type
-function emit(pi, event, payload) {
-    eventSeq++;
-    const frame = {
-        type: "event",
-        event,
-        payload,
-        seq: eventSeq,
-    };
-    // Emit to pi-coding-agent via message system
-    // @ts-ignore sendMessage type
-    // @ts-ignore sendMessage type
-    // @ts-ignore Content type
-    pi.sendMessage({
-        customType: 'gateway.broadcast',
-        // @ts-ignore Content type
-        content: [{ type: 'text', text: `Event: ${event}` }],
-        // @ts-ignore Content type
-        display: { type: 'text', text: `Gateway event: ${event}` },
-        details: { event, payload, seq: eventSeq },
+    // Create Draconic run record
+    const parentId = params.parentId;
+    const draconicRun = draconicRegistry.create({
+        sessionKey: `gateway-${Date.now()}`,
+        name: params.label || `Agent ${agents.size + 1}`,
+        type: "worker",
+        task: params.task,
+        workspace: AGENTS_DIR,
+        capabilities: {
+            primary: params.capabilities || ["general"],
+            secondary: [],
+        },
+        depth: parentId ? 1 : 0,
+        isProcessingQueue: false,
+        parentId,
+        model: params.model,
     });
-    // Broadcast to WebSocket clients
-    for (const [, ws] of clients) {
-        if (ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(frame));
-        }
-    }
-}
-// Agent Tree
-function buildAgentTree() {
-    const root = {};
-    for (const [id, agent] of agents) {
-        const node = {
-            id,
-            type: agent.type,
-            status: agent.status,
-            depth: agent.depth,
-            task: agent.task?.slice(0, 50),
-            tokens: agent.tokens,
-            children: agent.children,
-        };
-        if (agent.parentId) {
-            const parent = agents.get(agent.parentId);
-            if (parent) {
-                if (!parent.children.includes(id)) {
-                    parent.children.push(id);
-                }
-            }
-        }
-        else {
-            root[id] = node;
-        }
-    }
-    return root;
-}
-function getAgentTreeString() {
-    const lines = ["Agent Tree:"];
-    function printAgent(id, indent) {
-        const agent = agents.get(id);
-        if (!agent)
-            return;
-        const statusIcon = agent.status === "running" ? "◐" :
-            agent.status === "completed" ? "✓" :
-                agent.status === "error" ? "✗" : "○";
-        const typeLabel = agent.type === "orchestrator" ? "[orch]" :
-            agent.type === "worker" ? "[work]" : "[main]";
-        const task = agent.task ? ` - ${agent.task.slice(0, 30)}` : "";
-        const tokens = `(${agent.tokens.input}/${agent.tokens.output})`;
-        lines.push(`${indent}${statusIcon} ${typeLabel} ${id}${task} ${tokens}`);
-        for (const childId of agent.children) {
-            printAgent(childId, indent + "  ");
-        }
-    }
-    // Find root agents (depth 0)
-    for (const [id, agent] of agents) {
-        if (agent.depth === 0) {
-            printAgent(id, "");
-        }
-    }
-    return lines.join("\n");
-}
-// Detect capabilities from task description
-function detectCapabilities(task) {
-    const caps = ["chat"];
-    const t = task.toLowerCase();
-    if (t.includes("code") || t.includes("program") || t.includes("develop")) {
-        caps.push("coding", "shell", "file-ops");
-    }
-    if (t.includes("research") || t.includes("search") || t.includes("find")) {
-        caps.push("web-search", "analysis");
-    }
-    if (t.includes("write") || t.includes("create") || t.includes("generate")) {
-        caps.push("writing", "file-ops");
-    }
-    if (t.includes("debug") || t.includes("fix") || t.includes("error")) {
-        caps.push("debugging", "shell");
-    }
-    if (t.includes("test") || t.includes("validate")) {
-        caps.push("testing", "shell");
-    }
-    if (t.includes("refactor") || t.includes("improve")) {
-        caps.push("refactoring", "code-review");
-    }
-    return [...new Set(caps)];
-}
-// Spawn Agent
-async function spawnAgent(pi, params) {
-    const id = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-    const parent = params.parentId ? agents.get(params.parentId) : undefined;
-    const depth = parent ? parent.depth + 1 : 0;
-    const sessionKey = parent
-        ? `${parent.sessionKey}:subagent:${id}`
-        : `agent:main:${id}`;
-    // Determine agent type based on task and depth
-    let type = "worker";
-    if (depth === 0) {
-        type = "primary";
-    }
-    else if (params.maxWorkers && params.maxWorkers > 1) {
-        type = "orchestrator";
-    }
-    // Auto-detect capabilities from task
-    const capabilities = params.capabilities || detectCapabilities(params.task);
-    // Create workspace
-    const workspace = join(AGENTS_DIR, id, "workspace");
-    if (!existsSync(workspace)) {
-        mkdirSync(workspace, { recursive: true });
-    }
+    // Create agent with Draconic tracking
     const agent = {
-        id,
+        id: draconicRun.id,
         parentId: params.parentId,
-        sessionKey,
-        depth,
-        type,
-        capabilities,
-        status: "idle",
+        sessionKey: draconicRun.sessionKey,
+        depth: draconicRun.depth,
+        type: params.parentId ? "worker" : "primary",
+        capabilities: params.capabilities || ["general"],
+        status: "running",
         spawnedAt: new Date(),
         task: params.task,
-        model: params.model || "ollama/minimax-m2.5:cloud",
+        model: params.model || "default",
         children: [],
-        workspace,
-        tokens: { input: 0, output: 0 },
-        stats: { runtime: 0, toolCalls: 0 },
+        workspace: AGENTS_DIR,
+        tokens: { input: tokenEstimate.input.total, output: tokenEstimate.output.expected },
+        draconicRunId: draconicRun.id,
+        tokenEstimate,
     };
-    agents.set(id, agent);
-    // Add to parent's children
-    if (parent) {
-        parent.children.push(id);
+    agents.set(agent.id, agent);
+    // Track parent relationship
+    if (params.parentId) {
+        const parent = agents.get(params.parentId);
+        if (parent) {
+            parent.children.push(agent.id);
+        }
     }
-    // Emit spawn event
-    emit(pi, "agent.spawned", {
-        id,
-        parentId: params.parentId,
-        type,
-        depth,
-        task: params.task,
-        capabilities,
-    });
-    console.log(`[Agent] Spawned ${type} agent ${id} at depth ${depth}`);
-    console.log(getAgentTreeString());
-    return agent;
-}
-// Execute Agent Task
-async function executeAgent(pi, agent) {
-    agent.status = "running";
-    const startTime = Date.now();
-    emit(pi, "agent.status", {
-        id: agent.id,
-        status: "running",
-        task: agent.task,
-    });
-    // Simulate work
-    await new Promise(r => setTimeout(r, 2000 + Math.random() * 3000));
-    // Simulate token usage
-    agent.tokens.input += Math.floor(agent.task?.length || 10) * 2;
-    agent.tokens.output += Math.floor(Math.random() * 500) + 100;
-    agent.stats.runtime = Date.now() - startTime;
-    agent.stats.toolCalls = Math.floor(Math.random() * 5);
-    agent.status = "completed";
-    // Announce completion to parent
-    if (agent.parentId) {
-        await announceToParent(pi, agent);
+    // Create workspace if needed
+    const workspaceDir = join(AGENTS_DIR, agent.id);
+    if (!existsSync(workspaceDir)) {
+        mkdirSync(workspaceDir, { recursive: true });
     }
-    emit(pi, "agent.status", {
-        id: agent.id,
-        status: "completed",
-        tokens: agent.tokens,
+    // Broadcast event
+    broadcastEvent("agent.spawned", {
+        agentId: agent.id,
+        parentId: agent.parentId,
+        depth: agent.depth,
+        task: agent.task,
+        predictedTokens: tokenEstimate.input.total + tokenEstimate.output.expected,
     });
-}
-// Announce result to parent
-async function announceToParent(pi, agent) {
-    const parent = agents.get(agent.parentId);
-    if (!parent)
-        return;
-    const announce = {
-        source: "subagent",
-        childSessionKey: agent.sessionKey,
-        taskLabel: agent.task?.slice(0, 50),
-        status: agent.status === "completed" ? "success" : "error",
-        result: `Completed: ${agent.task}\n\nOutput: ${agent.tokens.output} tokens`,
-        tokens: agent.tokens,
-        stats: agent.stats,
-        sessionKey: agent.sessionKey,
+    return {
+        success: true,
+        agentId: agent.id,
+        prediction: tokenEstimate,
     };
-    emit(pi, "agent.announce", {
-        parentId: parent.id,
-        childId: agent.id,
-        ...announce,
-    });
-    console.log(`[Agent] ${agent.id} announced to parent ${parent.id}`);
-}
-// Spawn Swarm
-async function spawnSwarm(pi, parentId, task, count) {
-    const spawned = [];
-    console.log(`[Agent] Spawning swarm of ${count} workers for task: ${task.slice(0, 50)}`);
-    for (let i = 0; i < count; i++) {
-        const agent = await spawnAgent(pi, {
-            task: `${task} [worker ${i + 1}/${count}]`,
-            parentId,
-            label: `worker-${i + 1}`,
-            capabilities: detectCapabilities(task),
-        });
-        spawned.push(agent);
-        // Start execution
-        executeAgent(pi, agent);
-    }
-    return spawned;
 }
-// Check if another gateway instance is already running
-async function isGatewayRunning(port, hostname) {
+/**
+ * 🐉 Enhanced API call with connection pooling
+ */
+async function draconicAPICall(provider, model, endpoint, payload) {
     try {
-        const response = await fetch(`http://${hostname}:${port}/health`, {
-            signal: AbortSignal.timeout(1000)
+        // Acquire connection from pool
+        const slot = await draconicPool.acquire({ provider, model, host: getProviderHost(provider) });
+        // Make request through pooled connection
+        const response = await draconicPool.request(slot, endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
         });
-        return response.ok;
+        // Release connection
+        draconicPool.release(slot);
+        if (response.status >= 200 && response.status < 300) {
+            return { success: true, data: JSON.parse(response.body.toString()) };
+        }
+        else {
+            // 🐉 Classify error for retry strategy
+            const errorText = response.body.toString();
+            const strategy = draconicClassifier.classify(new Error(errorText), {
+                retryCount: 0,
+                consecutiveErrors: 0,
+                provider,
+            });
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${errorText}`,
+            };
+        }
     }
-    catch {
-        return false;
+    catch (error) {
+        return { success: false, error: String(error) };
     }
 }
-// Start Gateway Server
-async function startGateway(pi) {
-    if (server) {
-        console.log('[Gateway] Already running in this process');
-        return;
-    }
-    ensureDirectories();
-    // Get port and hostname from flags or use defaults
-    const preferredPort = Number(pi.getFlag('gateway-port')) || DEFAULT_GATEWAY_PORT;
-    const hostname = String(pi.getFlag('gateway-host') ?? '127.0.0.1');
-    // Check if another gateway is already running on the preferred port
-    if (await isGatewayRunning(preferredPort, hostname)) {
-        console.log(`[Gateway] Another gateway instance is already running on port ${preferredPort}. Skipping start.`);
-        GATEWAY_PORT = preferredPort;
+/**
+ * Get provider hostname
+ */
+function getProviderHost(provider) {
+    const hosts = {
+        anthropic: "api.anthropic.com",
+        openai: "api.openai.com",
+        ollama: "localhost",
+    };
+    return hosts[provider.toLowerCase()] || "localhost";
+}
+/**
+ * Enhanced gateway stats
+ */
+function getDraconicGatewayStats() {
+    const poolStats = draconicPool.getStats();
+    return {
+        running: isRunning,
+        port: GATEWAY_PORT,
+        agents: agents.size,
+        clients: clients.size,
+        poolConnections: poolStats.totalConnections,
+        poolHealth: Object.keys(poolStats.byHealth),
+        totalTokensPredicted: Array.from(agents.values()).reduce((sum, a) => sum + (a.tokenEstimate?.input.total || 0) + (a.tokenEstimate?.output.expected || 0), 0),
+        totalErrorsPrevented: 0, // Would track from classifier history
+    };
+}
+/**
+ * Start Gateway Server with Draconic enhancements
+ */
+async function startDraconicGateway(pi) {
+    if (isRunning) {
+        console.log("[🐉 Gateway] Already running");
         return;
     }
-    // Find an available port (only if preferred is not in use by a gateway)
-    try {
-        GATEWAY_PORT = await findAvailablePort(preferredPort, hostname);
-        if (GATEWAY_PORT !== preferredPort) {
-            console.log(`[Gateway] Using alternate port ${GATEWAY_PORT} (preferred ${preferredPort} was in use)`);
-        }
-    }
-    catch (err) {
-        console.error('[Gateway] Failed to find available port:', err instanceof Error ? err.message : String(err));
-        // @ts-ignore sendMessage type
-        // @ts-ignore sendMessage type
-        // @ts-ignore Content type
-        pi.sendMessage({
-            customType: 'gateway.error',
-            // @ts-ignore Content type
-            content: [{ type: 'text', text: 'Gateway failed to start: no available port' }],
-            // @ts-ignore Content type
-            display: { type: 'text', text: 'Gateway failed: no available port' },
-            details: { error: 'no_available_port' },
-        });
-        return;
+    // Initialize Draconic systems FIRST
+    initializeDraconicSystems();
+    // Ensure agents directory
+    if (!existsSync(AGENTS_DIR)) {
+        mkdirSync(AGENTS_DIR, { recursive: true });
     }
+    // Start Bun server
     server = Bun.serve({
         port: GATEWAY_PORT,
-        hostname,
+        hostname: "127.0.0.1",
         websocket: {
             open(ws) {
-                ws.data = { state: "pending", id: null };
+                const clientId = `client-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+                clients.set(clientId, ws);
+                console.log(`[🐉 Gateway] Client connected: ${clientId}`);
+                // Send welcome with Draconic capabilities
+                ws.send(JSON.stringify({
+                    type: "connected",
+                    clientId,
+                    features: {
+                        hierarchicalAgents: true,
+                        tokenPrediction: true,
+                        http2Pooling: true,
+                        errorPrediction: true,
+                    },
+                }));
+            },
+            close(ws, code, reason) {
+                // Find and remove client
+                for (const [id, clientWs] of clients.entries()) {
+                    if (clientWs === ws) {
+                        clients.delete(id);
+                        console.log(`[🐉 Gateway] Client disconnected: ${id}`);
+                        break;
+                    }
+                }
             },
             async message(ws, data) {
                 try {
-                    const frame = JSON.parse(data);
-                    const wsData = ws.data;
-                    // Handshake
-                    if (wsData.state === "pending") {
-                        if (frame.type !== "connect") {
-                            ws.close(1002, "Expected connect");
-                            return;
-                        }
-                        const connect = frame;
-                        const clientId = connect.params.device?.id || `client-${Date.now()}`;
-                        Object.assign(wsData, { state: "connected", id: clientId, ...connect.params });
-                        clients.set(clientId, ws);
-                        const res = {
-                            type: "res",
-                            id: frame.id,
-                            ok: true,
-                            payload: {
-                                clientId,
-                                agents: Array.from(agents.values()).map(a => ({
-                                    id: a.id,
-                                    type: a.type,
-                                    status: a.status,
-                                    depth: a.depth,
-                                })),
-                            },
-                        };
-                        ws.send(JSON.stringify(res));
-                        console.log(`[Gateway] Client connected: ${clientId}`);
-                        return;
-                    }
-                    // Handle requests
+                    const frame = JSON.parse(data.toString());
                     if (frame.type === "req") {
-                        const req = frame;
-                        let res;
-                        switch (req.method) {
+                        switch (frame.method) {
                             case "agent.spawn": {
-                                // @ts-ignore Type cast through unknown
-                                const { task, parentId, maxWorkers } = req.params;
-                                if (maxWorkers && maxWorkers > 1) {
-                                    // Spawn swarm
-                                    const swarm = await spawnSwarm(pi, parentId || "main", task, maxWorkers);
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: {
-                                            swarm: swarm.map(a => a.id),
-                                            count: swarm.length,
-                                            tree: getAgentTreeString(),
-                                        },
-                                    };
-                                }
-                                else {
-                                    // Spawn single agent
-                                    const agent = await spawnAgent(pi, { task, parentId: parentId || "main" });
-                                    executeAgent(pi, agent);
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: {
-                                            id: agent.id,
-                                            sessionKey: agent.sessionKey,
-                                            type: agent.type,
-                                            depth: agent.depth,
-                                            tree: getAgentTreeString(),
-                                        },
-                                    };
-                                }
-                                break;
-                            }
-                            case "agent.list": {
-                                const agentList = Array.from(agents.values()).map(a => ({
-                                    id: a.id,
-                                    parentId: a.parentId,
-                                    type: a.type,
-                                    status: a.status,
-                                    depth: a.depth,
-                                    task: a.task?.slice(0, 50),
-                                    tokens: a.tokens,
-                                    children: a.children.length,
-                                }));
-                                res = {
+                                const { task, parentId, label, capabilities, model } = frame.params;
+                                const result = await spawnDraconicAgent({ task, parentId, label, capabilities, model }, pi);
+                                ws.send(JSON.stringify({
                                     type: "res",
                                     id: frame.id,
-                                    ok: true,
-                                    payload: {
-                                        agents: agentList,
-                                        tree: getAgentTreeString(),
-                                        total: agents.size,
-                                    },
-                                };
+                                    ok: result.success,
+                                    payload: result.success
+                                        ? { agentId: result.agentId, prediction: result.prediction }
+                                        : undefined,
+                                    error: result.error,
+                                }));
                                 break;
                             }
                             case "agent.tree": {
-                                res = {
+                                // 🐉 Get hierarchical tree
+                                const tree = draconicRegistry.getTree();
+                                ws.send(JSON.stringify({
                                     type: "res",
                                     id: frame.id,
                                     ok: true,
-                                    payload: {
-                                        tree: getAgentTreeString(),
-                                    },
-                                };
+                                    payload: { tree },
+                                }));
                                 break;
                             }
-                            case "agent.kill": {
-                                const { id, cascade } = req.params;
-                                const agent = agents.get(id);
-                                if (agent) {
-                                    if (cascade && agent.children.length > 0) {
-                                        for (const childId of agent.children) {
-                                            agents.delete(childId);
+                            case "agent.status": {
+                                const { agentId } = frame.params;
+                                const agent = agents.get(agentId);
+                                const run = agent ? draconicRegistry.get(agent.draconicRunId || "") : null;
+                                const tree = agent ? draconicRegistry.getTree(agent.draconicRunId) : null;
+                                ws.send(JSON.stringify({
+                                    type: "res",
+                                    id: frame.id,
+                                    ok: !!agent,
+                                    payload: agent
+                                        ? {
+                                            agent,
+                                            run: run
+                                                ? {
+                                                    status: run.status,
+                                                    metrics: run.metrics,
+                                                }
+                                                : null,
+                                            tree: tree ? formatTreeForWebSocket(tree) : null,
                                         }
-                                    }
-                                    agents.delete(id);
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: { killed: id, cascade: cascade || false },
-                                    };
-                                }
-                                else {
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: false,
-                                        error: "Agent not found",
-                                    };
-                                }
+                                        : undefined,
+                                    error: agent ? undefined : "Agent not found",
+                                }));
                                 break;
                             }
-                            case "chat.send": {
-                                const { message, agentId } = req.params;
-                                // If message suggests spawning, auto-spawn
-                                if (message.toLowerCase().includes("spawn") || message.toLowerCase().includes("create agent")) {
-                                    const task = message.replace(/spawn|create agent/gi, "").trim();
-                                    const agent = await spawnAgent(pi, {
-                                        task: task || "assist with task",
-                                        parentId: agentId || "main"
-                                    });
-                                    executeAgent(pi, agent);
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: {
-                                            content: `Spawned ${agent.type} agent ${agent.id} to handle: ${agent.task}`,
-                                            agent: agent.id,
-                                            tree: getAgentTreeString(),
-                                        },
-                                    };
-                                }
-                                else if (message.toLowerCase().includes("swarm")) {
-                                    // Extract number from message like "spawn swarm of 5"
-                                    const match = message.match(/(\d+)/);
-                                    const count = match ? parseInt(match[1]) : 3;
-                                    const task = message.replace(/swarm|\d+/gi, "").trim();
-                                    const swarm = await spawnSwarm(pi, agentId || "main", task || "assist", count);
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: {
-                                            content: `Spawned swarm of ${swarm.length} workers`,
-                                            swarm: swarm.map(a => a.id),
-                                            tree: getAgentTreeString(),
-                                        },
-                                    };
-                                }
-                                else {
-                                    res = {
-                                        type: "res",
-                                        id: frame.id,
-                                        ok: true,
-                                        payload: {
-                                            content: `Echo: ${message}`,
-                                        },
-                                    };
-                                }
+                            case "gateway.stats": {
+                                const stats = getDraconicGatewayStats();
+                                ws.send(JSON.stringify({
+                                    type: "res",
+                                    id: frame.id,
+                                    ok: true,
+                                    payload: stats,
+                                }));
+                                break;
+                            }
+                            case "pool.status": {
+                                // 🐉 Connection pool status
+                                const poolStats = draconicPool.getStats();
+                                const connections = draconicPool.getConnections();
+                                ws.send(JSON.stringify({
+                                    type: "res",
+                                    id: frame.id,
+                                    ok: true,
+                                    payload: {
+                                        stats: poolStats,
+                                        connections: connections.map((c) => ({
+                                            id: c.id,
+                                            provider: c.provider,
+                                            health: c.health,
+                                            streams: c.streams,
+                                            latency: c.latency,
+                                        })),
+                                    },
+                                }));
                                 break;
                             }
                             default:
-                                res = {
+                                ws.send(JSON.stringify({
                                     type: "res",
                                     id: frame.id,
                                     ok: false,
-                                    error: `Unknown method: ${req.method}`,
-                                };
+                                    error: `Unknown method: ${frame.method}`,
+                                }));
                         }
-                        ws.send(JSON.stringify(res));
                     }
                 }
-                catch (err) {
+                catch (error) {
+                    console.error("[🐉 Gateway] Message error:", error);
                     ws.send(JSON.stringify({
                         type: "error",
-                        error: err instanceof Error ? err.message : String(err),
+                        error: String(error),
                     }));
                 }
             },
-            close(ws) {
-                const wsData = ws.data;
-                if (wsData.id) {
-                    clients.delete(wsData.id);
-                    console.log(`[Gateway] Client disconnected: ${wsData.id}`);
-                }
-            },
         },
-        fetch(req, server) {
+        fetch(req) {
             const url = new URL(req.url);
             if (url.pathname === "/health") {
+                return Response.json(getDraconicGatewayStats());
+            }
+            if (url.pathname === "/metrics") {
+                // 🐉 Detailed metrics endpoint
+                const stats = getDraconicGatewayStats();
+                const poolStats = draconicPool.getStats();
                 return Response.json({
-                    status: "ok",
-                    agents: agents.size,
-                    clients: clients.size,
+                    gateway: stats,
+                    pool: poolStats,
+                    agents: {
+                        total: agents.size,
+                        byStatus: Object.fromEntries(Array.from(agents.values()).reduce((acc, a) => {
+                            acc.set(a.status, (acc.get(a.status) || 0) + 1);
+                            return acc;
+                        }, new Map())),
+                    },
                 });
             }
-            // Upgrade WebSocket connections
-            // @ts-ignore Bun Server upgrade signature
-            if (server.upgrade(req)) {
-                return; // Return undefined to accept the WebSocket upgrade
+            // @ts-ignore Bun upgrade
+            if (server?.upgrade(req)) {
+                return;
             }
-            return new Response("0xKobold Gateway - WebSocket on port 18789", { status: 200 });
+            return new Response("🐉 0xKobold Draconic Gateway - WebSocket on port 18789", { status: 200 });
         },
     });
     isRunning = true;
-    console.log(`[Gateway] Multi-Agent Gateway listening on ws://127.0.0.1:${GATEWAY_PORT}`);
-    console.log(`[Gateway] Agents directory: ${AGENTS_DIR}`);
-    // @ts-ignore sendMessage type
-    // @ts-ignore sendMessage type
-    // @ts-ignore Content type
+    console.log(`[🐉 Gateway] RUNNING on ws://127.0.0.1:${GATEWAY_PORT}`);
+    console.log(`[🐉 Gateway] Features: HTTP/2 pooling, token prediction, hierarchical tracking`);
     pi.sendMessage({
-        customType: 'gateway.started',
-        content: [{ type: 'text', text: `Gateway started on port ${GATEWAY_PORT}` }],
-        // @ts-ignore Content type
-        display: { type: 'text', text: `Gateway started on port ${GATEWAY_PORT}` },
-        details: { port: GATEWAY_PORT, url: `ws://127.0.0.1:${GATEWAY_PORT}`, agents: agents.size, clients: clients.size },
+        customType: "gateway.started",
+        content: [{ type: "text", text: `🐉 Draconic Gateway on port ${GATEWAY_PORT}` }],
+        display: true,
+        details: { port: GATEWAY_PORT, url: `ws://127.0.0.1:${GATEWAY_PORT}` },
     });
 }
-// Stop Gateway Server
-async function stopGateway(pi) {
+/**
+ * Format tree for WebSocket transmission
+ */
+function formatTreeForWebSocket(node) {
+    return {
+        id: node.id,
+        name: node.name,
+        type: node.type,
+        status: node.status,
+        depth: node.depth,
+        metrics: node.metrics,
+        children: node.children.map(formatTreeForWebSocket),
+    };
+}
+/**
+ * Broadcast event to all clients
+ */
+function broadcastEvent(event, payload) {
+    eventSeq++;
+    const message = JSON.stringify({
+        type: "event",
+        event,
+        payload,
+        seq: eventSeq,
+    });
+    for (const [, ws] of clients.entries()) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(message);
+        }
+    }
+}
+/**
+ * Stop Gateway
+ */
+async function stopDraconicGateway(pi) {
     if (!server) {
-        console.log('[Gateway] Not running');
+        console.log("[🐉 Gateway] Not running");
         return;
     }
-    // Close all client connections
-    for (const [, ws] of clients) {
+    // Destroy connection pool
+    await draconicPool.destroy();
+    // Close clients
+    for (const [, ws] of clients.entries()) {
         if (ws.readyState === WebSocket.OPEN) {
             ws.close(1000, "Gateway shutting down");
         }
     }
     clients.clear();
-    // Stop the server
     server.stop();
     server = null;
     isRunning = false;
-    console.log('[Gateway] Server stopped');
-    // @ts-ignore sendMessage type
-    // @ts-ignore sendMessage type
-    // @ts-ignore Content type
+    console.log("[🐉 Gateway] Stopped");
     pi.sendMessage({
-        customType: 'gateway.stopped',
-        content: [{ type: 'text', text: 'Gateway stopped' }],
-        // @ts-ignore Content type
-        display: { type: 'text', text: 'Gateway stopped' },
+        customType: "gateway.stopped",
+        content: [{ type: "text", text: "🐉 Gateway stopped" }],
+        display: true,
         details: {},
     });
 }
-// Get gateway status
-function getStatus() {
-    return {
-        running: isRunning,
-        port: GATEWAY_PORT,
-        agents: agents.size,
-        clients: clients.size,
-    };
-}
-// Main Extension Export
-export default function gatewayExtension(pi) {
-    // Register CLI flags for gateway configuration
-    pi.registerFlag('gateway-port', {
-        description: 'Port for the WebSocket gateway server',
-        type: 'string',
-        default: String(DEFAULT_GATEWAY_PORT),
-    });
-    pi.registerFlag('gateway-host', {
-        description: 'Hostname for the WebSocket gateway server',
-        type: 'string',
-        default: '127.0.0.1',
-    });
-    // Register gateway_broadcast tool
-    pi.registerTool({
-        name: 'gateway_broadcast',
-        description: 'Broadcast a message to all connected gateway clients',
-        // @ts-ignore TSchema mismatch
-        parameters: {
-            type: 'object',
-            properties: {
-                event: { type: 'string', description: 'Event name' },
-                payload: { type: 'object', description: 'Event payload' },
-            },
-            required: ['event', 'payload'],
-        },
-        async execute(args) {
-            const { event, payload } = args;
-            if (!isRunning) {
-                return {
-                    content: [{ type: 'text', text: 'Gateway not running' }],
-                    details: { error: 'not_running' },
-                };
-            }
-            emit(pi, event, payload);
-            return {
-                content: [{ type: 'text', text: `Broadcasted event "${event}" to ${clients.size} clients` }],
-                details: { clients: clients.size },
-            };
+// Main Export
+export default function draconicGatewayExtension(pi) {
+    // Register commands
+    pi.registerCommand("gateway:start", {
+        description: "Start Draconic Gateway with HTTP/2 pooling",
+        handler: async (_args, ctx) => {
+            await startDraconicGateway(ctx.extension);
         },
     });
-    // Register gateway:start command
-    pi.registerCommand('gateway:start', {
-        description: 'Start the WebSocket gateway server',
-        async handler() {
-            await startGateway(pi);
+    pi.registerCommand("gateway:stop", {
+        description: "Stop Draconic Gateway",
+        handler: async (_args, ctx) => {
+            await stopDraconicGateway(ctx.extension);
         },
     });
-    // Register gateway:stop command
-    pi.registerCommand('gateway:stop', {
-        description: 'Stop the WebSocket gateway server',
-        async handler() {
-            await stopGateway(pi);
+    pi.registerCommand("gateway:status", {
+        description: "Show Draconic Gateway status with pool metrics",
+        handler: async (_args, ctx) => {
+            const stats = getDraconicGatewayStats();
+            ctx.ui.notify(`🐉 Gateway: ${stats.running ? "RUNNING" : "STOPPED"}\n` +
+                `Agents: ${stats.agents} | Clients: ${stats.clients}\n` +
+                `Pool: ${stats.poolConnections} connections`, stats.running ? "info" : "warning");
         },
     });
-    // Register gateway:status command
-    pi.registerCommand('gateway:status', {
-        description: 'Get gateway server status',
-        async handler() {
-            const status = getStatus();
-            // @ts-ignore sendMessage type
-            // @ts-ignore sendMessage type
-            // @ts-ignore Content type
-            pi.sendMessage({
-                customType: 'gateway.status',
-                content: [{ type: 'text', text: `Gateway status: ${JSON.stringify(status)}` }],
-                // @ts-ignore Content type
-                display: { type: 'text', text: `Gateway: ${status.running ? '🟢' : '🔴'} ${status.agents} agents, ${status.clients} clients` },
-                details: status,
-            });
-            console.log('[Gateway] Status:', status);
+    pi.registerCommand("gateway:pool", {
+        description: "Show connection pool status",
+        handler: async (_args, ctx) => {
+            const stats = draconicPool.getStats();
+            ctx.ui.notify(`🌊 Connection Pool:\n` +
+                `Connections: ${stats.totalConnections}\n` +
+                `Active streams: ${stats.activeStreams}\n` +
+                `Avg latency: ${stats.averageLatency.toFixed(0)}ms\n` +
+                `Error rate: ${(stats.errorRate * 100).toFixed(1)}%`, "info");
         },
     });
-    // Cleanup on shutdown
-    // @ts-ignore Event type
-    pi.on('shutdown', async () => {
-        await stopGateway(pi);
+    // Tools
+    pi.registerTool({
+        name: "draconic_gateway_spawn",
+        label: "🐉 Spawn Draconic Agent",
+        description: "Spawn agent with token prediction",
+        parameters: Type.Object({
+            task: Type.String(),
+            parentId: Type.Optional(Type.String()),
+            model: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            const result = await spawnDraconicAgent(params, pi);
+            return {
+                content: [{ type: "text", text: result.success ? `🐉 Spawned: ${result.agentId}` : `❌ Failed: ${result.error}` }],
+                details: result,
+            };
+        },
     });
-    // Auto-start gateway when session starts (runtime is ready)
-    // Only start in the main process, NOT in subagent sessions
-    pi.on('session_start', async () => {
-        // Skip if already attempted (prevents duplicate starts in subagents)
-        if (hasAttemptedStart) {
-            console.log('[Gateway] Gateway already started or attempted, skipping...');
-            return;
-        }
-        hasAttemptedStart = true;
-        // Check if we're in a subagent by looking for parent session indicator
-        const isSubagent = process.env.KOBOLD_SUBAGENT === 'true' || process.env.PI_SESSION_PARENT;
-        if (isSubagent) {
-            console.log('[Gateway] Running in subagent, skipping gateway auto-start');
-            return;
-        }
-        // Skip if this isn't the main TUI process
-        const args = process.argv.slice(2);
-        const hasCommandFlag = args.includes('--command') || args.includes('-c');
-        if (hasCommandFlag) {
-            console.log('[Gateway] Running with --command flag, skipping gateway auto-start');
-            return;
-        }
-        console.log('[Gateway] Session started. Auto-starting gateway...');
-        await startGateway(pi);
+    pi.registerTool({
+        name: "draconic_gateway_stats",
+        label: "🐉 Gateway Stats",
+        description: "Get Draconic gateway statistics",
+        parameters: Type.Object({}),
+        async execute() {
+            const stats = getDraconicGatewayStats();
+            return {
+                content: [{
+                        type: "text",
+                        text: `🐉 Gateway Stats:\nRunning: ${stats.running}\nAgents: ${stats.agents}\nPool: ${stats.poolConnections}\nTokens predicted: ${stats.totalTokensPredicted}`,
+                    }],
+                details: stats,
+            };
+        },
     });
-    console.log('[Gateway] Extension loaded. Waiting for session start...');
+    console.log("[🐉 DraconicGateway] Extension loaded");
+    console.log("  Commands: /gateway:start, /gateway:stop, /gateway:status, /gateway:pool");
+    console.log("  Tools: draconic_gateway_spawn, draconic_gateway_stats");
 }
 //# sourceMappingURL=gateway-extension.js.map