wispy-cli 0.6.1 → 0.8.0

package/core/index.mjs

@@ -0,0 +1,14 @@
+/**
+ * core/index.mjs — Public API for wispy-core
+ *
+ * All surfaces (CLI, TUI, channels) import from here.
+ */
+
+export { WispyEngine, getDefaultEngine } from "./engine.mjs";
+export { SessionManager, Session, sessionManager } from "./session.mjs";
+export { ProviderRegistry } from "./providers.mjs";
+export { ToolRegistry } from "./tools.mjs";
+export { MCPClient, MCPManager, ensureDefaultMcpConfig } from "./mcp.mjs";
+export { loadConfig, saveConfig, detectProvider, PROVIDERS, WISPY_DIR, MCP_CONFIG_PATH, SESSIONS_DIR, CONVERSATIONS_DIR, MEMORY_DIR } from "./config.mjs";
+export { MemoryManager } from "./memory.mjs";
+export { CronManager } from "./cron.mjs";

package/core/mcp.mjs

@@ -0,0 +1,8 @@
+/**
+ * core/mcp.mjs — MCP client (re-export from lib/mcp-client.mjs)
+ *
+ * MCPClient and MCPManager are moved here as the canonical location.
+ * lib/mcp-client.mjs remains as a backward-compatible re-export.
+ */
+
+export { MCPClient, MCPManager, ensureDefaultMcpConfig } from "../lib/mcp-client.mjs";

package/core/memory.mjs

@@ -0,0 +1,275 @@
+/**
+ * core/memory.mjs — Long-term memory system for Wispy
+ *
+ * File-based memory stored in ~/.wispy/memory/
+ * - MEMORY.md — main persistent memory
+ * - daily/YYYY-MM-DD.md — daily logs
+ * - projects/<name>.md — project-specific memory
+ * - user.md — user preferences/info
+ */
+
+import path from "node:path";
+import { readFile, writeFile, appendFile, mkdir, readdir, unlink, stat } from "node:fs/promises";
+
+const MAX_SEARCH_RESULTS = 20;
+const MAX_SNIPPET_CHARS = 200;
+
+export class MemoryManager {
+  constructor(wispyDir) {
+    this.memoryDir = path.join(wispyDir, "memory");
+  }
+
+  /**
+   * Ensure memory directory exists
+   */
+  async _ensureDir(subDir = "") {
+    const dir = subDir ? path.join(this.memoryDir, subDir) : this.memoryDir;
+    await mkdir(dir, { recursive: true });
+    return dir;
+  }
+
+  /**
+   * Resolve key to file path
+   * Keys can be: "user", "MEMORY", "daily/2025-01-01", "projects/myproject"
+   */
+  _keyToPath(key) {
+    // Normalize: strip .md extension if present
+    const clean = key.replace(/\.md$/, "");
+    return path.join(this.memoryDir, `${clean}.md`);
+  }
+
+  /**
+   * Save (overwrite) a memory file
+   */
+  async save(key, content, metadata = {}) {
+    await this._ensureDir();
+
+    // Ensure subdirectory exists
+    const filePath = this._keyToPath(key);
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+
+    const ts = new Date().toISOString();
+    const header = metadata.title
+      ? `# ${metadata.title}\n\n_Last updated: ${ts}_\n\n`
+      : `_Last updated: ${ts}_\n\n`;
+
+    await writeFile(filePath, header + content, "utf8");
+    return { key, path: filePath };
+  }
+
+  /**
+   * Append to an existing memory file (creates if doesn't exist)
+   */
+  async append(key, content) {
+    await this._ensureDir();
+    const filePath = this._keyToPath(key);
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+
+    const ts = new Date().toISOString().slice(0, 16);
+    await appendFile(filePath, `\n- [${ts}] ${content}\n`, "utf8");
+    return { key, path: filePath };
+  }
+
+  /**
+   * Get a specific memory file
+   */
+  async get(key) {
+    const filePath = this._keyToPath(key);
+    try {
+      const content = await readFile(filePath, "utf8");
+      return { key, content, path: filePath };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * List all memory keys (relative paths without .md)
+   */
+  async list() {
+    await this._ensureDir();
+    const keys = [];
+    await this._collectKeys(this.memoryDir, this.memoryDir, keys);
+    return keys;
+  }
+
+  async _collectKeys(baseDir, dir, keys) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this._collectKeys(baseDir, fullPath, keys);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const rel = path.relative(baseDir, fullPath).replace(/\.md$/, "");
+        const fileStat = await stat(fullPath).catch(() => null);
+        const content = await readFile(fullPath, "utf8").catch(() => "");
+        keys.push({
+          key: rel,
+          path: fullPath,
+          size: content.trim().length,
+          preview: content.trim().slice(0, 80).replace(/\n/g, " "),
+          updatedAt: fileStat?.mtime?.toISOString() ?? null,
+        });
+      }
+    }
+  }
+
+  /**
+   * Full-text search across all memory files
+   * Returns matching snippets with file path and line numbers
+   */
+  async search(query, opts = {}) {
+    if (!query?.trim()) return [];
+    await this._ensureDir();
+
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const results = [];
+    await this._searchDir(this.memoryDir, this.memoryDir, terms, results);
+
+    // Sort by relevance (number of term matches)
+    results.sort((a, b) => b.matchCount - a.matchCount);
+
+    return results.slice(0, opts.limit ?? MAX_SEARCH_RESULTS);
+  }
+
+  async _searchDir(baseDir, dir, terms, results) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this._searchDir(baseDir, fullPath, terms, results);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const content = await readFile(fullPath, "utf8").catch(() => "");
+        const lines = content.split("\n");
+        const key = path.relative(baseDir, fullPath).replace(/\.md$/, "");
+
+        let matchCount = 0;
+        const matchingLines = [];
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const lower = line.toLowerCase();
+          const lineMatches = terms.filter(t => lower.includes(t)).length;
+          if (lineMatches > 0) {
+            matchCount += lineMatches;
+            matchingLines.push({
+              lineNumber: i + 1,
+              text: line.slice(0, MAX_SNIPPET_CHARS),
+            });
+          }
+        }
+
+        if (matchCount > 0) {
+          results.push({
+            key,
+            path: fullPath,
+            matchCount,
+            snippets: matchingLines.slice(0, 5),
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Delete a memory file
+   */
+  async delete(key) {
+    const filePath = this._keyToPath(key);
+    try {
+      await unlink(filePath);
+      return { success: true, key };
+    } catch {
+      return { success: false, key, error: "Not found" };
+    }
+  }
+
+  /**
+   * Auto-capture important info from conversation messages
+   * Uses AI to extract key facts (called from engine)
+   */
+  async autoCapture(messages, aiCall) {
+    // Extract user messages for analysis
+    const recentUserMsgs = messages
+      .filter(m => m.role === "user")
+      .slice(-5)
+      .map(m => m.content)
+      .join("\n\n");
+
+    if (!recentUserMsgs.trim()) return null;
+
+    try {
+      const prompt = `Extract any important facts, preferences, or information from this conversation that should be remembered for future sessions. Be concise. If nothing important, reply "nothing".
+
+Conversation:
+${recentUserMsgs.slice(0, 2000)}`;
+
+      const result = await aiCall(prompt);
+      if (result && result.toLowerCase() !== "nothing") {
+        const today = new Date().toISOString().slice(0, 10);
+        await this.append(`daily/${today}`, result.slice(0, 500));
+        return result;
+      }
+    } catch {
+      // Silently fail — auto-capture is optional
+    }
+    return null;
+  }
+
+  /**
+   * Get today's daily log key
+   */
+  getDailyKey() {
+    return `daily/${new Date().toISOString().slice(0, 10)}`;
+  }
+
+  /**
+   * Get formatted memory context for injection into system prompt
+   */
+  async getContextForPrompt(query = "", maxChars = 3000) {
+    try {
+      const results = [];
+
+      // Always include MEMORY.md if it exists
+      const mainMemory = await this.get("MEMORY");
+      if (mainMemory?.content?.trim()) {
+        results.push(`### MEMORY.md\n${mainMemory.content.trim()}`);
+      }
+
+      // Include user.md if it exists
+      const userMemory = await this.get("user");
+      if (userMemory?.content?.trim()) {
+        results.push(`### user.md\n${userMemory.content.trim()}`);
+      }
+
+      // Search for relevant memories if query provided
+      if (query.trim()) {
+        const searchResults = await this.search(query, { limit: 5 });
+        for (const r of searchResults) {
+          if (r.key === "MEMORY" || r.key === "user") continue; // already included
+          const mem = await this.get(r.key);
+          if (mem?.content?.trim()) {
+            results.push(`### ${r.key}.md\n${mem.content.trim()}`);
+          }
+        }
+      }
+
+      const joined = results.join("\n\n");
+      return joined.slice(0, maxChars) || null;
+    } catch {
+      return null;
+    }
+  }
+}

package/core/providers.mjs

@@ -0,0 +1,410 @@
+/**
+ * core/providers.mjs — Provider abstraction for Wispy
+ *
+ * Class ProviderRegistry:
+ *   - detect() → available providers list
+ *   - get(name) → Provider
+ *   - getDefault() → Provider (first available)
+ *   - chat(messages, tools, opts?) → response
+ *   - setModel(model) → void
+ *
+ * Each provider: { name, label, models, chat(messages, tools, opts) }
+ */
+
+import { PROVIDERS, detectProvider } from "./config.mjs";
+
+const OPENAI_COMPAT_ENDPOINTS = {
+  openai:     "https://api.openai.com/v1/chat/completions",
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+  groq:       "https://api.groq.com/openai/v1/chat/completions",
+  deepseek:   "https://api.deepseek.com/v1/chat/completions",
+  ollama:     `${process.env.OLLAMA_HOST ?? "http://localhost:11434"}/v1/chat/completions`,
+};
+
+export class ProviderRegistry {
+  constructor() {
+    this._detected = null;
+    this._provider = null;
+    this._apiKey = null;
+    this._model = null;
+    this._sessionTokens = { input: 0, output: 0 };
+  }
+
+  /**
+   * Initialize by detecting available provider.
+   */
+  async init(overrides = {}) {
+    const detected = await detectProvider();
+    if (!detected && !overrides.provider) {
+      return null;
+    }
+    this._provider = overrides.provider ?? detected?.provider;
+    this._apiKey = overrides.key ?? detected?.key;
+    this._model = overrides.model ?? detected?.model;
+    this._detected = detected;
+    return { provider: this._provider, key: this._apiKey, model: this._model };
+  }
+
+  get provider() { return this._provider; }
+  get apiKey() { return this._apiKey; }
+  get model() { return this._model; }
+  get sessionTokens() { return this._sessionTokens; }
+
+  setModel(model) {
+    this._model = model;
+    process.env.WISPY_MODEL = model;
+  }
+
+  detect() {
+    return Object.entries(PROVIDERS)
+      .filter(([id, p]) => {
+        for (const k of p.envKeys) { if (process.env[k]) return true; }
+        return p.local && process.env.OLLAMA_HOST;
+      })
+      .map(([id, p]) => ({ id, label: p.label, defaultModel: p.defaultModel }));
+  }
+
+  get(name) {
+    return PROVIDERS[name] ?? null;
+  }
+
+  getDefault() {
+    return PROVIDERS[this._provider] ?? null;
+  }
+
+  _estimateTokens(text) {
+    return Math.ceil((text?.length ?? 0) / 4);
+  }
+
+  /**
+   * Main chat entrypoint. Routes to the correct provider.
+   * messages: array of { role, content, toolCalls?, ... }
+   * tools: array of tool definitions
+   * opts: { onChunk?(chunk), model? }
+   * Returns: { type: "text"|"tool_calls", text?, calls? }
+   */
+  async chat(messages, tools = [], opts = {}) {
+    const model = opts.model ?? this._model;
+    if (this._provider === "google") {
+      return this._chatGemini(messages, tools, opts, model);
+    }
+    if (this._provider === "anthropic") {
+      return this._chatAnthropic(messages, tools, opts, model);
+    }
+    return this._chatOpenAICompat(messages, tools, opts, model);
+  }
+
+  async _chatGemini(messages, tools, opts, model) {
+    const systemInstruction = messages.find(m => m.role === "system")?.content ?? "";
+    const contents = [];
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      if (m.role === "tool_result") {
+        contents.push({
+          role: "user",
+          parts: [{ functionResponse: { name: m.toolName, response: m.result } }],
+        });
+      } else if (m.role === "assistant" && m.toolCalls) {
+        contents.push({
+          role: "model",
+          parts: m.toolCalls.map(tc => ({
+            functionCall: { name: tc.name, args: tc.args },
+          })),
+        });
+      } else {
+        contents.push({
+          role: m.role === "assistant" ? "model" : "user",
+          parts: [{ text: m.content }],
+        });
+      }
+    }
+
+    const inputText = contents.map(c => c.parts?.map(p => p.text ?? JSON.stringify(p)).join("")).join("");
+    this._sessionTokens.input += this._estimateTokens(systemInstruction + inputText);
+
+    const geminiTools = tools.length > 0 ? [{
+      functionDeclarations: tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      })),
+    }] : [];
+
+    const hasToolResults = messages.some(m => m.role === "tool_result");
+    const useStreaming = !hasToolResults;
+    const endpoint = useStreaming ? "streamGenerateContent" : "generateContent";
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:${endpoint}?${useStreaming ? "alt=sse&" : ""}key=${this._apiKey}`;
+
+    const body = {
+      system_instruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+      contents,
+      generationConfig: { temperature: 0.7, maxOutputTokens: 4096 },
+    };
+    if (geminiTools.length > 0) body.tools = geminiTools;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    if (useStreaming) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let fullText = "";
+      let sseBuffer = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        sseBuffer += decoder.decode(value, { stream: true });
+        const sseLines = sseBuffer.split("\n");
+        sseBuffer = sseLines.pop() ?? "";
+
+        for (const line of sseLines) {
+          if (!line.startsWith("data: ")) continue;
+          const ld = line.slice(6).trim();
+          if (!ld || ld === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(ld);
+            const streamParts = parsed.candidates?.[0]?.content?.parts ?? [];
+            const streamFC = streamParts.filter(p => p.functionCall);
+            if (streamFC.length > 0) {
+              this._sessionTokens.output += this._estimateTokens(JSON.stringify(streamFC));
+              return { type: "tool_calls", calls: streamFC.map(p => ({ name: p.functionCall.name, args: p.functionCall.args })) };
+            }
+            const t = streamParts.map(p => p.text ?? "").join("");
+            if (t) { fullText += t; opts.onChunk?.(t); }
+          } catch { /* skip */ }
+        }
+      }
+      this._sessionTokens.output += this._estimateTokens(fullText);
+      return { type: "text", text: fullText };
+    }
+
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    if (!candidate) throw new Error("No response from Gemini");
+
+    const parts = candidate.content?.parts ?? [];
+    const functionCalls = parts.filter(p => p.functionCall);
+    if (functionCalls.length > 0) {
+      this._sessionTokens.output += this._estimateTokens(JSON.stringify(functionCalls));
+      return { type: "tool_calls", calls: functionCalls.map(p => ({ name: p.functionCall.name, args: p.functionCall.args })) };
+    }
+
+    const text = parts.map(p => p.text ?? "").join("");
+    this._sessionTokens.output += this._estimateTokens(text);
+    opts.onChunk?.(text);
+    return { type: "text", text };
+  }
+
+  async _chatAnthropic(messages, tools, opts, model) {
+    const systemPrompt = messages.find(m => m.role === "system")?.content ?? "";
+    const anthropicMessages = [];
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      if (m.role === "tool_result") {
+        anthropicMessages.push({
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: m.toolUseId ?? m.toolName, content: JSON.stringify(m.result) }],
+        });
+      } else if (m.role === "assistant" && m.toolCalls) {
+        anthropicMessages.push({
+          role: "assistant",
+          content: m.toolCalls.map(tc => ({
+            type: "tool_use", id: tc.id ?? tc.name, name: tc.name, input: tc.args,
+          })),
+        });
+      } else {
+        anthropicMessages.push({
+          role: m.role === "assistant" ? "assistant" : "user",
+          content: m.content,
+        });
+      }
+    }
+
+    const inputText = anthropicMessages.map(m => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("");
+    this._sessionTokens.input += this._estimateTokens(systemPrompt + inputText);
+
+    const anthropicTools = tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+    }));
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this._apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: anthropicMessages,
+        tools: anthropicTools,
+        stream: true,
+      }),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    const toolCalls = [];
+    let currentToolCall = null;
+    let currentToolInput = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (!data) continue;
+
+        try {
+          const event = JSON.parse(data);
+          if (event.type === "content_block_start") {
+            if (event.content_block?.type === "tool_use") {
+              currentToolCall = { id: event.content_block.id, name: event.content_block.name, args: {} };
+              currentToolInput = "";
+            }
+          } else if (event.type === "content_block_delta") {
+            if (event.delta?.type === "text_delta") {
+              fullText += event.delta.text;
+              opts.onChunk?.(event.delta.text);
+            } else if (event.delta?.type === "input_json_delta") {
+              currentToolInput += event.delta.partial_json ?? "";
+            }
+          } else if (event.type === "content_block_stop") {
+            if (currentToolCall) {
+              try { currentToolCall.args = JSON.parse(currentToolInput); } catch { currentToolCall.args = {}; }
+              toolCalls.push(currentToolCall);
+              currentToolCall = null;
+              currentToolInput = "";
+            }
+          }
+        } catch { /* skip */ }
+      }
+    }
+
+    this._sessionTokens.output += this._estimateTokens(fullText + JSON.stringify(toolCalls));
+
+    if (toolCalls.length > 0) {
+      return { type: "tool_calls", calls: toolCalls };
+    }
+    return { type: "text", text: fullText };
+  }
+
+  async _chatOpenAICompat(messages, tools, opts, model) {
+    const openaiMessages = messages.map(m => {
+      if (m.role === "tool_result") {
+        return { role: "tool", tool_call_id: m.toolCallId ?? m.toolName, content: JSON.stringify(m.result) };
+      }
+      if (m.role === "assistant" && m.toolCalls) {
+        return {
+          role: "assistant",
+          content: null,
+          tool_calls: m.toolCalls.map((tc, i) => ({
+            id: tc.id ?? `call_${i}`,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+          })),
+        };
+      }
+      return { role: m.role, content: m.content };
+    });
+
+    const inputText = openaiMessages.map(m => m.content ?? "").join("");
+    this._sessionTokens.input += this._estimateTokens(inputText);
+
+    const endpoint = OPENAI_COMPAT_ENDPOINTS[this._provider] ?? OPENAI_COMPAT_ENDPOINTS.openai;
+    const headers = { "Content-Type": "application/json" };
+    if (this._apiKey) headers["Authorization"] = `Bearer ${this._apiKey}`;
+    if (this._provider === "openrouter") headers["HTTP-Referer"] = "https://wispy.dev";
+
+    const supportsTools = !["ollama"].includes(this._provider);
+    const body = { model, messages: openaiMessages, temperature: 0.7, max_tokens: 4096 };
+    if (supportsTools && tools.length > 0) {
+      body.tools = tools.map(t => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+      }));
+    }
+
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) throw new Error("No response from OpenAI");
+
+    if (choice.message?.tool_calls?.length > 0) {
+      const calls = choice.message.tool_calls.map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        args: JSON.parse(tc.function.arguments),
+      }));
+      this._sessionTokens.output += this._estimateTokens(JSON.stringify(calls));
+      return { type: "tool_calls", calls };
+    }
+
+    const text = choice.message?.content ?? "";
+    this._sessionTokens.output += this._estimateTokens(text);
+    opts.onChunk?.(text);
+    return { type: "text", text };
+  }
+
+  formatCost() {
+    const MODEL_PRICING = {
+      "gemini-2.5-flash":   { input: 0.15,  output: 0.60 },
+      "gemini-2.5-pro":     { input: 1.25,  output: 10.0 },
+      "gemini-2.0-flash":   { input: 0.10,  output: 0.40 },
+      "claude-sonnet-4-20250514": { input: 3.0, output: 15.0 },
+      "claude-opus-4-6":    { input: 15.0,  output: 75.0 },
+      "claude-haiku-3.5":   { input: 0.80,  output: 4.0 },
+      "gpt-4o":             { input: 2.50,  output: 10.0 },
+      "gpt-4o-mini":        { input: 0.15,  output: 0.60 },
+      "gpt-4.1":            { input: 2.0,   output: 8.0 },
+      "gpt-4.1-mini":       { input: 0.40,  output: 1.60 },
+      "gpt-4.1-nano":       { input: 0.10,  output: 0.40 },
+      "o4-mini":            { input: 1.10,  output: 4.40 },
+      "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+      "deepseek-chat":      { input: 0.27,  output: 1.10 },
+      "llama3.2":           { input: 0,     output: 0 },
+    };
+    const pricing = MODEL_PRICING[this._model] ?? { input: 1.0, output: 3.0 };
+    const cost = (this._sessionTokens.input * pricing.input + this._sessionTokens.output * pricing.output) / 1_000_000;
+    const total = this._sessionTokens.input + this._sessionTokens.output;
+    return `${total} tokens (~$${cost.toFixed(4)})`;
+  }
+}