whale-code 6.5.5 → 6.5.6

package/dist/cli/serve-mode.js

@@ -20,9 +20,10 @@
  *   subagent_start, subagent_progress, subagent_done, subagent_tool_start, subagent_tool_end,
  *   team_start, team_progress, team_task, team_done
  */
+
 import { createServer } from "http";
 import { WebSocketServer, WebSocket } from "ws";
-import { runAgentLoop, setModel, setPermissionMode, resetSessionState, getModel, estimateCostUsd, AgentEventEmitter, } from "./services/agent-loop.js";
+import { runAgentLoop, setModel, setPermissionMode, resetSessionState, getModel, estimateCostUsd, AgentEventEmitter } from "./services/agent-loop.js";
 import { resolveConfig } from "./services/config-store.js";
 import { createClient } from "@supabase/supabase-js";
 import { getValidToken, createAuthenticatedClient } from "./services/auth-service.js";
@@ -31,606 +32,690 @@ import { LOCAL_TOOL_DEFINITIONS } from "./services/local-tools.js";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const PKG_VERSION = require("../../package.json").version;
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
 // ============================================================================
 // SUPABASE CLIENT (for conversation persistence)
 // ============================================================================
+
 let supabase = null;
 let supabaseCreatedAt = 0;
 const SUPABASE_TTL_MS = 45 * 60 * 1000; // Refresh client every 45 min (JWT expires ~60 min)
+
 async function getSupabase() {
-    const now = Date.now();
-    // Return cached client if still fresh
-    if (supabase && (now - supabaseCreatedAt) < SUPABASE_TTL_MS)
-        return supabase;
-    // Invalidate stale client
-    supabase = null;
-    const config = resolveConfig();
-    // Tier 1: Service role key (never expires)
-    if (config.supabaseUrl && config.supabaseKey && process.env.SUPABASE_SERVICE_ROLE_KEY) {
-        supabase = createClient(config.supabaseUrl, config.supabaseKey, {
-            auth: { autoRefreshToken: false, persistSession: false },
-        });
-        supabaseCreatedAt = now;
-        return supabase;
-    }
-    // Tier 2: User JWT — always get a fresh token
-    try {
-        const token = await getValidToken();
-        if (token) {
-            supabase = createAuthenticatedClient(token);
-            supabaseCreatedAt = now;
-            return supabase;
-        }
-    }
-    catch {
-        // Fall through
+  const now = Date.now();
+
+  // Return cached client if still fresh
+  if (supabase && now - supabaseCreatedAt < SUPABASE_TTL_MS) return supabase;
+
+  // Invalidate stale client
+  supabase = null;
+  const config = resolveConfig();
+
+  // Tier 1: Service role key (never expires)
+  if (config.supabaseUrl && config.supabaseKey && process.env.SUPABASE_SERVICE_ROLE_KEY) {
+    supabase = createClient(config.supabaseUrl, config.supabaseKey, {
+      auth: {
+        autoRefreshToken: false,
+        persistSession: false
+      }
+    });
+    supabaseCreatedAt = now;
+    return supabase;
+  }
+
+  // Tier 2: User JWT — always get a fresh token
+  try {
+    const token = await getValidToken();
+    if (token) {
+      supabase = createAuthenticatedClient(token);
+      supabaseCreatedAt = now;
+      return supabase;
     }
-    return null;
+  } catch {
+    // Fall through
+  }
+  return null;
 }
+
 // ============================================================================
 // CONVERSATION PERSISTENCE
 // ============================================================================
+
 async function createConversation(storeId, title, agentName) {
-    const db = await getSupabase();
-    if (!db)
-        return null;
-    try {
-        const { data, error } = await db
-            .from("ai_conversations")
-            .insert({
-            store_id: storeId || null,
-            title: title.substring(0, 100),
-            metadata: {
-                source: "whale-serve",
-                agentName: agentName || "whale",
-            },
-            status: "active",
-        })
-            .select("id")
-            .single();
-        if (error) {
-            console.error("[serve] Failed to create conversation:", error.message);
-            return null;
-        }
-        return data?.id || null;
-    }
-    catch (err) {
-        console.error("[serve] Conversation create error:", err);
-        return null;
+  const db = await getSupabase();
+  if (!db) return null;
+  try {
+    const {
+      data,
+      error
+    } = await db.from("ai_conversations").insert({
+      store_id: storeId || null,
+      title: title.substring(0, 100),
+      metadata: {
+        source: "whale-serve",
+        agentName: agentName || "whale"
+      },
+      status: "active"
+    }).select("id").single();
+    if (error) {
+      console.error("[serve] Failed to create conversation:", error.message);
+      return null;
     }
+    return data?.id || null;
+  } catch (err) {
+    console.error("[serve] Conversation create error:", err);
+    return null;
+  }
 }
 async function appendMessage(conversationId, role, content, tokenCount, toolNames) {
-    const db = await getSupabase();
-    if (!db || !conversationId)
-        return;
-    try {
-        // Insert into ai_messages for individual message tracking
-        await db.from("ai_messages").insert({
-            conversation_id: conversationId,
-            role,
-            content: [{ type: "text", text: content }],
-            is_tool_use: (toolNames && toolNames.length > 0) || false,
-            tool_names: toolNames || [],
-            token_count: tokenCount || 0,
-        });
-    }
-    catch {
-        // Non-fatal — persistence is best-effort
-    }
+  const db = await getSupabase();
+  if (!db || !conversationId) return;
+  try {
+    // Insert into ai_messages for individual message tracking
+    await db.from("ai_messages").insert({
+      conversation_id: conversationId,
+      role,
+      content: [{
+        type: "text",
+        text: content
+      }],
+      is_tool_use: toolNames && toolNames.length > 0 || false,
+      tool_names: toolNames || [],
+      token_count: tokenCount || 0
+    });
+  } catch {
+    // Non-fatal — persistence is best-effort
+  }
 }
 async function updateConversationMetadata(conversationId, metadata) {
-    const db = await getSupabase();
-    if (!db || !conversationId)
-        return;
-    try {
-        // Fetch current metadata, merge, and update
-        const { data } = await db
-            .from("ai_conversations")
-            .select("metadata")
-            .eq("id", conversationId)
-            .single();
-        const existing = data?.metadata || {};
-        await db
-            .from("ai_conversations")
-            .update({ metadata: { ...existing, ...metadata }, updated_at: new Date().toISOString() })
-            .eq("id", conversationId);
-    }
-    catch {
-        // Non-fatal
-    }
+  const db = await getSupabase();
+  if (!db || !conversationId) return;
+  try {
+    // Fetch current metadata, merge, and update
+    const {
+      data
+    } = await db.from("ai_conversations").select("metadata").eq("id", conversationId).single();
+    const existing = data?.metadata || {};
+    await db.from("ai_conversations").update({
+      metadata: {
+        ...existing,
+        ...metadata
+      },
+      updated_at: new Date().toISOString()
+    }).eq("id", conversationId);
+  } catch {
+    // Non-fatal
+  }
 }
 async function loadConversation(conversationId) {
-    const db = await getSupabase();
-    if (!db)
-        return null;
-    try {
-        const { data, error } = await db
-            .from("ai_conversations")
-            .select("id, title, messages")
-            .eq("id", conversationId)
-            .single();
-        if (error || !data)
-            return null;
-        return {
-            id: data.id,
-            title: data.title || "Untitled",
-            messages: data.messages || [],
-        };
-    }
-    catch {
-        return null;
-    }
+  const db = await getSupabase();
+  if (!db) return null;
+  try {
+    const {
+      data,
+      error
+    } = await db.from("ai_conversations").select("id, title, messages").eq("id", conversationId).single();
+    if (error || !data) return null;
+    return {
+      id: data.id,
+      title: data.title || "Untitled",
+      messages: data.messages || []
+    };
+  } catch {
+    return null;
+  }
 }
 async function listConversations(storeId, limit = 20) {
-    const db = await getSupabase();
-    if (!db)
-        return [];
-    try {
-        const { data, error } = await db
-            .from("ai_conversations")
-            .select("id, title, agent_id, metadata, turn_count, created_at, updated_at")
-            .eq("store_id", storeId)
-            .order("updated_at", { ascending: false })
-            .limit(limit);
-        if (error || !data)
-            return [];
-        return data.map((c) => ({
-            id: c.id,
-            title: c.title || "Untitled",
-            agentId: c.agent_id || null,
-            agentName: c.metadata?.agentName || null,
-            messageCount: c.turn_count || 0,
-            createdAt: c.created_at,
-            updatedAt: c.updated_at,
-        }));
-    }
-    catch {
-        return [];
-    }
+  const db = await getSupabase();
+  if (!db) return [];
+  try {
+    const {
+      data,
+      error
+    } = await db.from("ai_conversations").select("id, title, agent_id, metadata, turn_count, created_at, updated_at").eq("store_id", storeId).order("updated_at", {
+      ascending: false
+    }).limit(limit);
+    if (error || !data) return [];
+    return data.map(c => ({
+      id: c.id,
+      title: c.title || "Untitled",
+      agentId: c.agent_id || null,
+      agentName: c.metadata?.agentName || null,
+      messageCount: c.turn_count || 0,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at
+    }));
+  } catch {
+    return [];
+  }
 }
+
 // ============================================================================
 // TOOL LIST (for ready/tools messages)
 // ============================================================================
+
 async function getToolList() {
-    const tools = [];
-    // Local tools
-    for (const t of LOCAL_TOOL_DEFINITIONS) {
+  const tools = [];
+
+  // Local tools
+  for (const t of LOCAL_TOOL_DEFINITIONS) {
+    tools.push({
+      id: `local-${t.name}`,
+      name: t.name,
+      description: t.description,
+      category: "local"
+    });
+  }
+
+  // Server tools
+  try {
+    const serverTools = await loadServerToolDefinitions();
+    for (const t of serverTools) {
+      if (!tools.some(existing => existing.name === t.name)) {
         tools.push({
-            id: `local-${t.name}`,
-            name: t.name,
-            description: t.description,
-            category: "local",
+          id: `server-${t.name}`,
+          name: t.name,
+          description: t.description || "",
+          category: "server"
         });
+      }
     }
-    // Server tools
-    try {
-        const serverTools = await loadServerToolDefinitions();
-        for (const t of serverTools) {
-            if (!tools.some((existing) => existing.name === t.name)) {
-                tools.push({
-                    id: `server-${t.name}`,
-                    name: t.name,
-                    description: t.description || "",
-                    category: "server",
-                });
-            }
-        }
-    }
-    catch {
-        // Server tools unavailable — local-only mode
-    }
-    return tools;
+  } catch {
+    // Server tools unavailable — local-only mode
+  }
+  return tools;
 }
+
 // ============================================================================
 // WEBSOCKET MESSAGE HELPERS
 // ============================================================================
+
 function send(ws, message) {
-    if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify(message));
-    }
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(message));
+  }
 }
 function sendDebug(ws, level, message, data) {
-    send(ws, { type: "debug", level, message, data });
+  send(ws, {
+    type: "debug",
+    level,
+    message,
+    data
+  });
 }
+
 // ============================================================================
 // QUERY HANDLER — runs the full agent loop
 // ============================================================================
+
 async function handleQuery(session, msg, opts) {
-    const { ws } = session;
-    const prompt = msg.prompt;
-    if (!prompt) {
-        send(ws, { type: "error", error: "Missing 'prompt' field" });
-        return;
-    }
-    // Extract image attachments sent by WhaleChat
-    const rawAttachments = msg.attachments || [];
-    const images = rawAttachments
-        .filter(att => att.type === "image" && att.media_type && att.data)
-        .map(att => ({ base64: att.data, mediaType: att.media_type }));
-    const storeId = msg.storeId || resolveConfig().storeId || null;
-    const config = msg.config || {};
-    const requestedConvId = msg.conversationId || session.conversationId;
-    // Restore conversation history from client if session is fresh (new WS connection)
-    const clientHistory = msg.conversationHistory;
-    if (session.conversationHistory.length === 0 && clientHistory && clientHistory.length > 0) {
-        session.conversationHistory = clientHistory
-            .filter((m) => m.content && m.content.trim().length > 0)
-            .map((m) => ({
-            role: m.role,
-            content: m.content,
-        }));
-    }
-    // Apply model from config or server defaults
-    const model = config.model || opts.model;
-    if (model)
-        setModel(model);
-    // Create or continue conversation
-    let conversationId = requestedConvId;
-    if (!conversationId) {
-        conversationId = await createConversation(storeId, prompt, config.agentName);
-        if (conversationId) {
-            send(ws, {
-                type: "conversation_created",
-                conversation: {
-                    id: conversationId,
-                    title: prompt.substring(0, 100),
-                    agentId: config.agentId || null,
-                    agentName: config.agentName || "whale",
-                    messageCount: 0,
-                    createdAt: new Date().toISOString(),
-                    updatedAt: new Date().toISOString(),
-                },
-            });
-        }
-    }
-    session.conversationId = conversationId;
-    // Persist user message
-    if (conversationId) {
-        appendMessage(conversationId, "user", prompt);
-    }
-    // Signal started
+  const {
+    ws
+  } = session;
+  const prompt = msg.prompt;
+  if (!prompt) {
     send(ws, {
-        type: "started",
-        model: getModel(),
-        conversationId,
+      type: "error",
+      error: "Missing 'prompt' field"
     });
-    // Set up abort controller
-    const abortController = new AbortController();
-    session.abortController = abortController;
-    let totalIn = 0;
-    let totalOut = 0;
-    let lastCostUsd = 0;
-    let fullText = "";
-    const toolsUsed = [];
-    const startTime = Date.now();
-    // Create event emitter for subagent/team events → forward to WebSocket
-    const emitter = new AgentEventEmitter();
-    const forwardTypes = new Set([
-        "subagent_start", "subagent_progress", "subagent_done",
-        "subagent_tool_start", "subagent_tool_end",
-        "team_start", "team_progress", "team_task", "team_done",
-    ]);
-    const eventHandler = (event) => {
-        if (event.type === "text") {
-            // Emitter captures text events — forward them to WebSocket + accumulate
-            const text = event.text;
-            if (text) {
-                fullText += text;
-                send(ws, { type: "text", text });
-            }
-        }
-        else if (forwardTypes.has(event.type)) {
-            send(ws, event);
-        }
-    };
-    emitter.on("event", eventHandler);
-    try {
-        const callbacks = {
-            onText: (text) => {
-                fullText += text;
-                send(ws, { type: "text", text });
-            },
-            onToolStart: (name, input) => {
-                if (!toolsUsed.includes(name))
-                    toolsUsed.push(name);
-                send(ws, { type: "tool_start", tool: name, input: input || {} });
-            },
-            onToolResult: (name, success, result, _input, durationMs) => {
-                // Truncate large results for the wire
-                let wireResult = result;
-                if (typeof result === "string" && result.length > 10000) {
-                    wireResult = result.substring(0, 10000) + "\n... (truncated)";
-                }
-                send(ws, {
-                    type: "tool_result",
-                    tool: name,
-                    success,
-                    result: wireResult,
-                    error: success ? undefined : (typeof result === "string" ? result : "Tool failed"),
-                    duration_ms: durationMs,
-                });
-            },
-            onUsage: (input_tokens, output_tokens, _thinking_tokens, _model, costUsd) => {
-                totalIn += input_tokens;
-                totalOut += output_tokens;
-                if (costUsd != null)
-                    lastCostUsd = costUsd;
-            },
-            onDone: (finalMessages) => {
-                session.conversationHistory = finalMessages;
-            },
-            onError: (error) => {
-                send(ws, { type: "error", error });
-            },
-            onAutoCompact: (before, after, tokensSaved) => {
-                sendDebug(ws, "info", `Context compacted: ${before} → ${after} messages (saved ~${tokensSaved} tokens)`);
-            },
-        };
-        const loopOpts = {
-            message: prompt,
-            images: images.length > 0 ? images : undefined,
-            conversationHistory: session.conversationHistory,
-            callbacks,
-            abortSignal: abortController.signal,
-            emitter,
-            maxTurns: config.maxTurns || opts.maxTurns,
-            maxBudgetUsd: opts.maxBudgetUsd,
-            effort: (opts.effort || "medium"),
-            allowedTools: config.enabledTools || opts.allowedTools,
-            disallowedTools: opts.disallowedTools,
-            fallbackModel: opts.fallbackModel,
-        };
-        await runAgentLoop(loopOpts);
-        // Calculate cost
-        session.totalInputTokens += totalIn;
-        session.totalOutputTokens += totalOut;
-        const totalCost = lastCostUsd || estimateCostUsd(session.totalInputTokens, session.totalOutputTokens);
-        const durationMs = Date.now() - startTime;
-        // Persist assistant response
-        if (conversationId && fullText) {
-            appendMessage(conversationId, "assistant", fullText, totalOut, toolsUsed);
-        }
-        // Update conversation metadata
-        if (conversationId) {
-            updateConversationMetadata(conversationId, {
-                lastTurnTokens: { input: totalIn, output: totalOut },
-                lastToolCalls: toolsUsed,
-                lastDurationMs: durationMs,
-                model: getModel(),
-            });
+    return;
+  }
+
+  // Extract image attachments sent by WhaleChat
+  const rawAttachments = msg.attachments || [];
+  const images = rawAttachments.filter(att => att.type === "image" && att.media_type && att.data).map(att => ({
+    base64: att.data,
+    mediaType: att.media_type
+  }));
+  const storeId = msg.storeId || resolveConfig().storeId || null;
+  const config = msg.config || {};
+  const requestedConvId = msg.conversationId || session.conversationId;
+
+  // Restore conversation history from client if session is fresh (new WS connection)
+  const clientHistory = msg.conversationHistory;
+  if (session.conversationHistory.length === 0 && clientHistory && clientHistory.length > 0) {
+    session.conversationHistory = clientHistory.filter(m => m.content && m.content.trim().length > 0).map(m => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+
+  // Apply model from config or server defaults
+  const model = config.model || opts.model;
+  if (model) setModel(model);
+
+  // Create or continue conversation
+  let conversationId = requestedConvId;
+  if (!conversationId) {
+    conversationId = await createConversation(storeId, prompt, config.agentName);
+    if (conversationId) {
+      send(ws, {
+        type: "conversation_created",
+        conversation: {
+          id: conversationId,
+          title: prompt.substring(0, 100),
+          agentId: config.agentId || null,
+          agentName: config.agentName || "whale",
+          messageCount: 0,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
         }
-        // Send done
+      });
+    }
+  }
+  session.conversationId = conversationId;
+
+  // Persist user message
+  if (conversationId) {
+    appendMessage(conversationId, "user", prompt);
+  }
+
+  // Signal started
+  send(ws, {
+    type: "started",
+    model: getModel(),
+    conversationId
+  });
+
+  // Set up abort controller
+  const abortController = new AbortController();
+  session.abortController = abortController;
+  let totalIn = 0;
+  let totalOut = 0;
+  let lastCostUsd = 0;
+  let fullText = "";
+  const toolsUsed = [];
+  const startTime = Date.now();
+
+  // Create event emitter for subagent/team events → forward to WebSocket
+  const emitter = new AgentEventEmitter();
+  const forwardTypes = new Set(["subagent_start", "subagent_progress", "subagent_done", "subagent_tool_start", "subagent_tool_end", "team_start", "team_progress", "team_task", "team_done"]);
+  const eventHandler = event => {
+    if (event.type === "text") {
+      // Emitter captures text events — forward them to WebSocket + accumulate
+      const text = event.text;
+      if (text) {
+        fullText += text;
         send(ws, {
-            type: "done",
-            status: "complete",
-            conversationId: conversationId || "",
-            usage: {
-                inputTokens: session.totalInputTokens,
-                outputTokens: session.totalOutputTokens,
-                totalCost,
-            },
+          type: "text",
+          text
         });
+      }
+    } else if (forwardTypes.has(event.type)) {
+      send(ws, event);
     }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        if (abortController.signal.aborted) {
-            send(ws, { type: "aborted" });
-        }
-        else {
-            send(ws, { type: "error", error: errorMsg });
+  };
+  emitter.on("event", eventHandler);
+  try {
+    const callbacks = {
+      onText: text => {
+        fullText += text;
+        send(ws, {
+          type: "text",
+          text
+        });
+      },
+      onToolStart: (name, input) => {
+        if (!toolsUsed.includes(name)) toolsUsed.push(name);
+        send(ws, {
+          type: "tool_start",
+          tool: name,
+          input: input || {}
+        });
+      },
+      onToolResult: (name, success, result, _input, durationMs) => {
+        // Truncate large results for the wire
+        let wireResult = result;
+        if (typeof result === "string" && result.length > 10000) {
+          wireResult = result.substring(0, 10000) + "\n... (truncated)";
         }
+        send(ws, {
+          type: "tool_result",
+          tool: name,
+          success,
+          result: wireResult,
+          error: success ? undefined : typeof result === "string" ? result : "Tool failed",
+          duration_ms: durationMs
+        });
+      },
+      onUsage: (input_tokens, output_tokens, _thinking_tokens, _model, costUsd) => {
+        totalIn += input_tokens;
+        totalOut += output_tokens;
+        if (costUsd != null) lastCostUsd = costUsd;
+      },
+      onDone: finalMessages => {
+        session.conversationHistory = finalMessages;
+      },
+      onError: error => {
+        send(ws, {
+          type: "error",
+          error
+        });
+      },
+      onAutoCompact: (before, after, tokensSaved) => {
+        sendDebug(ws, "info", `Context compacted: ${before} → ${after} messages (saved ~${tokensSaved} tokens)`);
+      }
+    };
+    const loopOpts = {
+      message: prompt,
+      images: images.length > 0 ? images : undefined,
+      conversationHistory: session.conversationHistory,
+      callbacks,
+      abortSignal: abortController.signal,
+      emitter,
+      maxTurns: config.maxTurns || opts.maxTurns,
+      maxBudgetUsd: opts.maxBudgetUsd,
+      effort: opts.effort || "medium",
+      allowedTools: config.enabledTools || opts.allowedTools,
+      disallowedTools: opts.disallowedTools,
+      fallbackModel: opts.fallbackModel
+    };
+    await runAgentLoop(loopOpts);
+
+    // Calculate cost
+    session.totalInputTokens += totalIn;
+    session.totalOutputTokens += totalOut;
+    const totalCost = lastCostUsd || estimateCostUsd(session.totalInputTokens, session.totalOutputTokens);
+    const durationMs = Date.now() - startTime;
+
+    // Persist assistant response
+    if (conversationId && fullText) {
+      appendMessage(conversationId, "assistant", fullText, totalOut, toolsUsed);
     }
-    finally {
-        emitter.off("event", eventHandler);
-        session.abortController = null;
+
+    // Update conversation metadata
+    if (conversationId) {
+      updateConversationMetadata(conversationId, {
+        lastTurnTokens: {
+          input: totalIn,
+          output: totalOut
+        },
+        lastToolCalls: toolsUsed,
+        lastDurationMs: durationMs,
+        model: getModel()
+      });
     }
+
+    // Send done
+    send(ws, {
+      type: "done",
+      status: "complete",
+      conversationId: conversationId || "",
+      usage: {
+        inputTokens: session.totalInputTokens,
+        outputTokens: session.totalOutputTokens,
+        totalCost
+      }
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    if (abortController.signal.aborted) {
+      send(ws, {
+        type: "aborted"
+      });
+    } else {
+      send(ws, {
+        type: "error",
+        error: errorMsg
+      });
+    }
+  } finally {
+    emitter.off("event", eventHandler);
+    session.abortController = null;
+  }
 }
+
 // ============================================================================
 // CONNECTION HANDLER
 // ============================================================================
+
 async function handleConnection(ws, opts) {
-    const session = {
-        ws,
-        abortController: null,
-        conversationHistory: [],
-        conversationId: null,
-        totalInputTokens: 0,
-        totalOutputTokens: 0,
-    };
-    // Send ready with tool list
-    const tools = await getToolList();
-    send(ws, {
-        type: "ready",
-        version: PKG_VERSION,
-        tools,
-    });
-    if (opts.verbose) {
-        console.log("[serve] Client connected, sent ready with", tools.length, "tools");
+  const session = {
+    ws,
+    abortController: null,
+    conversationHistory: [],
+    conversationId: null,
+    totalInputTokens: 0,
+    totalOutputTokens: 0
+  };
+
+  // Send ready with tool list
+  const tools = await getToolList();
+  send(ws, {
+    type: "ready",
+    version: PKG_VERSION,
+    tools
+  });
+  if (opts.verbose) {
+    console.log("[serve] Client connected, sent ready with", tools.length, "tools");
+  }
+  ws.on("message", async data => {
+    let msg;
+    try {
+      const text = typeof data === "string" ? data : data.toString("utf-8");
+      msg = JSON.parse(text);
+    } catch {
+      send(ws, {
+        type: "error",
+        error: "Invalid JSON"
+      });
+      return;
     }
-    ws.on("message", async (data) => {
-        let msg;
-        try {
-            const text = typeof data === "string" ? data : data.toString("utf-8");
-            msg = JSON.parse(text);
+    const type = msg.type;
+    if (!type) {
+      send(ws, {
+        type: "error",
+        error: "Missing 'type' field"
+      });
+      return;
+    }
+    switch (type) {
+      case "query":
+        await handleQuery(session, msg, opts);
+        break;
+      case "abort":
+        if (session.abortController) {
+          session.abortController.abort();
+          // aborted message is sent by handleQuery's catch block
         }
-        catch {
-            send(ws, { type: "error", error: "Invalid JSON" });
-            return;
+        break;
+      case "ping":
+        send(ws, {
+          type: "pong"
+        });
+        break;
+      case "get_tools":
+        {
+          const toolList = await getToolList();
+          send(ws, {
+            type: "tools",
+            tools: toolList
+          });
+          break;
         }
-        const type = msg.type;
-        if (!type) {
-            send(ws, { type: "error", error: "Missing 'type' field" });
-            return;
+      case "new_conversation":
+        session.conversationHistory = [];
+        session.conversationId = null;
+        session.totalInputTokens = 0;
+        session.totalOutputTokens = 0;
+        resetSessionState(); // Reset module-level token counters, caches
+        if (opts.verbose) {
+          console.log("[serve] New conversation started");
         }
-        switch (type) {
-            case "query":
-                await handleQuery(session, msg, opts);
-                break;
-            case "abort":
-                if (session.abortController) {
-                    session.abortController.abort();
-                    // aborted message is sent by handleQuery's catch block
-                }
-                break;
-            case "ping":
-                send(ws, { type: "pong" });
-                break;
-            case "get_tools": {
-                const toolList = await getToolList();
-                send(ws, { type: "tools", tools: toolList });
-                break;
-            }
-            case "new_conversation":
-                session.conversationHistory = [];
-                session.conversationId = null;
-                session.totalInputTokens = 0;
-                session.totalOutputTokens = 0;
-                resetSessionState(); // Reset module-level token counters, caches
-                if (opts.verbose) {
-                    console.log("[serve] New conversation started");
-                }
-                break;
-            case "get_conversations": {
-                const storeId = msg.storeId;
-                const limit = msg.limit || 20;
-                if (!storeId) {
-                    send(ws, { type: "conversations", conversations: [] });
-                    break;
-                }
-                const convs = await listConversations(storeId, limit);
-                send(ws, { type: "conversations", conversations: convs });
-                break;
-            }
-            case "load_conversation": {
-                const convId = msg.conversationId;
-                if (!convId) {
-                    send(ws, { type: "error", error: "Missing conversationId" });
-                    break;
-                }
-                const conv = await loadConversation(convId);
-                if (conv) {
-                    session.conversationId = conv.id;
-                    send(ws, {
-                        type: "conversation_loaded",
-                        conversationId: conv.id,
-                        title: conv.title,
-                        messages: conv.messages,
-                    });
-                }
-                else {
-                    send(ws, { type: "error", error: `Conversation not found: ${convId}` });
-                }
-                break;
-            }
-            default:
-                if (opts.verbose) {
-                    console.log("[serve] Unknown message type:", type);
-                }
-                break;
+        break;
+      case "get_conversations":
+        {
+          const storeId = msg.storeId;
+          const limit = msg.limit || 20;
+          if (!storeId) {
+            send(ws, {
+              type: "conversations",
+              conversations: []
+            });
+            break;
+          }
+          const convs = await listConversations(storeId, limit);
+          send(ws, {
+            type: "conversations",
+            conversations: convs
+          });
+          break;
         }
-    });
-    ws.on("close", () => {
-        // Abort any running query when client disconnects
-        if (session.abortController) {
-            session.abortController.abort();
+      case "load_conversation":
+        {
+          const convId = msg.conversationId;
+          if (!convId) {
+            send(ws, {
+              type: "error",
+              error: "Missing conversationId"
+            });
+            break;
+          }
+          const conv = await loadConversation(convId);
+          if (conv) {
+            session.conversationId = conv.id;
+            send(ws, {
+              type: "conversation_loaded",
+              conversationId: conv.id,
+              title: conv.title,
+              messages: conv.messages
+            });
+          } else {
+            send(ws, {
+              type: "error",
+              error: `Conversation not found: ${convId}`
+            });
+          }
+          break;
         }
+      default:
         if (opts.verbose) {
-            console.log("[serve] Client disconnected");
-        }
-    });
-    ws.on("error", (err) => {
-        console.error("[serve] WebSocket error:", err.message);
-        if (session.abortController) {
-            session.abortController.abort();
+          console.log("[serve] Unknown message type:", type);
         }
-    });
+        break;
+    }
+  });
+  ws.on("close", () => {
+    // Abort any running query when client disconnects
+    if (session.abortController) {
+      session.abortController.abort();
+    }
+    if (opts.verbose) {
+      console.log("[serve] Client disconnected");
+    }
+  });
+  ws.on("error", err => {
+    console.error("[serve] WebSocket error:", err.message);
+    if (session.abortController) {
+      session.abortController.abort();
+    }
+  });
 }
+
 // ============================================================================
 // SERVER STARTUP
 // ============================================================================
+
 export async function runServeMode(opts) {
-    // Apply global settings
-    if (opts.model)
-        setModel(opts.model);
-    setPermissionMode(opts.permissionMode || "yolo");
-    const port = opts.port;
-    const host = opts.host;
-    // HTTP server for health check + WebSocket upgrade
-    const server = createServer((req, res) => {
-        // Health check endpoint
-        if (req.method === "GET" && (req.url === "/health" || req.url === "/")) {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                status: "ok",
-                version: PKG_VERSION,
-                model: getModel(),
-                port,
-                uptime: Math.floor(process.uptime()),
-            }));
-            return;
-        }
-        // Everything else: 404
-        res.writeHead(404, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "Not found. Connect via WebSocket." }));
+  // Apply global settings
+  if (opts.model) setModel(opts.model);
+  setPermissionMode(opts.permissionMode || "yolo");
+  const port = opts.port;
+  const host = opts.host;
+
+  // HTTP server for health check + WebSocket upgrade
+  const server = createServer((req, res) => {
+    // Health check endpoint
+    if (req.method === "GET" && (req.url === "/health" || req.url === "/")) {
+      res.writeHead(200, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({
+        status: "ok",
+        version: PKG_VERSION,
+        model: getModel(),
+        port,
+        uptime: Math.floor(process.uptime())
+      }));
+      return;
+    }
+
+    // Everything else: 404
+    res.writeHead(404, {
+      "Content-Type": "application/json"
     });
-    // WebSocket server
-    const wss = new WebSocketServer({ server });
-    wss.on("connection", (ws) => {
-        handleConnection(ws, opts);
+    res.end(JSON.stringify({
+      error: "Not found. Connect via WebSocket."
+    }));
+  });
+
+  // WebSocket server
+  const wss = new WebSocketServer({
+    server
+  });
+  wss.on("connection", ws => {
+    handleConnection(ws, opts);
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log("\n[serve] Shutting down...");
+    wss.clients.forEach(client => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.close(1001, "Server shutting down");
+      }
     });
-    // Graceful shutdown
-    const shutdown = () => {
-        console.log("\n[serve] Shutting down...");
-        wss.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.close(1001, "Server shutting down");
-            }
-        });
-        server.close(() => {
-            console.log("[serve] Server stopped.");
-            process.exit(0);
-        });
-        // Force exit after 3s
-        setTimeout(() => process.exit(0), 3000);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    // Verify Supabase connectivity (non-blocking)
-    getSupabase().then((db) => {
-        if (db) {
-            console.log("[serve] Supabase connected — conversation persistence enabled");
-        }
-        else {
-            console.log("[serve] Supabase not configured — conversations are session-only");
-        }
+    server.close(() => {
+      console.log("[serve] Server stopped.");
+      process.exit(0);
     });
-    // Start listening
-    return new Promise((resolve, reject) => {
-        server.on("error", (err) => {
-            if (err.code === "EADDRINUSE") {
-                console.error(`[serve] Port ${port} is already in use.`);
-                console.error(`[serve] Try: whale serve --port ${port + 1}`);
-                process.exit(1);
-            }
-            reject(err);
-        });
-        server.listen(port, host, () => {
-            const d = "\x1b[2m";
-            const B = "\x1b[1m";
-            const r = "\x1b[0m";
-            const c = "\x1b[38;2;99;102;241m";
-            console.log();
-            console.log(`  ${c}${B}◆ whale serve${r}  ${d}v${PKG_VERSION}${r}`);
-            console.log();
-            console.log(`  ${B}WebSocket${r}  ${d}ws://${host}:${port}${r}`);
-            console.log(`  ${B}Health${r}     ${d}http://${host}:${port}/health${r}`);
-            console.log(`  ${B}Model${r}      ${d}${getModel()}${r}`);
-            console.log(`  ${B}Mode${r}       ${d}yolo (local server trusts local client)${r}`);
-            console.log();
-            console.log(`  ${d}WhaleChat will auto-connect on port 3847${r}`);
-            console.log(`  ${d}Press Ctrl+C to stop${r}`);
-            console.log();
-            resolve();
-        });
+    // Force exit after 3s
+    setTimeout(() => process.exit(0), 3000);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // Verify Supabase connectivity (non-blocking)
+  getSupabase().then(db => {
+    if (db) {
+      console.log("[serve] Supabase connected — conversation persistence enabled");
+    } else {
+      console.log("[serve] Supabase not configured — conversations are session-only");
+    }
+  });
+
+  // Start listening
+  return new Promise((resolve, reject) => {
+    server.on("error", err => {
+      if (err.code === "EADDRINUSE") {
+        console.error(`[serve] Port ${port} is already in use.`);
+        console.error(`[serve] Try: whale serve --port ${port + 1}`);
+        process.exit(1);
+      }
+      reject(err);
+    });
+    server.listen(port, host, () => {
+      const d = "\x1b[2m";
+      const B = "\x1b[1m";
+      const r = "\x1b[0m";
+      const c = "\x1b[38;2;99;102;241m";
+      console.log();
+      console.log(`  ${c}${B}◆ whale serve${r}  ${d}v${PKG_VERSION}${r}`);
+      console.log();
+      console.log(`  ${B}WebSocket${r}  ${d}ws://${host}:${port}${r}`);
+      console.log(`  ${B}Health${r}     ${d}http://${host}:${port}/health${r}`);
+      console.log(`  ${B}Model${r}      ${d}${getModel()}${r}`);
+      console.log(`  ${B}Mode${r}       ${d}yolo (local server trusts local client)${r}`);
+      console.log();
+      console.log(`  ${d}WhaleChat will auto-connect on port 3847${r}`);
+      console.log(`  ${d}Press Ctrl+C to stop${r}`);
+      console.log();
+      resolve();
     });
+  });
 }
+//# sourceMappingURL=serve-mode.js.map