@quantish/agent 0.1.52 → 0.1.65

package/dist/index.js

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+import {
+  createAgent,
+  createMCPClient,
+  createMCPClientManager,
+  formatCost,
+  getModelConfig,
+  getOpenRouterModelConfig,
+  listModels,
+  listOpenRouterModels,
+  localTools,
+  processManager
+} from "./chunk-LQQUSD7H.js";
 
 // src/index.ts
 import React2 from "react";
@@ -16,7 +28,7 @@ var DISCOVERY_MCP_PUBLIC_KEY = "qm_ueQeqrmvZyHtR1zuVbLYkhx0fKyVAuV8";
 var KALSHI_MCP_URL = "https://kalshi-mcp-production-7c2c.up.railway.app/mcp";
 var DEFAULT_MCP_URL = DEFAULT_TRADING_MCP_URL;
 var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
-var DEFAULT_OPENROUTER_MODEL = "z-ai/glm-4.7";
+var DEFAULT_OPENROUTER_MODEL = "anthropic/claude-haiku-4.5";
 var schema = {
   anthropicApiKey: {
     type: "string"
@@ -232,328 +244,18 @@ function getConfigManager() {
 // src/config/setup.ts
 import * as readline from "readline";
 import chalk from "chalk";
-
-// src/mcp/client.ts
-var MCPClient = class {
-  baseUrl;
-  apiKey;
-  toolsCache = null;
-  source;
-  constructor(baseUrl, apiKey, source = "trading") {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-    this.source = source;
-  }
-  /**
-   * List available tools from the MCP server
-   * Discovery MCP uses REST endpoints, Trading MCP uses JSON-RPC
-   */
-  async listTools() {
-    if (this.toolsCache) {
-      return this.toolsCache;
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.source === "discovery") {
-      headers["Accept"] = "application/json, text/event-stream";
-      headers["X-API-Key"] = this.apiKey;
-    } else {
-      headers["x-api-key"] = this.apiKey;
-    }
-    const response = await fetch(this.baseUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        method: "tools/list",
-        params: {},
-        id: Date.now()
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`MCP server error: ${response.status} ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (data.error) {
-      throw new Error(`MCP error: ${data.error.message}`);
-    }
-    const tools = data.result?.tools || [];
-    this.toolsCache = tools;
-    return tools;
-  }
-  /**
-   * Call a tool on the MCP server
-   * All MCPs use JSON-RPC format
-   */
-  async callTool(name, args) {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.source === "discovery") {
-      headers["Accept"] = "application/json, text/event-stream";
-      headers["X-API-Key"] = this.apiKey;
-    } else {
-      headers["x-api-key"] = this.apiKey;
-    }
-    const response = await fetch(this.baseUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        method: "tools/call",
-        params: {
-          name,
-          arguments: args
-        },
-        id: Date.now()
-      })
-    });
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `MCP server error: ${response.status} ${response.statusText}`
-      };
-    }
-    const data = await response.json();
-    if (data.error) {
-      return {
-        success: false,
-        error: data.error.message
-      };
-    }
-    const content = data.result?.content;
-    if (content && content.length > 0) {
-      const textContent = content.find((c) => c.type === "text");
-      if (textContent?.text) {
-        try {
-          return {
-            success: true,
-            data: JSON.parse(textContent.text)
-          };
-        } catch {
-          return {
-            success: true,
-            data: textContent.text
-          };
-        }
-      }
-    }
-    return {
-      success: true,
-      data: data.result
-    };
-  }
-  /**
-   * Clear the tools cache (useful if server tools are updated)
-   */
-  clearCache() {
-    this.toolsCache = null;
-  }
-  /**
-   * Check if the MCP server is reachable
-   */
-  async healthCheck() {
-    try {
-      await this.listTools();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-function createMCPClient(baseUrl, apiKey, source = "trading") {
-  return new MCPClient(baseUrl, apiKey, source);
-}
-var MCPClientManager = class {
-  discoveryClient;
-  tradingClient;
-  kalshiClient;
-  toolSourceMap = /* @__PURE__ */ new Map();
-  allToolsCache = null;
-  constructor(discoveryUrl, discoveryApiKey, tradingUrl, tradingApiKey, kalshiUrl, kalshiApiKey) {
-    this.discoveryClient = new MCPClient(discoveryUrl, discoveryApiKey, "discovery");
-    this.tradingClient = tradingUrl && tradingApiKey ? new MCPClient(tradingUrl, tradingApiKey, "trading") : null;
-    this.kalshiClient = kalshiUrl && kalshiApiKey ? new MCPClient(kalshiUrl, kalshiApiKey, "kalshi") : null;
-  }
-  /**
-   * Check if trading is enabled (Polymarket)
-   */
-  isTradingEnabled() {
-    return this.tradingClient !== null;
-  }
-  /**
-   * Check if Kalshi trading is enabled
-   */
-  isKalshiEnabled() {
-    return this.kalshiClient !== null;
-  }
-  /**
-   * Get the discovery client
-   */
-  getDiscoveryClient() {
-    return this.discoveryClient;
-  }
-  /**
-   * Get the trading client (may be null)
-   */
-  getTradingClient() {
-    return this.tradingClient;
-  }
-  /**
-   * Get the Kalshi client (may be null)
-   */
-  getKalshiClient() {
-    return this.kalshiClient;
-  }
-  /**
-   * List all tools from both servers
-   */
-  async listAllTools() {
-    if (this.allToolsCache) {
-      return this.allToolsCache;
-    }
-    const allTools = [];
-    this.toolSourceMap.clear();
-    try {
-      const discoveryTools = await this.discoveryClient.listTools();
-      for (const tool of discoveryTools) {
-        allTools.push({ ...tool, source: "discovery" });
-        this.toolSourceMap.set(tool.name, "discovery");
-      }
-    } catch (error2) {
-      console.warn("Failed to fetch Discovery MCP tools:", error2);
-    }
-    const discoverySearchTools = /* @__PURE__ */ new Set([
-      "search_markets",
-      "get_market_details",
-      "get_trending_markets",
-      "get_categories",
-      "get_market_stats",
-      "get_search_status",
-      "find_arbitrage"
-    ]);
-    if (this.tradingClient) {
-      try {
-        const tradingTools = await this.tradingClient.listTools();
-        for (const tool of tradingTools) {
-          if (discoverySearchTools.has(tool.name)) {
-            continue;
-          }
-          allTools.push({ ...tool, source: "trading" });
-          this.toolSourceMap.set(tool.name, "trading");
-        }
-      } catch (error2) {
-        console.warn("Failed to fetch Trading MCP tools:", error2);
-      }
-    }
-    if (this.kalshiClient) {
-      try {
-        const kalshiTools = await this.kalshiClient.listTools();
-        for (const tool of kalshiTools) {
-          allTools.push({ ...tool, source: "kalshi" });
-          this.toolSourceMap.set(tool.name, "kalshi");
-        }
-      } catch (error2) {
-        console.warn("Failed to fetch Kalshi MCP tools:", error2);
-      }
-    }
-    this.allToolsCache = allTools;
-    return allTools;
-  }
-  /**
-   * Get which server a tool belongs to
-   */
-  getToolSource(toolName) {
-    return this.toolSourceMap.get(toolName);
-  }
-  /**
-   * Call a tool on the appropriate server
-   */
-  async callTool(name, args) {
-    if (this.toolSourceMap.size === 0) {
-      await this.listAllTools();
-    }
-    const source = this.toolSourceMap.get(name);
-    if (!source) {
-      return {
-        success: false,
-        error: `Unknown MCP tool: ${name}`
-      };
-    }
-    if (source === "discovery") {
-      const result = await this.discoveryClient.callTool(name, args);
-      return { ...result, source: "discovery" };
-    }
-    if (source === "trading") {
-      if (!this.tradingClient) {
-        return {
-          success: false,
-          error: `Polymarket trading not enabled. Run 'quantish init' to set up trading.`
-        };
-      }
-      const result = await this.tradingClient.callTool(name, args);
-      return { ...result, source: "trading" };
-    }
-    if (source === "kalshi") {
-      if (!this.kalshiClient) {
-        return {
-          success: false,
-          error: `Kalshi trading not enabled. Run 'quantish init' to set up your Kalshi API key.`
-        };
-      }
-      const result = await this.kalshiClient.callTool(name, args);
-      return { ...result, source: "kalshi" };
-    }
-    return {
-      success: false,
-      error: `Unknown tool source: ${source}`
-    };
-  }
-  /**
-   * Clear all caches
-   */
-  clearCache() {
-    this.discoveryClient.clearCache();
-    this.tradingClient?.clearCache();
-    this.allToolsCache = null;
-    this.toolSourceMap.clear();
-  }
-  /**
-   * Health check both servers
-   */
-  async healthCheck() {
-    const discovery = await this.discoveryClient.healthCheck();
-    const trading = this.tradingClient ? await this.tradingClient.healthCheck() : null;
-    return { discovery, trading };
-  }
-};
-function createMCPClientManager(discoveryUrl, discoveryApiKey, tradingUrl, tradingApiKey, kalshiUrl, kalshiApiKey) {
-  return new MCPClientManager(discoveryUrl, discoveryApiKey, tradingUrl, tradingApiKey, kalshiUrl, kalshiApiKey);
-}
-
-// src/mcp/tools.ts
-function convertToClaudeTools(mcpTools) {
-  return mcpTools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    input_schema: tool.inputSchema
-  }));
-}
-
-// src/config/setup.ts
 async function prompt(question, isSecret = false) {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     if (isSecret) {
       console.log(chalk.dim("(Input will be visible)"));
     }
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve(answer.trim());
     });
   });
 }
@@ -641,7 +343,7 @@ async function runSetup() {
     }
     config.setOpenRouterApiKey(openrouterKey);
     console.log(chalk.green("\u2713 OpenRouter API key saved"));
-    console.log(chalk.dim("  Using model: z-ai/glm-4.7\n"));
+    console.log(chalk.dim("  Using model: Claude Haiku 4.5\n"));
   } else {
     config.setProvider("anthropic");
     console.log();
@@ -803,3637 +505,161 @@ async function runSetup() {
           console.log(chalk.dim(String(error2)));
           console.log(chalk.dim("Keeping current key.\n"));
         }
-      }
-    } else if (action.toLowerCase() === "d") {
-      kalshiKey = void 0;
-      skipKalshi = true;
-    }
-  } else {
-    console.log("Options:");
-    console.log(chalk.dim("  1. Create a new Kalshi wallet (recommended for new users)"));
-    console.log(chalk.dim("  2. Enter an existing Kalshi API key"));
-    console.log(chalk.dim("  3. Skip Kalshi for now\n"));
-    const choice = await prompt("Choose (1/2/3): ");
-    if (choice === "1") {
-      console.log(chalk.dim("\nCreating a new Solana wallet on Kalshi MCP..."));
-      const externalId = await prompt("Enter a unique identifier (e.g., email or username): ");
-      if (!externalId) {
-        console.log(chalk.red("Identifier is required to create an account."));
-        skipKalshi = true;
-      } else {
-        try {
-          const kalshiClient = createMCPClient(KALSHI_MCP_URL, "", "kalshi");
-          const result = await kalshiClient.callTool("kalshi_signup", { externalId });
-          if (result.success && typeof result.data === "object" && result.data !== null) {
-            const data = result.data;
-            kalshiKey = data.apiKey;
-            console.log(chalk.green("\n\u2713 Kalshi wallet created!"));
-            console.log(chalk.dim(`  Solana Address: ${data.walletAddress}`));
-            if (data.apiSecret) {
-              console.log(chalk.yellow("\n\u26A0\uFE0F  Save your API secret (shown only once):"));
-              console.log(chalk.bold.yellow(`   ${String(data.apiSecret)}`));
-              console.log();
-            }
-          } else {
-            console.log(chalk.red("Failed to create Kalshi account: " + (result.error || "Unknown error")));
-            console.log(chalk.dim("You can try again later via the agent."));
-            skipKalshi = true;
-          }
-        } catch (error2) {
-          console.log(chalk.red("Failed to connect to Kalshi MCP."));
-          console.log(chalk.dim(String(error2)));
-          console.log(chalk.dim("You can try again later via the agent."));
-          skipKalshi = true;
-        }
-      }
-    } else if (choice === "2") {
-      kalshiKey = await prompt("Enter your Kalshi API key: ", true);
-    } else {
-      skipKalshi = true;
-    }
-  }
-  if (kalshiKey) {
-    config.setKalshiApiKey(kalshiKey);
-    console.log(chalk.green("\u2713 Kalshi API key saved\n"));
-  } else if (skipKalshi) {
-    console.log(chalk.dim("\u2713 Kalshi disabled - you can set it up later via the agent\n"));
-  } else {
-    console.log(chalk.dim("\u2713 No Kalshi key - you can set it up later\n"));
-  }
-  console.log(chalk.bold("Step 4: Exa API Key (Optional)"));
-  console.log(chalk.dim("Powers web search. Get one free at https://dashboard.exa.ai"));
-  console.log(chalk.dim("Without this, web search will use DuckDuckGo as fallback.\n"));
-  const exaKey = await prompt("Enter your Exa API key (or press Enter to skip): ", true);
-  if (exaKey) {
-    console.log(chalk.green("\u2713 Great! Add this to your shell profile:"));
-    console.log(chalk.cyan(`   export EXA_API_KEY="${exaKey}"`));
-    console.log();
-  } else {
-    console.log(chalk.dim("Skipped. Web search will use DuckDuckGo.\n"));
-  }
-  console.log(chalk.bold("Step 5: Verifying connections..."));
-  try {
-    const discoveryClient = createMCPClient(DISCOVERY_MCP_URL, DISCOVERY_MCP_PUBLIC_KEY, "discovery");
-    const discoveryResult = await discoveryClient.callTool("get_market_stats", {});
-    if (discoveryResult.success) {
-      console.log(chalk.green("\u2713 Discovery MCP connected"));
-    } else {
-      console.log(chalk.yellow("\u26A0 Discovery MCP: " + (discoveryResult.error || "Unknown error")));
-    }
-  } catch (error2) {
-    console.log(chalk.yellow("\u26A0 Could not verify Discovery MCP"));
-    console.log(chalk.dim(String(error2)));
-  }
-  if (quantishKey) {
-    try {
-      const tradingClient = createMCPClient(config.getTradingMcpUrl(), quantishKey, "trading");
-      const result = await tradingClient.callTool("get_wallet_status", {});
-      if (result.success && typeof result.data === "object" && result.data !== null) {
-        const data = result.data;
-        console.log(chalk.green("\u2713 Polymarket MCP connected"));
-        if (data.safeAddress) {
-          console.log(chalk.dim(`  Safe Address: ${data.safeAddress}`));
-          console.log(chalk.dim(`  Status: READY`));
-        } else {
-          console.log(chalk.dim(`  Safe Address: Will deploy on first trade`));
-          console.log(chalk.dim(`  Status: CREATED (wallet ready, Safe deploys on first trade)`));
-        }
-      } else {
-        console.log(chalk.yellow("\u26A0 Polymarket MCP: " + (result.error || "Unknown error")));
-      }
-    } catch (error2) {
-      console.log(chalk.yellow("\u26A0 Could not verify Polymarket MCP connection."));
-      console.log(chalk.dim(String(error2)));
-    }
-  } else {
-    console.log(chalk.dim("\u23ED Polymarket MCP skipped (no API key)"));
-  }
-  if (kalshiKey) {
-    try {
-      const kalshiClient = createMCPClient(KALSHI_MCP_URL, kalshiKey, "kalshi");
-      const result = await kalshiClient.callTool("kalshi_get_wallet_info", {});
-      if (result.success && typeof result.data === "object" && result.data !== null) {
-        const data = result.data;
-        const wallet = data.wallet;
-        const publicKey = wallet?.publicKey;
-        console.log(chalk.green("\u2713 Kalshi MCP connected"));
-        console.log(chalk.dim(`  Solana Address: ${publicKey || "No wallet yet"}`));
-        if (wallet) {
-          console.log(chalk.dim(`  Status: READY`));
-        }
-      } else {
-        console.log(chalk.yellow("\u26A0 Kalshi MCP: " + (result.error || "Unknown error")));
-      }
-    } catch (error2) {
-      console.log(chalk.yellow("\u26A0 Could not verify Kalshi MCP connection."));
-      console.log(chalk.dim(String(error2)));
-    }
-  } else {
-    console.log(chalk.dim("\u23ED Kalshi MCP skipped (no API key)"));
-  }
-  console.log();
-  console.log(chalk.bold.green("\u{1F389} Setup complete!"));
-  console.log();
-  console.log(chalk.bold("\u{1F4C1} Your credentials are saved:"));
-  console.log(chalk.dim(`   Local config: ${config.getConfigPath()}`));
-  console.log(chalk.dim("   Wallet keys:  Encrypted on Quantish server (accessible via your API key)"));
-  console.log();
-  console.log("You can now use Quantish CLI:");
-  console.log(chalk.yellow("  quantish") + " - Start interactive chat");
-  console.log(chalk.yellow('  quantish -p "check my balance"') + " - One-shot command");
-  console.log(chalk.yellow("  quantish tools") + " - List available tools");
-  console.log(chalk.yellow("  quantish config") + " - View configuration");
-  console.log(chalk.yellow("  quantish config --export") + " - Export keys for your own agents");
-  console.log();
-  console.log(chalk.dim("Your wallet is managed by the Quantish Signing Server."));
-  console.log(chalk.dim("The CLOB signing credentials are stored encrypted on the server."));
-  console.log(chalk.dim('To export your private key: quantish -p "export my private key"'));
-  console.log();
-  return true;
-}
-async function ensureConfigured() {
-  const config = getConfigManager();
-  if (!config.isConfigured()) {
-    console.log(chalk.yellow("Quantish CLI is not configured yet.\n"));
-    return await runSetup();
-  }
-  return true;
-}
-
-// src/agent/loop.ts
-import Anthropic2 from "@anthropic-ai/sdk";
-
-// src/tools/filesystem.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-import { existsSync } from "fs";
-async function readFile2(filePath, options) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    if (!existsSync(resolvedPath)) {
-      return { success: false, error: `File not found: ${filePath}` };
-    }
-    const content = await fs.readFile(resolvedPath, "utf-8");
-    if (options?.offset !== void 0 || options?.limit !== void 0) {
-      const lines = content.split("\n");
-      const start = options.offset ?? 0;
-      const end = options.limit ? start + options.limit : lines.length;
-      const selectedLines = lines.slice(start, end);
-      const numbered = selectedLines.map((line, i) => `${(start + i + 1).toString().padStart(6)}|${line}`).join("\n");
-      return { success: true, data: numbered };
-    }
-    return { success: true, data: content };
-  } catch (error2) {
-    return { success: false, error: `Failed to read file: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function writeFile2(filePath, content) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    const dir = path.dirname(resolvedPath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(resolvedPath, content, "utf-8");
-    return { success: true, data: { path: resolvedPath, bytesWritten: Buffer.byteLength(content) } };
-  } catch (error2) {
-    return { success: false, error: `Failed to write file: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function listDir(dirPath, options) {
-  try {
-    const resolvedPath = path.resolve(dirPath);
-    if (!existsSync(resolvedPath)) {
-      return { success: false, error: `Directory not found: ${dirPath}` };
-    }
-    const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
-    const items = entries.map((entry) => ({
-      name: entry.name,
-      type: entry.isDirectory() ? "directory" : "file",
-      path: path.join(resolvedPath, entry.name)
-    }));
-    items.sort((a, b) => {
-      if (a.type === b.type) return a.name.localeCompare(b.name);
-      return a.type === "directory" ? -1 : 1;
-    });
-    return { success: true, data: items };
-  } catch (error2) {
-    return { success: false, error: `Failed to list directory: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function deleteFile(filePath) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    if (!existsSync(resolvedPath)) {
-      return { success: false, error: `File not found: ${filePath}` };
-    }
-    await fs.unlink(resolvedPath);
-    return { success: true, data: { deleted: resolvedPath } };
-  } catch (error2) {
-    return { success: false, error: `Failed to delete file: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function fileExists(filePath) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    const exists = existsSync(resolvedPath);
-    if (exists) {
-      const stats = await fs.stat(resolvedPath);
-      return {
-        success: true,
-        data: {
-          exists: true,
-          type: stats.isDirectory() ? "directory" : "file",
-          size: stats.size,
-          modified: stats.mtime.toISOString()
-        }
-      };
-    }
-    return { success: true, data: { exists: false } };
-  } catch (error2) {
-    return { success: false, error: `Failed to check file: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function workspaceSummary(dirPath, options) {
-  const maxDepth = options?.maxDepth ?? 3;
-  const maxFiles = options?.maxFiles ?? 100;
-  try {
-    const resolvedPath = path.resolve(dirPath);
-    if (!existsSync(resolvedPath)) {
-      return { success: false, error: `Directory not found: ${dirPath}` };
-    }
-    const tree = [];
-    let fileCount = 0;
-    let dirCount = 0;
-    const skipDirs = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target"]);
-    async function walkDir(currentPath, prefix, depth) {
-      if (depth > maxDepth || fileCount >= maxFiles) return;
-      const entries = await fs.readdir(currentPath, { withFileTypes: true });
-      entries.sort((a, b) => {
-        if (a.isDirectory() === b.isDirectory()) return a.name.localeCompare(b.name);
-        return a.isDirectory() ? -1 : 1;
-      });
-      for (let i = 0; i < entries.length && fileCount < maxFiles; i++) {
-        const entry = entries[i];
-        const isLast = i === entries.length - 1;
-        const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-        const newPrefix = isLast ? prefix + "    " : prefix + "\u2502   ";
-        if (entry.isDirectory()) {
-          if (skipDirs.has(entry.name)) {
-            tree.push(`${prefix}${connector}${entry.name}/ (skipped)`);
-          } else {
-            dirCount++;
-            tree.push(`${prefix}${connector}${entry.name}/`);
-            await walkDir(path.join(currentPath, entry.name), newPrefix, depth + 1);
-          }
-        } else {
-          fileCount++;
-          const filePath = path.join(currentPath, entry.name);
-          const stats = await fs.stat(filePath);
-          const size = stats.size < 1024 ? `${stats.size}B` : stats.size < 1024 * 1024 ? `${Math.round(stats.size / 1024)}KB` : `${Math.round(stats.size / (1024 * 1024))}MB`;
-          tree.push(`${prefix}${connector}${entry.name} (${size})`);
-        }
-      }
-    }
-    tree.push(path.basename(resolvedPath) + "/");
-    await walkDir(resolvedPath, "", 1);
-    return {
-      success: true,
-      data: {
-        path: resolvedPath,
-        tree: tree.join("\n"),
-        stats: {
-          totalFiles: fileCount,
-          totalDirectories: dirCount,
-          truncated: fileCount >= maxFiles
-        }
-      }
-    };
-  } catch (error2) {
-    return { success: false, error: `Failed to summarize workspace: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-async function editFile(filePath, oldString, newString, options) {
-  try {
-    const resolvedPath = path.resolve(filePath);
-    if (!existsSync(resolvedPath)) {
-      return { success: false, error: `File not found: ${filePath}` };
-    }
-    const content = await fs.readFile(resolvedPath, "utf-8");
-    if (!content.includes(oldString)) {
-      return {
-        success: false,
-        error: `The string to replace was not found in the file. Make sure to include exact whitespace and formatting.`
-      };
-    }
-    const occurrences = content.split(oldString).length - 1;
-    if (!options?.replaceAll && occurrences > 1) {
-      return {
-        success: false,
-        error: `Found ${occurrences} occurrences of the string. Use replaceAll: true to replace all, or provide a more unique string.`
-      };
-    }
-    const newContent = options?.replaceAll ? content.replaceAll(oldString, newString) : content.replace(oldString, newString);
-    await fs.writeFile(resolvedPath, newContent, "utf-8");
-    return {
-      success: true,
-      data: {
-        path: resolvedPath,
-        replacements: options?.replaceAll ? occurrences : 1,
-        bytesWritten: Buffer.byteLength(newContent)
-      }
-    };
-  } catch (error2) {
-    return { success: false, error: `Failed to edit file: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
-var filesystemTools = [
-  {
-    name: "read_file",
-    description: "Read the contents of a file from the local filesystem. Returns the file content as text. Supports optional line offset and limit for large files.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to the file to read (absolute or relative to current directory)"
-        },
-        offset: {
-          type: "number",
-          description: "Optional: Start reading from this line number (0-indexed)"
-        },
-        limit: {
-          type: "number",
-          description: "Optional: Maximum number of lines to read"
-        }
-      },
-      required: ["path"]
-    }
-  },
-  {
-    name: "write_file",
-    description: "Write content to a file on the local filesystem. Creates the file if it doesn't exist, or overwrites if it does. Creates parent directories as needed.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to the file to write (absolute or relative)"
-        },
-        content: {
-          type: "string",
-          description: "The content to write to the file"
-        }
-      },
-      required: ["path", "content"]
-    }
-  },
-  {
-    name: "list_dir",
-    description: "List files and directories in a given path. Returns entries with name, type (file/directory), and full path.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The directory path to list"
-        }
-      },
-      required: ["path"]
-    }
-  },
-  {
-    name: "delete_file",
-    description: "Delete a file from the local filesystem.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to the file to delete"
-        }
-      },
-      required: ["path"]
-    }
-  },
-  {
-    name: "file_exists",
-    description: "Check if a file or directory exists, and get basic info (type, size, modified date).",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to check"
-        }
-      },
-      required: ["path"]
-    }
-  },
-  {
-    name: "edit_file",
-    description: "Edit a file by replacing a specific string with new content. Safer than write_file as it only modifies the targeted section. The old_string must match exactly (including whitespace).",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to the file to edit"
-        },
-        old_string: {
-          type: "string",
-          description: "The exact string to find and replace. Must be unique in the file unless using replaceAll."
-        },
-        new_string: {
-          type: "string",
-          description: "The new string to replace the old one with"
-        },
-        replace_all: {
-          type: "boolean",
-          description: "If true, replace all occurrences. Default false (only replace first, and fail if multiple found)."
-        }
-      },
-      required: ["path", "old_string", "new_string"]
-    }
-  },
-  {
-    name: "workspace_summary",
-    description: `Get a tree-view summary of a directory. Perfect for understanding project structure after scaffolding or cloning.
-
-Automatically skips: node_modules, .git, dist, build, .next, __pycache__, venv
-
-Shows file sizes and provides a quick overview. Use this after:
-- Running npx create-react-app, npm create vite, etc.
-- Cloning a repo
-- Any command that creates multiple files`,
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The directory path to summarize"
-        },
-        max_depth: {
-          type: "number",
-          description: "Optional: Maximum depth to traverse (default: 3)"
-        },
-        max_files: {
-          type: "number",
-          description: "Optional: Maximum files to show (default: 100)"
-        }
-      },
-      required: ["path"]
-    }
-  }
-];
-async function executeFilesystemTool(name, args) {
-  switch (name) {
-    case "read_file":
-      return readFile2(args.path, {
-        offset: args.offset,
-        limit: args.limit
-      });
-    case "write_file":
-      return writeFile2(args.path, args.content);
-    case "list_dir":
-      return listDir(args.path);
-    case "delete_file":
-      return deleteFile(args.path);
-    case "file_exists":
-      return fileExists(args.path);
-    case "edit_file":
-      return editFile(
-        args.path,
-        args.old_string,
-        args.new_string,
-        { replaceAll: args.replace_all }
-      );
-    case "workspace_summary":
-      return workspaceSummary(args.path, {
-        maxDepth: args.max_depth,
-        maxFiles: args.max_files
-      });
-    default:
-      return { success: false, error: `Unknown filesystem tool: ${name}` };
-  }
-}
-
-// src/tools/shell.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-
-// src/tools/process-manager.ts
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var ProcessManager = class extends EventEmitter {
-  processes = /* @__PURE__ */ new Map();
-  nextId = 1;
-  maxOutputLines = 100;
-  constructor() {
-    super();
-  }
-  /**
-   * Spawn a new background process
-   */
-  spawn(command, options = {}) {
-    const id = this.nextId++;
-    const cwd = options.cwd || process.cwd();
-    const name = options.name || command.split(" ")[0];
-    const child = spawn("bash", ["-c", command], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: false,
-      // Keep attached so we can track it
-      env: { ...process.env, FORCE_COLOR: "1" }
-      // Enable colors
-    });
-    const spawnedProcess = {
-      id,
-      pid: child.pid,
-      command,
-      name,
-      cwd,
-      startedAt: /* @__PURE__ */ new Date(),
-      status: "running",
-      child,
-      outputBuffer: [],
-      lastOutput: [],
-      onOutput: options.onOutput
-    };
-    child.stdout?.on("data", (data) => {
-      const lines = data.toString().split("\n").filter(Boolean);
-      for (const line of lines) {
-        this.addOutput(spawnedProcess, line);
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      const lines = data.toString().split("\n").filter(Boolean);
-      for (const line of lines) {
-        this.addOutput(spawnedProcess, `[stderr] ${line}`);
-      }
-    });
-    child.on("exit", (code, signal) => {
-      spawnedProcess.status = code === 0 ? "stopped" : "error";
-      this.addOutput(spawnedProcess, `[Process exited with code ${code}${signal ? `, signal ${signal}` : ""}]`);
-      this.emit("exit", id, code, signal);
-    });
-    child.on("error", (err) => {
-      spawnedProcess.status = "error";
-      this.addOutput(spawnedProcess, `[Error: ${err.message}]`);
-      this.emit("error", id, err);
-    });
-    this.processes.set(id, spawnedProcess);
-    this.emit("spawn", id, spawnedProcess);
-    return this.getProcessInfo(spawnedProcess);
-  }
-  /**
-   * Add output to process buffer
-   */
-  addOutput(process2, line) {
-    process2.outputBuffer.push(line);
-    process2.lastOutput.push(line);
-    if (process2.outputBuffer.length > this.maxOutputLines) {
-      process2.outputBuffer.shift();
-    }
-    if (process2.lastOutput.length > 20) {
-      process2.lastOutput.shift();
-    }
-    process2.onOutput?.(line);
-    this.emit("output", process2.id, line);
-  }
-  /**
-   * Get process info without the child process object
-   */
-  getProcessInfo(process2) {
-    return {
-      id: process2.id,
-      pid: process2.pid,
-      command: process2.command,
-      name: process2.name,
-      cwd: process2.cwd,
-      startedAt: process2.startedAt,
-      status: process2.status,
-      lastOutput: [...process2.lastOutput]
-    };
-  }
-  /**
-   * Kill a process by ID
-   */
-  kill(id) {
-    const process2 = this.processes.get(id);
-    if (!process2) {
-      return false;
-    }
-    if (process2.status !== "running") {
-      return true;
-    }
-    try {
-      process2.child.kill("SIGTERM");
-      setTimeout(() => {
-        if (process2.status === "running") {
-          process2.child.kill("SIGKILL");
-        }
-      }, 3e3);
-      process2.status = "stopped";
-      this.emit("kill", id);
-      return true;
-    } catch (error2) {
-      return false;
-    }
-  }
-  /**
-   * Kill all running processes
-   */
-  killAll() {
-    for (const [id, process2] of this.processes) {
-      if (process2.status === "running") {
-        this.kill(id);
-      }
-    }
-  }
-  /**
-   * List all processes
-   */
-  list() {
-    return Array.from(this.processes.values()).map((p) => this.getProcessInfo(p));
-  }
-  /**
-   * List running processes only
-   */
-  listRunning() {
-    return this.list().filter((p) => p.status === "running");
-  }
-  /**
-   * Get a specific process
-   */
-  get(id) {
-    const process2 = this.processes.get(id);
-    return process2 ? this.getProcessInfo(process2) : void 0;
-  }
-  /**
-   * Get recent output from a process
-   */
-  getOutput(id, lines = 20) {
-    const process2 = this.processes.get(id);
-    if (!process2) {
-      return [];
-    }
-    return process2.outputBuffer.slice(-lines);
-  }
-  /**
-   * Check if any processes are running
-   */
-  hasRunning() {
-    return this.listRunning().length > 0;
-  }
-  /**
-   * Get count of running processes
-   */
-  runningCount() {
-    return this.listRunning().length;
-  }
-  /**
-   * Set output callback for a process
-   */
-  setOutputCallback(id, callback) {
-    const process2 = this.processes.get(id);
-    if (process2) {
-      process2.onOutput = callback;
-    }
-  }
-};
-var processManager = new ProcessManager();
-
-// src/tools/shell.ts
-var execPromise = promisify(exec);
-var BLOCKED_COMMANDS = [
-  "rm -rf /",
-  "rm -rf ~",
-  "rm -rf /*",
-  "mkfs",
-  "dd if=/dev/zero",
-  ":(){:|:&};:",
-  // Fork bomb
-  "chmod -R 777 /",
-  "chown -R"
-];
-var DANGEROUS_PATTERNS = [
-  /rm\s+-rf?\s+/,
-  /sudo\s+/,
-  />\s*\/dev\//,
-  /chmod\s+.*\s+\//
-];
-var PACKAGE_MANAGER_PATTERNS = [
-  /^(npm|yarn|pnpm|bun)\s+(install|i|add|ci|update|upgrade)/,
-  /^(pip|pip3)\s+install/,
-  /^cargo\s+(build|install)/,
-  /^go\s+(build|get|mod)/
-];
-var SCAFFOLDING_PATTERNS = [
-  /^npx\s+(--yes\s+)?create-/,
-  // npx create-react-app, npx create-next-app
-  /^npx\s+(--yes\s+)?@\w+\/create-/,
-  // npx @vue/create-app, etc.
-  /^bunx\s+create-/,
-  // bunx create-react-app
-  /^pnpm\s+(dlx\s+)?create-/,
-  // pnpm create vite
-  /^npm\s+create\s+/,
-  // npm create vite@latest
-  /^yarn\s+create\s+/,
-  // yarn create react-app
-  /^npx\s+degit/,
-  // npx degit for templates
-  /^npx\s+(--yes\s+)?(vite|astro|nuxt|remix|svelte)/
-  // Direct scaffolding
-];
-var LONG_RUNNING_PATTERNS = [
-  /^(npm|yarn|pnpm|bun)\s+(build|test|run)/,
-  /webpack|vite|esbuild|rollup/,
-  /docker\s+(build|pull|push)/,
-  /^npx\s+/
-  // Most npx commands need more time than 30s default
-];
-function getSmartTimeout(command, explicitTimeout) {
-  if (explicitTimeout !== void 0) {
-    return explicitTimeout;
-  }
-  for (const pattern of SCAFFOLDING_PATTERNS) {
-    if (pattern.test(command)) {
-      return 6e5;
-    }
-  }
-  for (const pattern of PACKAGE_MANAGER_PATTERNS) {
-    if (pattern.test(command)) {
-      return 3e5;
-    }
-  }
-  for (const pattern of LONG_RUNNING_PATTERNS) {
-    if (pattern.test(command)) {
-      return 18e4;
-    }
-  }
-  return 3e4;
-}
-function checkCommand(command) {
-  for (const blocked of BLOCKED_COMMANDS) {
-    if (command.includes(blocked)) {
-      return { allowed: false, reason: `Blocked command pattern: ${blocked}` };
-    }
-  }
-  for (const pattern of DANGEROUS_PATTERNS) {
-    if (pattern.test(command)) {
-      return { allowed: false, reason: `Dangerous command pattern detected. Use allowDangerous option to override.` };
-    }
-  }
-  return { allowed: true };
-}
-async function runCommand(command, options = {}) {
-  const {
-    cwd = process.cwd(),
-    timeout: explicitTimeout,
-    maxBuffer = 10 * 1024 * 1024,
-    // 10MB
-    allowDangerous = false
-  } = options;
-  const timeout = getSmartTimeout(command, explicitTimeout);
-  if (!allowDangerous) {
-    const check = checkCommand(command);
-    if (!check.allowed) {
-      return { success: false, error: check.reason };
-    }
-  }
-  try {
-    const { stdout, stderr } = await execPromise(command, {
-      cwd,
-      timeout,
-      maxBuffer,
-      shell: "/bin/bash",
-      // Explicit bash for compound command support
-      env: { ...process.env }
-    });
-    return {
-      success: true,
-      data: {
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        command,
-        cwd,
-        timeoutUsed: timeout
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    if (execError.killed) {
-      return {
-        success: false,
-        error: `Command timed out after ${timeout / 1e3}s. For long-running commands, use start_background_process or increase timeout.`,
-        data: {
-          stdout: execError.stdout || "",
-          stderr: execError.stderr || "",
-          timedOut: true
-        }
-      };
-    }
-    return {
-      success: false,
-      error: execError.message || "Command failed",
-      data: {
-        stdout: execError.stdout || "",
-        stderr: execError.stderr || "",
-        exitCode: execError.code
-      }
-    };
-  }
-}
-async function grep(pattern, path2, options = {}) {
-  const { ignoreCase = false, contextLines = 0 } = options;
-  const rgArgs = [
-    pattern,
-    path2,
-    "--no-heading",
-    "--line-number",
-    "--color=never"
-  ];
-  if (ignoreCase) rgArgs.push("-i");
-  if (contextLines > 0) rgArgs.push(`-C${contextLines}`);
-  try {
-    const { stdout } = await execPromise(`rg ${rgArgs.join(" ")}`, {
-      timeout: 3e4,
-      maxBuffer: 10 * 1024 * 1024
-    });
-    return {
-      success: true,
-      data: {
-        matches: stdout.trim().split("\n").filter(Boolean),
-        pattern,
-        path: path2
-      }
-    };
-  } catch {
-    try {
-      const grepArgs = [
-        ignoreCase ? "-i" : "",
-        contextLines > 0 ? `-C${contextLines}` : "",
-        "-rn",
-        pattern,
-        path2
-      ].filter(Boolean);
-      const { stdout } = await execPromise(`grep ${grepArgs.join(" ")}`, {
-        timeout: 3e4,
-        maxBuffer: 10 * 1024 * 1024
-      });
-      return {
-        success: true,
-        data: {
-          matches: stdout.trim().split("\n").filter(Boolean),
-          pattern,
-          path: path2
-        }
-      };
-    } catch (error2) {
-      const execError = error2;
-      if (execError.code === 1) {
-        return { success: true, data: { matches: [], pattern, path: path2 } };
-      }
-      return { success: false, error: `Search failed: ${execError.message}` };
-    }
-  }
-}
-async function findFiles(pattern, directory = ".") {
-  try {
-    const { stdout } = await execPromise(
-      `find "${directory}" -name "${pattern}" -type f 2>/dev/null | head -100`,
-      { timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }
-    );
-    return {
-      success: true,
-      data: {
-        files: stdout.trim().split("\n").filter(Boolean),
-        pattern,
-        directory
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Find failed: ${execError.message}` };
-  }
-}
-var shellTools = [
-  {
-    name: "run_command",
-    description: `Execute a shell command on the local machine. Returns stdout, stderr, and exit code. 
-
-SMART TIMEOUTS (auto-detected):
-- 10 min: npx create-react-app, npm create vite, etc (scaffolding)
-- 5 min: npm install, yarn add, pip install (package installs)
-- 3 min: npm build, webpack, docker build (build commands)
-- 30 sec: all other commands
-
-BEST PRACTICES:
-- For dev servers (npm start, npm run dev), use start_background_process instead
-- After creating a project, use list_dir to verify the files were created
-- Add --yes to npx commands to skip prompts (e.g., "npx --yes create-react-app myapp")
-- Compound commands (&&, ||, |) are supported`,
-    input_schema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: "The shell command to execute. Compound commands with && and || are supported."
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory for the command (defaults to current directory)"
-        },
-        timeout: {
-          type: "number",
-          description: "Optional: Override timeout in milliseconds. Usually not needed - smart defaults handle most cases."
-        }
-      },
-      required: ["command"]
-    }
-  },
-  {
-    name: "grep",
-    description: "Search for a text pattern in files. Uses ripgrep if available, falls back to grep. Returns matching lines with file paths and line numbers.",
-    input_schema: {
-      type: "object",
-      properties: {
-        pattern: {
-          type: "string",
-          description: "The regex pattern to search for"
-        },
-        path: {
-          type: "string",
-          description: "The file or directory to search in"
-        },
-        ignore_case: {
-          type: "boolean",
-          description: "Optional: Case-insensitive search (default: false)"
-        },
-        context_lines: {
-          type: "number",
-          description: "Optional: Number of context lines before and after matches"
-        }
-      },
-      required: ["pattern", "path"]
-    }
-  },
-  {
-    name: "find_files",
-    description: "Find files by name pattern (glob). Returns up to 100 matching file paths.",
-    input_schema: {
-      type: "object",
-      properties: {
-        pattern: {
-          type: "string",
-          description: 'The glob pattern to match (e.g., "*.ts", "package.json")'
-        },
-        directory: {
-          type: "string",
-          description: "Optional: Directory to search in (default: current directory)"
-        }
-      },
-      required: ["pattern"]
-    }
-  },
-  {
-    name: "start_background_process",
-    description: `Start a long-running process in the background. Returns immediately with a process ID.
-
-USE THIS FOR (runs indefinitely):
-- Dev servers: npm start, npm run dev, yarn dev
-- Watch modes: npm run watch, tsc --watch
-- Local servers: python -m http.server, serve -s build
-- Database servers: mongod, redis-server
-
-DO NOT USE FOR (use run_command instead):
-- One-time installs: npm install, pip install
-- Project scaffolding: npx create-react-app
-- Build commands: npm run build
-
-Returns a process ID to use with stop_process and get_process_output.`,
-    input_schema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: 'The command to run (e.g., "npm start", "python -m http.server 8000")'
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory for the process"
-        },
-        name: {
-          type: "string",
-          description: 'Optional: Friendly name for the process (e.g., "React Dev Server")'
-        }
-      },
-      required: ["command"]
-    }
-  },
-  {
-    name: "stop_process",
-    description: "Stop a background process by its process ID. Use list_processes to see running processes.",
-    input_schema: {
-      type: "object",
-      properties: {
-        process_id: {
-          type: "number",
-          description: "The process ID returned by start_background_process"
-        }
-      },
-      required: ["process_id"]
-    }
-  },
-  {
-    name: "list_processes",
-    description: "List all background processes started by this session, including their status and recent output.",
-    input_schema: {
-      type: "object",
-      properties: {},
-      required: []
-    }
-  },
-  {
-    name: "get_process_output",
-    description: "Get recent output from a background process.",
-    input_schema: {
-      type: "object",
-      properties: {
-        process_id: {
-          type: "number",
-          description: "The process ID"
-        },
-        lines: {
-          type: "number",
-          description: "Number of output lines to retrieve (default: 20)"
-        }
-      },
-      required: ["process_id"]
-    }
-  }
-];
-function startBackgroundProcess(command, options = {}) {
-  try {
-    const processInfo = processManager.spawn(command, {
-      cwd: options.cwd,
-      name: options.name
-    });
-    return {
-      success: true,
-      data: {
-        processId: processInfo.id,
-        pid: processInfo.pid,
-        name: processInfo.name,
-        command: processInfo.command,
-        message: `Started background process "${processInfo.name}" (ID: ${processInfo.id}, PID: ${processInfo.pid}). Use stop_process with ID ${processInfo.id} to stop it.`
-      }
-    };
-  } catch (error2) {
-    const err = error2;
-    return { success: false, error: `Failed to start background process: ${err.message}` };
-  }
-}
-function stopProcess(processId) {
-  const process2 = processManager.get(processId);
-  if (!process2) {
-    return { success: false, error: `Process with ID ${processId} not found` };
-  }
-  const killed = processManager.kill(processId);
-  if (killed) {
-    return {
-      success: true,
-      data: {
-        processId,
-        name: process2.name,
-        message: `Stopped process "${process2.name}" (ID: ${processId})`
-      }
-    };
-  } else {
-    return { success: false, error: `Failed to stop process ${processId}` };
-  }
-}
-function listProcesses() {
-  const processes = processManager.list();
-  const running = processes.filter((p) => p.status === "running");
-  const stopped = processes.filter((p) => p.status !== "running");
-  return {
-    success: true,
-    data: {
-      running: running.map((p) => ({
-        id: p.id,
-        pid: p.pid,
-        name: p.name,
-        command: p.command,
-        startedAt: p.startedAt.toISOString(),
-        uptime: Math.round((Date.now() - p.startedAt.getTime()) / 1e3) + "s"
-      })),
-      stopped: stopped.map((p) => ({
-        id: p.id,
-        name: p.name,
-        status: p.status
-      })),
-      summary: `${running.length} running, ${stopped.length} stopped`
-    }
-  };
-}
-function getProcessOutput(processId, lines = 20) {
-  const process2 = processManager.get(processId);
-  if (!process2) {
-    return { success: false, error: `Process with ID ${processId} not found` };
-  }
-  const output = processManager.getOutput(processId, lines);
-  return {
-    success: true,
-    data: {
-      processId,
-      name: process2.name,
-      status: process2.status,
-      output,
-      lineCount: output.length
-    }
-  };
-}
-async function executeShellTool(name, args) {
-  switch (name) {
-    case "run_command":
-      return runCommand(args.command, {
-        cwd: args.cwd,
-        timeout: args.timeout
-      });
-    case "grep":
-      return grep(args.pattern, args.path, {
-        ignoreCase: args.ignore_case,
-        contextLines: args.context_lines
-      });
-    case "find_files":
-      return findFiles(args.pattern, args.directory);
-    case "start_background_process":
-      return startBackgroundProcess(args.command, {
-        cwd: args.cwd,
-        name: args.name
-      });
-    case "stop_process":
-      return stopProcess(args.process_id);
-    case "list_processes":
-      return listProcesses();
-    case "get_process_output":
-      return getProcessOutput(args.process_id, args.lines);
-    default:
-      return { success: false, error: `Unknown shell tool: ${name}` };
-  }
-}
-
-// src/tools/git.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execPromise2 = promisify2(exec2);
-async function gitExec(command, cwd) {
-  return execPromise2(`git ${command}`, {
-    cwd: cwd || process.cwd(),
-    timeout: 3e4,
-    maxBuffer: 10 * 1024 * 1024
-  });
-}
-async function gitStatus(cwd) {
-  try {
-    const { stdout } = await gitExec("status --porcelain", cwd);
-    const { stdout: branch } = await gitExec("branch --show-current", cwd);
-    const files = stdout.trim().split("\n").filter(Boolean).map((line) => {
-      const status = line.slice(0, 2);
-      const file = line.slice(3);
-      return { status: status.trim(), file };
-    });
-    return {
-      success: true,
-      data: {
-        branch: branch.trim(),
-        files,
-        clean: files.length === 0
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git status failed: ${execError.message}` };
-  }
-}
-async function gitDiff(options, cwd) {
-  try {
-    const args = ["diff"];
-    if (options?.staged) args.push("--staged");
-    if (options?.file) args.push(options.file);
-    const { stdout } = await gitExec(args.join(" "), cwd);
-    return {
-      success: true,
-      data: {
-        diff: stdout,
-        hasChanges: stdout.trim().length > 0
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git diff failed: ${execError.message}` };
-  }
-}
-async function gitAdd(files, cwd) {
-  try {
-    const fileList = Array.isArray(files) ? files.join(" ") : files;
-    await gitExec(`add ${fileList}`, cwd);
-    return {
-      success: true,
-      data: { added: Array.isArray(files) ? files : [files] }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git add failed: ${execError.message}` };
-  }
-}
-async function gitCommit(message, cwd) {
-  try {
-    const { stdout } = await gitExec(`commit -m "${message.replace(/"/g, '\\"')}"`, cwd);
-    const match = stdout.match(/\[[\w-]+\s+([a-f0-9]+)\]/);
-    const hash = match ? match[1] : void 0;
-    return {
-      success: true,
-      data: {
-        message,
-        hash,
-        output: stdout.trim()
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git commit failed: ${execError.message}` };
-  }
-}
-async function gitLog(options, cwd) {
-  try {
-    const args = ["log"];
-    if (options?.count) args.push(`-${options.count}`);
-    if (options?.oneline) args.push("--oneline");
-    const { stdout } = await gitExec(args.join(" "), cwd);
-    const commits = stdout.trim().split("\n").filter(Boolean);
-    return {
-      success: true,
-      data: { commits }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git log failed: ${execError.message}` };
-  }
-}
-async function gitCheckout(target, options, cwd) {
-  try {
-    const args = ["checkout"];
-    if (options?.create) args.push("-b");
-    args.push(target);
-    const { stdout, stderr } = await gitExec(args.join(" "), cwd);
-    return {
-      success: true,
-      data: {
-        target,
-        created: options?.create || false,
-        output: (stdout || stderr).trim()
-      }
-    };
-  } catch (error2) {
-    const execError = error2;
-    return { success: false, error: `Git checkout failed: ${execError.message}` };
-  }
-}
-var gitTools = [
-  {
-    name: "git_status",
-    description: "Get the current git status including branch name, modified files, and staged changes.",
-    input_schema: {
-      type: "object",
-      properties: {
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory (defaults to current)"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "git_diff",
-    description: "Show git diff of changes. Can show staged or unstaged changes, and optionally for a specific file.",
-    input_schema: {
-      type: "object",
-      properties: {
-        staged: {
-          type: "boolean",
-          description: "Show staged changes only (default: false, shows unstaged)"
-        },
-        file: {
-          type: "string",
-          description: "Optional: Show diff for a specific file only"
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "git_add",
-    description: 'Stage files for commit. Can stage specific files or use "." to stage all.',
-    input_schema: {
-      type: "object",
-      properties: {
-        files: {
-          oneOf: [
-            { type: "string" },
-            { type: "array", items: { type: "string" } }
-          ],
-          description: 'File(s) to stage. Use "." for all files.'
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory"
-        }
-      },
-      required: ["files"]
-    }
-  },
-  {
-    name: "git_commit",
-    description: "Create a git commit with the staged changes.",
-    input_schema: {
-      type: "object",
-      properties: {
-        message: {
-          type: "string",
-          description: "The commit message"
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory"
-        }
-      },
-      required: ["message"]
-    }
-  },
-  {
-    name: "git_log",
-    description: "Show recent git commits.",
-    input_schema: {
-      type: "object",
-      properties: {
-        count: {
-          type: "number",
-          description: "Number of commits to show (default: 10)"
-        },
-        oneline: {
-          type: "boolean",
-          description: "Show compact one-line format (default: false)"
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "git_checkout",
-    description: "Switch branches or restore files. Can create a new branch with the create option.",
-    input_schema: {
-      type: "object",
-      properties: {
-        target: {
-          type: "string",
-          description: "Branch name or commit to checkout"
-        },
-        create: {
-          type: "boolean",
-          description: "Create a new branch (default: false)"
-        },
-        cwd: {
-          type: "string",
-          description: "Optional: Working directory"
-        }
-      },
-      required: ["target"]
-    }
-  }
-];
-async function executeGitTool(name, args) {
-  const cwd = args.cwd;
-  switch (name) {
-    case "git_status":
-      return gitStatus(cwd);
-    case "git_diff":
-      return gitDiff({
-        staged: args.staged,
-        file: args.file
-      }, cwd);
-    case "git_add":
-      return gitAdd(args.files, cwd);
-    case "git_commit":
-      return gitCommit(args.message, cwd);
-    case "git_log":
-      return gitLog({
-        count: args.count,
-        oneline: args.oneline
-      }, cwd);
-    case "git_checkout":
-      return gitCheckout(args.target, {
-        create: args.create
-      }, cwd);
-    default:
-      return { success: false, error: `Unknown git tool: ${name}` };
-  }
-}
-
-// src/tools/web.ts
-async function searchWithExa(query, apiKey, options = {}) {
-  const { maxResults = 10, includeText = true } = options;
-  try {
-    const response = await fetch("https://api.exa.ai/search", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey
-      },
-      body: JSON.stringify({
-        query,
-        numResults: maxResults,
-        type: "auto",
-        // Let Exa decide between neural and keyword search
-        contents: includeText ? {
-          text: {
-            maxCharacters: 1e3
-            // Limit text length per result
-          }
-        } : void 0
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Exa API error: ${response.status} - ${errorText}`);
-    }
-    const data = await response.json();
-    return {
-      success: true,
-      data: {
-        query,
-        source: "exa",
-        results: data.results.map((r) => ({
-          title: r.title,
-          url: r.url,
-          snippet: r.text?.slice(0, 500) || "",
-          publishedDate: r.publishedDate,
-          author: r.author
-        }))
-      }
-    };
-  } catch (error2) {
-    return {
-      success: false,
-      error: `Exa search failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-    };
-  }
-}
-async function answerWithExa(query, apiKey) {
-  try {
-    const response = await fetch("https://api.exa.ai/answer", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey
-      },
-      body: JSON.stringify({
-        query,
-        text: true
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Exa Answer API error: ${response.status} - ${errorText}`);
-    }
-    const data = await response.json();
-    return {
-      success: true,
-      data: {
-        query,
-        source: "exa",
-        answer: data.answer,
-        citations: data.citations?.map((c) => ({
-          title: c.title,
-          url: c.url
-        })) || []
-      }
-    };
-  } catch (error2) {
-    return {
-      success: false,
-      error: `Exa answer failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-    };
-  }
-}
-async function searchWithDuckDuckGo(query, options = {}) {
-  const { maxResults = 10 } = options;
-  try {
-    const response = await fetch(
-      `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
-      {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
-        }
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`DuckDuckGo error: ${response.status}`);
-    }
-    const html = await response.text();
-    const results = [];
-    const resultPattern = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>/g;
-    const snippetPattern = /<a[^>]*class="result__snippet"[^>]*>([^<]*)/g;
-    let linkMatch;
-    const snippets = [];
-    let snippetMatch;
-    while ((snippetMatch = snippetPattern.exec(html)) !== null) {
-      snippets.push(snippetMatch[1].trim());
-    }
-    let i = 0;
-    while ((linkMatch = resultPattern.exec(html)) !== null && results.length < maxResults) {
-      let url = linkMatch[1];
-      const uddgMatch = url.match(/uddg=([^&]+)/);
-      if (uddgMatch) {
-        url = decodeURIComponent(uddgMatch[1]);
-      }
-      results.push({
-        title: linkMatch[2].trim(),
-        url,
-        snippet: snippets[i] || ""
-      });
-      i++;
-    }
-    if (results.length === 0) {
-      return {
-        success: true,
-        data: {
-          query,
-          source: "duckduckgo",
-          results: [],
-          note: "No results found. DuckDuckGo may be rate-limiting. Consider setting EXA_API_KEY for better results."
-        }
-      };
-    }
-    return {
-      success: true,
-      data: {
-        query,
-        source: "duckduckgo",
-        results,
-        note: "Using DuckDuckGo (free). Set EXA_API_KEY for better AI-powered search results."
-      }
-    };
-  } catch (error2) {
-    return {
-      success: false,
-      error: `DuckDuckGo search failed: ${error2 instanceof Error ? error2.message : String(error2)}`
-    };
-  }
-}
-async function webSearch(query, options = {}) {
-  const exaKey = process.env.EXA_API_KEY;
-  if (exaKey) {
-    return searchWithExa(query, exaKey, options);
-  }
-  return searchWithDuckDuckGo(query, options);
-}
-async function webAnswer(query) {
-  const exaKey = process.env.EXA_API_KEY;
-  if (!exaKey) {
-    return {
-      success: false,
-      error: "EXA_API_KEY is required for web_answer. Get one at https://dashboard.exa.ai"
-    };
-  }
-  return answerWithExa(query, exaKey);
-}
-async function fetchUrl(url, options = {}) {
-  const { maxLength = 5e4 } = options;
-  try {
-    const response = await fetch(url, {
-      headers: {
-        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    const contentType = response.headers.get("content-type") || "";
-    let content = await response.text();
-    if (content.length > maxLength) {
-      content = content.slice(0, maxLength) + "\n\n[Content truncated...]";
-    }
-    if (contentType.includes("text/html")) {
-      content = content.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-    }
-    return {
-      success: true,
-      data: {
-        url,
-        contentType,
-        length: content.length,
-        content
-      }
-    };
-  } catch (error2) {
-    return {
-      success: false,
-      error: `Failed to fetch URL: ${error2 instanceof Error ? error2.message : String(error2)}`
-    };
-  }
-}
-var webTools = [
-  {
-    name: "web_search",
-    description: "Search the web for information. Returns titles, URLs, and snippets from search results. Uses Exa AI search if EXA_API_KEY is set (recommended), otherwise falls back to DuckDuckGo.",
-    input_schema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "The search query"
-        },
-        max_results: {
-          type: "number",
-          description: "Maximum number of results to return (default: 10)"
-        }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: "web_answer",
-    description: "Get an AI-generated answer to a question with citations, powered by Exa. Requires EXA_API_KEY. Best for factual questions that need grounded answers.",
-    input_schema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "The question to answer"
-        }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: "fetch_url",
-    description: "Fetch the content of a URL. Returns the text content of the page. Useful for reading articles, documentation, or any web page.",
-    input_schema: {
-      type: "object",
-      properties: {
-        url: {
-          type: "string",
-          description: "The URL to fetch"
-        },
-        max_length: {
-          type: "number",
-          description: "Maximum content length to return (default: 50000 characters)"
-        }
-      },
-      required: ["url"]
-    }
-  }
-];
-async function executeWebTool(name, args) {
-  switch (name) {
-    case "web_search":
-      return webSearch(args.query, {
-        maxResults: args.max_results
-      });
-    case "web_answer":
-      return webAnswer(args.query);
-    case "fetch_url":
-      return fetchUrl(args.url, {
-        maxLength: args.max_length
-      });
-    default:
-      return { success: false, error: `Unknown web tool: ${name}` };
-  }
-}
-
-// src/tools/index.ts
-var localTools = [
-  ...filesystemTools,
-  ...shellTools,
-  ...gitTools,
-  ...webTools
-];
-var localToolNames = new Set(localTools.map((t) => t.name));
-function isLocalTool(name) {
-  return localToolNames.has(name);
-}
-async function executeLocalTool(name, args) {
-  if (filesystemTools.some((t) => t.name === name)) {
-    return executeFilesystemTool(name, args);
-  }
-  if (shellTools.some((t) => t.name === name)) {
-    return executeShellTool(name, args);
-  }
-  if (gitTools.some((t) => t.name === name)) {
-    return executeGitTool(name, args);
-  }
-  if (webTools.some((t) => t.name === name)) {
-    return executeWebTool(name, args);
-  }
-  return { success: false, error: `Unknown local tool: ${name}` };
-}
-
-// src/agent/pricing.ts
-var MODELS = {
-  "claude-opus-4-5-20250929": {
-    id: "claude-opus-4-5-20250929",
-    name: "opus-4.5",
-    displayName: "Claude Opus 4.5",
-    pricing: {
-      inputPerMTok: 5,
-      outputPerMTok: 25,
-      cacheWritePerMTok: 6.25,
-      // 1.25x input
-      cacheReadPerMTok: 0.5
-      // 0.1x input
-    },
-    contextWindow: 2e5,
-    description: "Most capable model. Best for complex reasoning and creative tasks."
-  },
-  "claude-sonnet-4-5-20250929": {
-    id: "claude-sonnet-4-5-20250929",
-    name: "sonnet-4.5",
-    displayName: "Claude Sonnet 4.5",
-    pricing: {
-      inputPerMTok: 3,
-      outputPerMTok: 15,
-      cacheWritePerMTok: 3.75,
-      // 1.25x input
-      cacheReadPerMTok: 0.3
-      // 0.1x input
-    },
-    contextWindow: 2e5,
-    description: "Balanced performance and cost. Great for most coding and trading tasks."
-  },
-  "claude-haiku-4-5-20250929": {
-    id: "claude-haiku-4-5-20250929",
-    name: "haiku-4.5",
-    displayName: "Claude Haiku 4.5",
-    pricing: {
-      inputPerMTok: 1,
-      outputPerMTok: 5,
-      cacheWritePerMTok: 1.25,
-      // 1.25x input
-      cacheReadPerMTok: 0.1
-      // 0.1x input
-    },
-    contextWindow: 2e5,
-    description: "Fastest and most economical. Good for simple tasks and high volume."
-  }
-};
-var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
-var MODEL_ALIASES = {
-  "opus": "claude-opus-4-5-20250929",
-  "opus-4.5": "claude-opus-4-5-20250929",
-  "sonnet": "claude-sonnet-4-5-20250929",
-  "sonnet-4.5": "claude-sonnet-4-5-20250929",
-  "haiku": "claude-haiku-4-5-20250929",
-  "haiku-4.5": "claude-haiku-4-5-20250929"
-};
-function resolveModelId(nameOrAlias) {
-  const lower = nameOrAlias.toLowerCase();
-  if (MODELS[lower]) {
-    return lower;
-  }
-  if (MODEL_ALIASES[lower]) {
-    return MODEL_ALIASES[lower];
-  }
-  for (const [id, config] of Object.entries(MODELS)) {
-    if (config.name.toLowerCase() === lower) {
-      return id;
-    }
-  }
-  return null;
-}
-function getModelPricing(modelId) {
-  const anthropicModel = MODELS[modelId];
-  if (anthropicModel?.pricing) {
-    return anthropicModel.pricing;
-  }
-  const openrouterModel = OPENROUTER_MODELS[modelId];
-  if (openrouterModel?.pricing) {
-    return openrouterModel.pricing;
-  }
-  return null;
-}
-function getModelConfig(modelId) {
-  return MODELS[modelId] ?? OPENROUTER_MODELS[modelId] ?? null;
-}
-function calculateCost(modelId, inputTokens, outputTokens, cacheCreationTokens = 0, cacheReadTokens = 0) {
-  const pricing = getModelPricing(modelId);
-  if (!pricing) {
-    const defaultPricing = MODELS[DEFAULT_MODEL].pricing;
-    return calculateCostWithPricing(
-      defaultPricing,
-      inputTokens,
-      outputTokens,
-      cacheCreationTokens,
-      cacheReadTokens
-    );
-  }
-  return calculateCostWithPricing(
-    pricing,
-    inputTokens,
-    outputTokens,
-    cacheCreationTokens,
-    cacheReadTokens
-  );
-}
-function calculateCostWithPricing(pricing, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens) {
-  const inputCost = inputTokens / 1e6 * pricing.inputPerMTok;
-  const outputCost = outputTokens / 1e6 * pricing.outputPerMTok;
-  const cacheWriteCost = cacheCreationTokens / 1e6 * pricing.cacheWritePerMTok;
-  const cacheReadCost = cacheReadTokens / 1e6 * pricing.cacheReadPerMTok;
-  return {
-    inputCost,
-    outputCost,
-    cacheWriteCost,
-    cacheReadCost,
-    totalCost: inputCost + outputCost + cacheWriteCost + cacheReadCost
-  };
-}
-function formatCost(cost) {
-  if (cost < 0.01) {
-    const cents = cost * 100;
-    return `${cents.toFixed(3)}\xA2`;
-  }
-  if (cost < 1) {
-    return `$${cost.toFixed(4)}`;
-  }
-  return `$${cost.toFixed(2)}`;
-}
-function listModels() {
-  return Object.values(MODELS);
-}
-var OPENROUTER_MODELS = {
-  "z-ai/glm-4.7": {
-    id: "z-ai/glm-4.7",
-    name: "glm-4.7",
-    displayName: "GLM 4.7",
-    pricing: {
-      inputPerMTok: 0.4,
-      outputPerMTok: 1.5,
-      cacheWritePerMTok: 0,
-      cacheReadPerMTok: 0
-    },
-    contextWindow: 202752,
-    description: "Z.AI flagship. Enhanced programming, multi-step reasoning, agent tasks."
-  },
-  "minimax/minimax-m2.1": {
-    id: "minimax/minimax-m2.1",
-    name: "minimax-m2.1",
-    displayName: "MiniMax M2.1",
-    pricing: {
-      inputPerMTok: 0.3,
-      outputPerMTok: 1.2,
-      cacheWritePerMTok: 0,
-      cacheReadPerMTok: 0
-    },
-    contextWindow: 204800,
-    description: "Lightweight, optimized for coding and agentic workflows."
-  },
-  "deepseek/deepseek-chat": {
-    id: "deepseek/deepseek-chat",
-    name: "deepseek-chat",
-    displayName: "DeepSeek Chat",
-    pricing: {
-      inputPerMTok: 0.14,
-      outputPerMTok: 0.28,
-      cacheWritePerMTok: 0,
-      cacheReadPerMTok: 0
-    },
-    contextWindow: 128e3,
-    description: "Ultra-cheap, strong coding and reasoning. Great for high-volume."
-  },
-  "google/gemini-2.0-flash-001": {
-    id: "google/gemini-2.0-flash-001",
-    name: "gemini-2.0-flash",
-    displayName: "Gemini 2.0 Flash",
-    pricing: {
-      inputPerMTok: 0.1,
-      outputPerMTok: 0.4,
-      cacheWritePerMTok: 0,
-      cacheReadPerMTok: 0
-    },
-    contextWindow: 1e6,
-    description: "Google's fast multimodal model. 1M context window."
-  },
-  "qwen/qwen-2.5-coder-32b-instruct": {
-    id: "qwen/qwen-2.5-coder-32b-instruct",
-    name: "qwen-coder-32b",
-    displayName: "Qwen 2.5 Coder 32B",
-    pricing: {
-      inputPerMTok: 0.18,
-      outputPerMTok: 0.18,
-      cacheWritePerMTok: 0,
-      cacheReadPerMTok: 0
-    },
-    contextWindow: 32768,
-    description: "Alibaba's coding specialist. Excellent for code generation."
-  }
-};
-
-// src/agent/provider.ts
-import Anthropic from "@anthropic-ai/sdk";
-
-// src/agent/openrouter.ts
-var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
-var OPENROUTER_MODELS2 = {
-  // Z.AI GLM models
-  "z-ai/glm-4.7": {
-    id: "z-ai/glm-4.7",
-    name: "glm-4.7",
-    displayName: "GLM 4.7",
-    provider: "Z.AI",
-    pricing: {
-      inputPerMTok: 0.4,
-      outputPerMTok: 1.5
-    },
-    contextWindow: 202752,
-    maxOutputTokens: 65536,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Z.AI flagship. Enhanced programming, multi-step reasoning, agent tasks."
-  },
-  // MiniMax models - very cost effective
-  "minimax/minimax-m2.1": {
-    id: "minimax/minimax-m2.1",
-    name: "minimax-m2.1",
-    displayName: "MiniMax M2.1",
-    provider: "MiniMax",
-    pricing: {
-      inputPerMTok: 0.3,
-      // $0.0000003 * 1M
-      outputPerMTok: 1.2,
-      // $0.0000012 * 1M
-      cacheReadPerMTok: 0.03,
-      cacheWritePerMTok: 0.375
-    },
-    contextWindow: 204800,
-    maxOutputTokens: 131072,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "10B active params, state-of-the-art for coding and agentic workflows. Very cost efficient."
-  },
-  "minimax/minimax-m2": {
-    id: "minimax/minimax-m2",
-    name: "minimax-m2",
-    displayName: "MiniMax M2",
-    provider: "MiniMax",
-    pricing: {
-      inputPerMTok: 0.2,
-      outputPerMTok: 1,
-      cacheReadPerMTok: 0.03
-    },
-    contextWindow: 196608,
-    maxOutputTokens: 131072,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Compact model optimized for end-to-end coding and agentic workflows."
-  },
-  // DeepSeek models - very cheap
-  "deepseek/deepseek-v3.2": {
-    id: "deepseek/deepseek-v3.2",
-    name: "deepseek-v3.2",
-    displayName: "DeepSeek V3.2",
-    provider: "DeepSeek",
-    pricing: {
-      inputPerMTok: 0.224,
-      outputPerMTok: 0.32
-    },
-    contextWindow: 163840,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "High efficiency with strong reasoning. GPT-5 class performance."
-  },
-  // Mistral models
-  "mistralai/devstral-2512": {
-    id: "mistralai/devstral-2512",
-    name: "devstral-2512",
-    displayName: "Devstral 2 2512",
-    provider: "Mistral",
-    pricing: {
-      inputPerMTok: 0.05,
-      outputPerMTok: 0.22
-    },
-    contextWindow: 262144,
-    supportsTools: true,
-    description: "State-of-the-art open model for agentic coding. 123B params."
-  },
-  "mistralai/mistral-large-2512": {
-    id: "mistralai/mistral-large-2512",
-    name: "mistral-large-2512",
-    displayName: "Mistral Large 3",
-    provider: "Mistral",
-    pricing: {
-      inputPerMTok: 0.5,
-      outputPerMTok: 1.5
-    },
-    contextWindow: 262144,
-    supportsTools: true,
-    description: "Most capable Mistral model. 675B total params (41B active)."
-  },
-  // Google Gemini
-  "google/gemini-3-flash-preview": {
-    id: "google/gemini-3-flash-preview",
-    name: "gemini-3-flash",
-    displayName: "Gemini 3 Flash Preview",
-    provider: "Google",
-    pricing: {
-      inputPerMTok: 0.5,
-      outputPerMTok: 3,
-      cacheReadPerMTok: 0.05
-    },
-    contextWindow: 1048576,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "High speed thinking model for agentic workflows. 1M context."
-  },
-  "google/gemini-3-pro-preview": {
-    id: "google/gemini-3-pro-preview",
-    name: "gemini-3-pro",
-    displayName: "Gemini 3 Pro Preview",
-    provider: "Google",
-    pricing: {
-      inputPerMTok: 2,
-      outputPerMTok: 12,
-      cacheReadPerMTok: 0.2,
-      cacheWritePerMTok: 2.375
-    },
-    contextWindow: 1048576,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Flagship frontier model for high-precision multimodal reasoning."
-  },
-  // xAI Grok
-  "x-ai/grok-4.1-fast": {
-    id: "x-ai/grok-4.1-fast",
-    name: "grok-4.1-fast",
-    displayName: "Grok 4.1 Fast",
-    provider: "xAI",
-    pricing: {
-      inputPerMTok: 0.2,
-      outputPerMTok: 0.5,
-      cacheReadPerMTok: 0.05
-    },
-    contextWindow: 2e6,
-    maxOutputTokens: 3e4,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Best agentic tool calling model. 2M context window."
-  },
-  // Anthropic via OpenRouter (for fallback/comparison)
-  "anthropic/claude-opus-4.5": {
-    id: "anthropic/claude-opus-4.5",
-    name: "claude-opus-4.5-or",
-    displayName: "Claude Opus 4.5 (OR)",
-    provider: "Anthropic",
-    pricing: {
-      inputPerMTok: 5,
-      outputPerMTok: 25,
-      cacheReadPerMTok: 0.5,
-      cacheWritePerMTok: 6.25
-    },
-    contextWindow: 2e5,
-    maxOutputTokens: 32e3,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Anthropic Opus 4.5 via OpenRouter."
-  },
-  "anthropic/claude-haiku-4.5": {
-    id: "anthropic/claude-haiku-4.5",
-    name: "claude-haiku-4.5-or",
-    displayName: "Claude Haiku 4.5 (OR)",
-    provider: "Anthropic",
-    pricing: {
-      inputPerMTok: 1,
-      outputPerMTok: 5,
-      cacheReadPerMTok: 0.1,
-      cacheWritePerMTok: 1.25
-    },
-    contextWindow: 2e5,
-    maxOutputTokens: 64e3,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Anthropic Haiku 4.5 via OpenRouter. Fast and efficient."
-  },
-  // Free models (for testing/experimentation)
-  "mistralai/devstral-2512:free": {
-    id: "mistralai/devstral-2512:free",
-    name: "devstral-free",
-    displayName: "Devstral 2 (Free)",
-    provider: "Mistral",
-    pricing: {
-      inputPerMTok: 0,
-      outputPerMTok: 0
-    },
-    contextWindow: 262144,
-    supportsTools: true,
-    description: "Free tier Devstral for testing. Limited capacity."
-  },
-  "xiaomi/mimo-v2-flash:free": {
-    id: "xiaomi/mimo-v2-flash:free",
-    name: "mimo-v2-flash-free",
-    displayName: "MiMo V2 Flash (Free)",
-    provider: "Xiaomi",
-    pricing: {
-      inputPerMTok: 0,
-      outputPerMTok: 0
-    },
-    contextWindow: 262144,
-    supportsTools: true,
-    supportsReasoning: true,
-    description: "Free MoE model. Top open-source on SWE-bench."
-  }
-};
-var OPENROUTER_ALIASES = {
-  // Z.AI GLM
-  "glm": "z-ai/glm-4.7",
-  "glm-4.7": "z-ai/glm-4.7",
-  // MiniMax
-  "minimax": "minimax/minimax-m2.1",
-  "m2": "minimax/minimax-m2",
-  "m2.1": "minimax/minimax-m2.1",
-  // DeepSeek  
-  "deepseek": "deepseek/deepseek-v3.2",
-  "ds": "deepseek/deepseek-v3.2",
-  // Mistral
-  "devstral": "mistralai/devstral-2512",
-  "mistral": "mistralai/mistral-large-2512",
-  "mistral-large": "mistralai/mistral-large-2512",
-  // Google
-  "gemini": "google/gemini-3-flash-preview",
-  "gemini-flash": "google/gemini-3-flash-preview",
-  "gemini-pro": "google/gemini-3-pro-preview",
-  // xAI
-  "grok": "x-ai/grok-4.1-fast",
-  // Anthropic via OR
-  "opus-or": "anthropic/claude-opus-4.5",
-  "haiku-or": "anthropic/claude-haiku-4.5",
-  // Free
-  "free": "mistralai/devstral-2512:free",
-  "mimo": "xiaomi/mimo-v2-flash:free"
-};
-function resolveOpenRouterModelId(nameOrAlias) {
-  const lower = nameOrAlias.toLowerCase();
-  if (OPENROUTER_MODELS2[lower]) {
-    return lower;
-  }
-  if (OPENROUTER_ALIASES[lower]) {
-    return OPENROUTER_ALIASES[lower];
-  }
-  for (const [id, config] of Object.entries(OPENROUTER_MODELS2)) {
-    if (config.name.toLowerCase() === lower) {
-      return id;
-    }
-  }
-  if (nameOrAlias.includes("/")) {
-    return nameOrAlias;
-  }
-  return null;
-}
-function getOpenRouterModelConfig(modelId) {
-  return OPENROUTER_MODELS2[modelId] ?? null;
-}
-function convertToOpenAITools(anthropicTools) {
-  return anthropicTools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description ?? "",
-      parameters: tool.input_schema
-    }
-  }));
-}
-var OpenRouterClient = class {
-  apiKey;
-  baseUrl;
-  appName;
-  appUrl;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl ?? OPENROUTER_BASE_URL;
-    this.appName = config.appName ?? "Quantish Agent";
-    this.appUrl = config.appUrl ?? "https://quantish.ai";
-  }
-  /**
-   * Create a chat completion (non-streaming)
-   */
-  async createChatCompletion(options) {
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-        "HTTP-Referer": this.appUrl,
-        "X-Title": this.appName
-      },
-      body: JSON.stringify({
-        model: options.model,
-        messages: options.messages,
-        tools: options.tools,
-        tool_choice: options.tool_choice ?? (options.tools ? "auto" : void 0),
-        max_tokens: options.max_tokens,
-        temperature: options.temperature,
-        top_p: options.top_p,
-        stream: false
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-    return response.json();
-  }
-  /**
-   * Create a streaming chat completion
-   */
-  async *createStreamingChatCompletion(options) {
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-        "HTTP-Referer": this.appUrl,
-        "X-Title": this.appName
-      },
-      body: JSON.stringify({
-        model: options.model,
-        messages: options.messages,
-        tools: options.tools,
-        tool_choice: options.tool_choice ?? (options.tools ? "auto" : void 0),
-        max_tokens: options.max_tokens,
-        temperature: options.temperature,
-        top_p: options.top_p,
-        stream: true
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-    if (!response.body) {
-      throw new Error("No response body for streaming request");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      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) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const json = JSON.parse(trimmed.slice(6));
-            yield json;
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  /**
-   * Get generation details including exact cost
-   */
-  async getGenerationDetails(generationId) {
-    const response = await fetch(`${this.baseUrl}/generation?id=${generationId}`, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-    return response.json();
-  }
-  /**
-   * List available models
-   */
-  async listModels() {
-    const response = await fetch(`${this.baseUrl}/models`, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-    return response.json();
-  }
-};
-function calculateOpenRouterCost(modelId, inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
-  let config = getOpenRouterModelConfig(modelId);
-  if (!config) {
-    config = getOpenRouterModelConfig(modelId.toLowerCase());
-  }
-  if (!config) {
-    const lower = modelId.toLowerCase();
-    for (const [key, model] of Object.entries(OPENROUTER_MODELS2)) {
-      if (key.toLowerCase() === lower || model.name.toLowerCase() === lower) {
-        config = model;
-        break;
-      }
-    }
-    if (!config && OPENROUTER_ALIASES[lower]) {
-      config = OPENROUTER_MODELS2[OPENROUTER_ALIASES[lower]];
-    }
-  }
-  const pricing = config?.pricing ?? {
-    inputPerMTok: 0.4,
-    // GLM 4.7 pricing as fallback
-    outputPerMTok: 1.5,
-    cacheReadPerMTok: 0,
-    cacheWritePerMTok: 0
-  };
-  const inputCost = inputTokens / 1e6 * pricing.inputPerMTok;
-  const outputCost = outputTokens / 1e6 * pricing.outputPerMTok;
-  const cacheReadCost = cacheReadTokens / 1e6 * (pricing.cacheReadPerMTok ?? 0);
-  const cacheWriteCost = cacheWriteTokens / 1e6 * (pricing.cacheWritePerMTok ?? 0);
-  return {
-    inputCost,
-    outputCost,
-    cacheReadCost,
-    cacheWriteCost,
-    totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost
-  };
-}
-function listOpenRouterModels() {
-  return Object.values(OPENROUTER_MODELS2);
-}
-
-// src/agent/provider.ts
-var AnthropicProvider = class {
-  client;
-  config;
-  constructor(config) {
-    this.config = config;
-    const headers = {};
-    if (config.contextEditing && config.contextEditing.length > 0) {
-      headers["anthropic-beta"] = "context-management-2025-06-27";
-    }
-    this.client = new Anthropic({
-      apiKey: config.apiKey,
-      defaultHeaders: Object.keys(headers).length > 0 ? headers : void 0
-    });
-  }
-  getModel() {
-    return this.config.model;
-  }
-  async countTokens(messages) {
-    try {
-      const response = await this.client.messages.countTokens({
-        model: this.config.model,
-        system: this.config.systemPrompt,
-        tools: this.config.tools,
-        messages
-      });
-      return response.input_tokens;
-    } catch {
-      return 0;
-    }
-  }
-  async chat(messages) {
-    const systemWithCache = [
-      {
-        type: "text",
-        text: this.config.systemPrompt,
-        cache_control: { type: "ephemeral" }
-      }
-    ];
-    const response = await this.client.messages.create({
-      model: this.config.model,
-      max_tokens: this.config.maxTokens,
-      system: systemWithCache,
-      tools: this.config.tools,
-      messages
-    });
-    const usage = response.usage;
-    const cost = calculateCost(
-      this.config.model,
-      usage.input_tokens,
-      usage.output_tokens,
-      usage.cache_creation_input_tokens ?? 0,
-      usage.cache_read_input_tokens ?? 0
-    );
-    const textBlocks = response.content.filter(
-      (block) => block.type === "text"
-    );
-    const toolUses = response.content.filter(
-      (block) => block.type === "tool_use"
-    );
-    return {
-      text: textBlocks.map((b) => b.text).join(""),
-      toolCalls: toolUses.map((t) => ({
-        id: t.id,
-        name: t.name,
-        input: t.input
-      })),
-      usage: {
-        inputTokens: usage.input_tokens,
-        outputTokens: usage.output_tokens,
-        cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
-        cacheReadTokens: usage.cache_read_input_tokens ?? 0
-      },
-      cost,
-      stopReason: response.stop_reason === "tool_use" ? "tool_use" : "end_turn",
-      rawResponse: response
-    };
-  }
-  async streamChat(messages, callbacks) {
-    const systemWithCache = [
-      {
-        type: "text",
-        text: this.config.systemPrompt,
-        cache_control: { type: "ephemeral" }
-      }
-    ];
-    const stream = this.client.messages.stream({
-      model: this.config.model,
-      max_tokens: this.config.maxTokens,
-      system: systemWithCache,
-      tools: this.config.tools,
-      messages
-    });
-    let fullText = "";
-    for await (const event of stream) {
-      if (event.type === "content_block_delta") {
-        const delta = event.delta;
-        if (delta.type === "text_delta" && delta.text) {
-          fullText += delta.text;
-          callbacks.onText?.(delta.text);
-        } else if (delta.type === "thinking_delta" && delta.thinking) {
-          callbacks.onThinking?.(delta.thinking);
-        }
-      }
-    }
-    const response = await stream.finalMessage();
-    const usage = response.usage;
-    const cost = calculateCost(
-      this.config.model,
-      usage.input_tokens,
-      usage.output_tokens,
-      usage.cache_creation_input_tokens ?? 0,
-      usage.cache_read_input_tokens ?? 0
-    );
-    const toolUses = response.content.filter(
-      (block) => block.type === "tool_use"
-    );
-    for (const tool of toolUses) {
-      callbacks.onToolCall?.(tool.id, tool.name, tool.input);
-    }
-    return {
-      text: fullText,
-      toolCalls: toolUses.map((t) => ({
-        id: t.id,
-        name: t.name,
-        input: t.input
-      })),
-      usage: {
-        inputTokens: usage.input_tokens,
-        outputTokens: usage.output_tokens,
-        cacheCreationTokens: usage.cache_creation_input_tokens ?? 0,
-        cacheReadTokens: usage.cache_read_input_tokens ?? 0
-      },
-      cost,
-      stopReason: response.stop_reason === "tool_use" ? "tool_use" : "end_turn",
-      rawResponse: response
-    };
-  }
-};
-var OpenRouterProvider = class {
-  client;
-  config;
-  openaiTools;
-  constructor(config) {
-    this.config = config;
-    this.client = new OpenRouterClient({
-      apiKey: config.apiKey
-    });
-    this.openaiTools = convertToOpenAITools(config.tools);
-  }
-  getModel() {
-    return this.config.model;
-  }
-  async countTokens(_messages) {
-    const text = JSON.stringify(_messages);
-    return Math.ceil(text.length / 4);
-  }
-  /**
-   * Convert Anthropic message format to OpenAI format
-   */
-  convertMessages(messages) {
-    const result = [];
-    result.push({
-      role: "system",
-      content: this.config.systemPrompt
-    });
-    for (const msg of messages) {
-      if (msg.role === "user") {
-        if (typeof msg.content === "string") {
-          result.push({ role: "user", content: msg.content });
-        } else if (Array.isArray(msg.content)) {
-          const toolResults = msg.content.filter(
-            (block) => block.type === "tool_result"
-          );
-          if (toolResults.length > 0) {
-            for (const tr of toolResults) {
-              const toolResult = tr;
-              result.push({
-                role: "tool",
-                tool_call_id: toolResult.tool_use_id,
-                content: typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content)
-              });
-            }
-          } else {
-            const textContent = msg.content.filter((block) => block.type === "text").map((block) => block.text).join("");
-            if (textContent) {
-              result.push({ role: "user", content: textContent });
-            }
-          }
-        }
-      } else if (msg.role === "assistant") {
-        if (typeof msg.content === "string") {
-          result.push({ role: "assistant", content: msg.content });
-        } else if (Array.isArray(msg.content)) {
-          const textBlocks = msg.content.filter(
-            (block) => block.type === "text"
-          );
-          const toolUses = msg.content.filter(
-            (block) => block.type === "tool_use"
-          );
-          const textContent = textBlocks.map((b) => b.text).join("");
-          if (toolUses.length > 0) {
-            result.push({
-              role: "assistant",
-              content: textContent || null,
-              tool_calls: toolUses.map((t) => ({
-                id: t.id,
-                type: "function",
-                function: {
-                  name: t.name,
-                  arguments: JSON.stringify(t.input)
-                }
-              }))
-            });
-          } else {
-            result.push({ role: "assistant", content: textContent });
-          }
-        }
-      }
-    }
-    return result;
-  }
-  async chat(messages) {
-    const openaiMessages = this.convertMessages(messages);
-    const response = await this.client.createChatCompletion({
-      model: this.config.model,
-      messages: openaiMessages,
-      tools: this.openaiTools.length > 0 ? this.openaiTools : void 0,
-      max_tokens: this.config.maxTokens
-    });
-    const choice = response.choices[0];
-    const usage = response.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const cost = calculateOpenRouterCost(
-      this.config.model,
-      usage.prompt_tokens,
-      usage.completion_tokens
-    );
-    const toolCalls = choice.message.tool_calls ?? [];
-    return {
-      text: choice.message.content ?? "",
-      toolCalls: toolCalls.map((tc) => ({
-        id: tc.id,
-        name: tc.function.name,
-        input: JSON.parse(tc.function.arguments)
-      })),
-      usage: {
-        inputTokens: usage.prompt_tokens,
-        outputTokens: usage.completion_tokens,
-        cacheCreationTokens: 0,
-        cacheReadTokens: 0
-      },
-      cost,
-      stopReason: choice.finish_reason === "tool_calls" ? "tool_use" : "end_turn",
-      rawResponse: response
-    };
-  }
-  async streamChat(messages, callbacks) {
-    const openaiMessages = this.convertMessages(messages);
-    let fullText = "";
-    const toolCallsInProgress = /* @__PURE__ */ new Map();
-    let finishReason = null;
-    let usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const stream = this.client.createStreamingChatCompletion({
-      model: this.config.model,
-      messages: openaiMessages,
-      tools: this.openaiTools.length > 0 ? this.openaiTools : void 0,
-      max_tokens: this.config.maxTokens
-    });
-    for await (const chunk of stream) {
-      const choice = chunk.choices[0];
-      if (!choice) continue;
-      if (choice.delta.content) {
-        fullText += choice.delta.content;
-        callbacks.onText?.(choice.delta.content);
-      }
-      if (choice.delta.tool_calls) {
-        for (const tcDelta of choice.delta.tool_calls) {
-          const existing = toolCallsInProgress.get(tcDelta.index);
-          if (!existing) {
-            toolCallsInProgress.set(tcDelta.index, {
-              id: tcDelta.id ?? "",
-              name: tcDelta.function?.name ?? "",
-              arguments: tcDelta.function?.arguments ?? ""
-            });
-          } else {
-            if (tcDelta.id) existing.id = tcDelta.id;
-            if (tcDelta.function?.name) existing.name = tcDelta.function.name;
-            if (tcDelta.function?.arguments) existing.arguments += tcDelta.function.arguments;
-          }
-        }
-      }
-      if (choice.finish_reason) {
-        finishReason = choice.finish_reason;
-      }
-      if (chunk.usage) {
-        usage = chunk.usage;
-      }
-    }
-    const toolCalls = [];
-    for (const [, tc] of toolCallsInProgress) {
-      try {
-        if (!tc || !tc.name) {
-          continue;
-        }
-        let toolName = tc.name;
-        if (toolName.includes("<")) {
-          toolName = toolName.split("<")[0];
-        }
-        if (toolName.includes("(")) {
-          toolName = toolName.split("(")[0];
-        }
-        toolName = toolName.trim();
-        let args = tc.arguments?.trim() || "{}";
-        if (args.includes("<arg_key>") || args.includes("</arg_key>")) {
-          args = args.replace(/<\/?arg_key>/g, "");
-          if (!args.startsWith("{")) {
-            const keyValuePairs = [];
-            const kvMatches = args.matchAll(/(\w+):\s*(?:"([^"]+)"|(\d+)|(\w+))/g);
-            for (const match of kvMatches) {
-              const key = match[1];
-              const value = match[2] ?? match[3] ?? match[4];
-              if (match[3]) {
-                keyValuePairs.push(`"${key}": ${value}`);
-              } else {
-                keyValuePairs.push(`"${key}": "${value}"`);
-              }
-            }
-            if (keyValuePairs.length > 0) {
-              args = `{${keyValuePairs.join(", ")}}`;
-            }
-          }
-        }
-        if (args && !args.endsWith("}") && !args.endsWith("]")) {
-          const openBraces = (args.match(/{/g) || []).length;
-          const closeBraces = (args.match(/}/g) || []).length;
-          if (openBraces > closeBraces) {
-            args = args + "}".repeat(openBraces - closeBraces);
-          }
-        }
-        if (!args || args === "" || args === "undefined") {
-          args = "{}";
-        }
-        const input = JSON.parse(args);
-        const toolId = tc.id || `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-        toolCalls.push({ id: toolId, name: toolName, input });
-        callbacks.onToolCall?.(toolId, toolName, input);
-      } catch (e) {
-        const cleanToolName = tc?.name?.split("<")[0]?.split("(")[0]?.trim() || "unknown_tool";
-        let parsedInput = {};
-        try {
-          const argsStr = tc?.arguments || "";
-          const matches = argsStr.matchAll(/(\w+):\s*"([^"]+)"/g);
-          for (const match of matches) {
-            parsedInput[match[1]] = match[2];
-          }
-        } catch {
-        }
-        const toolId = tc?.id || `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-        toolCalls.push({ id: toolId, name: cleanToolName, input: parsedInput });
-        callbacks.onToolCall?.(toolId, cleanToolName, parsedInput);
-      }
-    }
-    const cost = calculateOpenRouterCost(
-      this.config.model,
-      usage.prompt_tokens,
-      usage.completion_tokens
-    );
-    return {
-      text: fullText,
-      toolCalls,
-      usage: {
-        inputTokens: usage.prompt_tokens,
-        outputTokens: usage.completion_tokens,
-        cacheCreationTokens: 0,
-        cacheReadTokens: 0
-      },
-      cost,
-      stopReason: finishReason === "tool_calls" ? "tool_use" : "end_turn"
-    };
-  }
-};
-function createLLMProvider(config) {
-  if (config.provider === "openrouter") {
-    return new OpenRouterProvider(config);
-  }
-  return new AnthropicProvider(config);
-}
-
-// src/agent/loop.ts
-var DEFAULT_SYSTEM_PROMPT = `You are Quantish, an AI trading agent for prediction markets (Polymarket, Kalshi).
-
-## CRITICAL: Market Display Rules
-
-When showing market search results, ALWAYS include:
-- Market title
-- Platform  
-- **Price/Probability** (REQUIRED - never omit this)
-- Market ID
-
-Format market tables like this:
-| Market | Platform | Price | ID |
-|--------|----------|-------|-----|
-| Example market | Polymarket | Yes 45\xA2 / No 55\xA2 | 12345 |
-
-The price data is in the tool result - extract and display it.
-
-## Building Applications
-
-When asked to create applications or projects:
-
-1. **Use run_command for scaffolding** - Commands like \`npx create-react-app\` or \`npm create vite\` are automatically given 10 minutes to complete. Always add \`--yes\` flag to skip prompts.
-
-2. **Verify after creation** - After scaffolding completes, use \`workspace_summary\` to see the file tree and confirm the project was created correctly.
-
-3. **Use start_background_process for dev servers** - After the app is built, use this for \`npm start\`, \`npm run dev\`, etc. These run indefinitely until stopped.
-
-4. **Read files before editing** - Always use \`read_file\` before \`edit_file\` to understand the existing code structure.
-
-5. **Test incrementally** - After making changes, run the app and verify it works before making more changes.
-
-Be concise and helpful.`;
-var Agent = class _Agent {
-  anthropic;
-  llmProvider;
-  mcpClient;
-  mcpClientManager;
-  config;
-  conversationHistory = [];
-  workingDirectory;
-  sessionCost = 0;
-  // Cumulative cost for this session
-  // Loop detection: track last N tool calls to detect loops
-  recentToolCalls = [];
-  static MAX_RECENT_TOOL_CALLS = 5;
-  static LOOP_THRESHOLD = 2;
-  // Abort if same call appears this many times
-  cumulativeTokenUsage = {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheCreationInputTokens: 0,
-    cacheReadInputTokens: 0,
-    totalTokens: 0,
-    cost: { inputCost: 0, outputCost: 0, cacheWriteCost: 0, cacheReadCost: 0, totalCost: 0 },
-    sessionCost: 0
-  };
-  // Sliding window context management
-  conversationSummary = null;
-  toolHistory = [];
-  exchanges = [];
-  static MAX_TOOL_HISTORY = 10;
-  static MAX_EXCHANGES = 5;
-  constructor(config) {
-    this.config = {
-      enableLocalTools: true,
-      enableMCPTools: true,
-      provider: "anthropic",
-      // Default to Anthropic
-      // Default context editing: clear old tool uses when context exceeds 100k tokens
-      contextEditing: config.contextEditing || [
-        {
-          type: "clear_tool_uses_20250919",
-          trigger: { type: "input_tokens", value: 1e5 },
-          keep: { type: "tool_uses", value: 5 }
-        }
-      ],
-      ...config
-    };
-    const headers = {};
-    if (this.config.contextEditing && this.config.contextEditing.length > 0) {
-      headers["anthropic-beta"] = "context-management-2025-06-27";
-    }
-    const anthropicKey = config.anthropicApiKey || "placeholder";
-    this.anthropic = new Anthropic2({
-      apiKey: anthropicKey,
-      defaultHeaders: Object.keys(headers).length > 0 ? headers : void 0
-    });
-    this.mcpClient = config.mcpClient;
-    this.mcpClientManager = config.mcpClientManager;
-    this.workingDirectory = config.workingDirectory || process.cwd();
-  }
-  /**
-   * Get the API key for the current provider
-   */
-  getApiKey() {
-    if (this.config.provider === "openrouter") {
-      return this.config.openrouterApiKey || "";
-    }
-    return this.config.anthropicApiKey || "";
-  }
-  /**
-   * Check if using OpenRouter provider
-   */
-  isOpenRouter() {
-    return this.config.provider === "openrouter";
-  }
-  /**
-   * Get the current provider name
-   */
-  getProvider() {
-    return this.config.provider || "anthropic";
-  }
-  /**
-   * Set the LLM provider
-   */
-  setProvider(provider) {
-    this.config.provider = provider;
-    this.llmProvider = void 0;
-  }
-  /**
-   * Get or create the LLM provider instance
-   */
-  async getOrCreateProvider() {
-    const allTools = await this.getAllTools();
-    const systemPrompt = this.buildSystemContext();
-    const defaultModel = this.config.provider === "openrouter" ? "z-ai/glm-4.7" : DEFAULT_MODEL;
-    const model = this.config.model ?? defaultModel;
-    const maxTokens = this.config.maxTokens ?? 8192;
-    this.llmProvider = createLLMProvider({
-      provider: this.config.provider || "anthropic",
-      apiKey: this.getApiKey(),
-      model,
-      maxTokens,
-      systemPrompt,
-      tools: allTools,
-      contextEditing: this.config.contextEditing
-    });
-    return this.llmProvider;
-  }
-  /**
-   * Run the agent using the provider abstraction (for OpenRouter and future providers)
-   */
-  async runWithProvider(userMessage) {
-    const maxIterations = this.config.maxIterations ?? 200;
-    const useStreaming = this.config.streaming ?? true;
-    const provider = await this.getOrCreateProvider();
-    const messages = this.buildSlimHistory(userMessage);
-    this.clearToolCallLoopTracking();
-    let currentTurnMessages = [...messages];
-    const toolCalls = [];
-    let iterations = 0;
-    let finalText = "";
-    const maxTurns = this.config.maxTurns ?? maxIterations;
-    while (iterations < maxTurns) {
-      if (this.config.abortSignal?.aborted) {
-        finalText += "\n\n[Operation cancelled by user]";
-        break;
-      }
-      iterations++;
-      this.config.onStreamStart?.();
-      let response;
-      if (useStreaming) {
-        response = await provider.streamChat(currentTurnMessages, {
-          onText: (text) => {
-            finalText += text;
-            this.config.onText?.(text, false);
-          },
-          onThinking: (text) => {
-            this.config.onThinking?.(text);
-          },
-          onToolCall: (id, name, input) => {
-            this.config.onToolCall?.(name, input);
-          }
-        });
-        if (response.text) {
-          this.config.onText?.("", true);
-        }
-      } else {
-        response = await provider.chat(currentTurnMessages);
-        if (response.text) {
-          finalText += response.text;
-          this.config.onText?.(response.text, true);
-        }
-      }
-      this.config.onStreamEnd?.();
-      this.updateTokenUsage({
-        input_tokens: response.usage.inputTokens,
-        output_tokens: response.usage.outputTokens,
-        cache_creation_input_tokens: response.usage.cacheCreationTokens,
-        cache_read_input_tokens: response.usage.cacheReadTokens
-      }, response.cost);
-      const responseContent = [];
-      if (response.text) {
-        responseContent.push({ type: "text", text: response.text });
-      }
-      for (const tc of response.toolCalls) {
-        responseContent.push({
-          type: "tool_use",
-          id: tc.id,
-          name: tc.name,
-          input: tc.input
-        });
-      }
-      if (response.toolCalls.length === 0) {
-        break;
-      }
-      const toolResults = [];
-      for (const toolCall2 of response.toolCalls) {
-        await new Promise((resolve2) => setImmediate(resolve2));
-        const { result, source } = await this.executeTool(
-          toolCall2.name,
-          toolCall2.input
-        );
-        const success2 = !(result && typeof result === "object" && "error" in result);
-        this.config.onToolResult?.(toolCall2.name, result, success2);
-        this.addToolHistory(toolCall2.name, toolCall2.input, success2);
-        toolCalls.push({
-          name: toolCall2.name,
-          input: toolCall2.input,
-          result,
-          source
-        });
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: toolCall2.id,
-          content: JSON.stringify(result)
-        });
-      }
-      currentTurnMessages.push({
-        role: "assistant",
-        content: responseContent
-      });
-      currentTurnMessages.push({
-        role: "user",
-        content: toolResults
-      });
-      if (response.stopReason === "end_turn" && response.toolCalls.length === 0) {
-        break;
-      }
-    }
-    if (finalText.trim()) {
-      this.storeTextExchange(userMessage, finalText.trim());
-    }
-    return {
-      text: finalText,
-      toolCalls,
-      iterations,
-      tokenUsage: { ...this.cumulativeTokenUsage }
-    };
-  }
-  /**
-   * Get all available tools
-   */
-  async getAllTools() {
-    const tools = [];
-    if (this.config.enableLocalTools) {
-      tools.push(...localTools);
-    }
-    if (this.config.enableMCPTools) {
-      if (this.mcpClientManager) {
-        const mcpTools = await this.mcpClientManager.listAllTools();
-        tools.push(...convertToClaudeTools(mcpTools));
-      } else if (this.mcpClient) {
-        const mcpTools = await this.mcpClient.listTools();
-        tools.push(...convertToClaudeTools(mcpTools));
-      }
-    }
-    return tools;
-  }
-  /**
-   * Execute a tool (local or MCP)
-   */
-  async executeTool(name, args) {
-    if (this.config.abortSignal?.aborted) {
-      return {
-        result: { error: "Operation cancelled by user" },
-        source: "local"
-      };
-    }
-    if (this.checkToolCallLoop(name, args)) {
-      return {
-        result: { error: `Loop detected: "${name}" was called multiple times with the same input. Please try a different approach.` },
-        source: "local"
-      };
-    }
-    if (isLocalTool(name)) {
-      const result = await executeLocalTool(name, args);
-      return {
-        result: result.success ? result.data : { error: result.error },
-        source: "local"
-      };
-    }
-    if (this.mcpClientManager) {
-      const result = await this.mcpClientManager.callTool(name, args);
-      const source = result.source || "mcp";
-      return {
-        result: result.success ? result.data : { error: result.error },
-        source
-      };
-    }
-    if (this.mcpClient) {
-      const result = await this.mcpClient.callTool(name, args);
-      return {
-        result: result.success ? result.data : { error: result.error },
-        source: "mcp"
-      };
-    }
-    return {
-      result: { error: `Unknown tool: ${name}` },
-      source: "local"
-    };
-  }
-  /**
-   * Set the abort signal for the current request (call before run())
-   */
-  setAbortSignal(signal) {
-    this.config.abortSignal = signal;
-  }
-  /**
-   * Run the agent with a user message (supports streaming)
-   */
-  async run(userMessage, options) {
-    if (options?.abortSignal) {
-      this.config.abortSignal = options.abortSignal;
-    }
-    if (this.config.provider === "openrouter") {
-      return this.runWithProvider(userMessage);
-    }
-    const maxIterations = this.config.maxIterations ?? 15;
-    const model = this.config.model ?? "claude-sonnet-4-5-20250929";
-    const maxTokens = this.config.maxTokens ?? 8192;
-    const systemPrompt = this.buildSystemContext();
-    const useStreaming = this.config.streaming ?? true;
-    const allTools = await this.getAllTools();
-    const contextManagement = this.config.contextEditing && this.config.contextEditing.length > 0 ? { edits: this.config.contextEditing } : void 0;
-    let currentTurnMessages = this.buildSlimHistory(userMessage);
-    this.clearToolCallLoopTracking();
-    const toolCalls = [];
-    let iterations = 0;
-    let finalText = "";
-    const maxTurns = this.config.maxTurns ?? maxIterations;
-    while (iterations < maxTurns) {
-      if (this.config.abortSignal?.aborted) {
-        finalText += "\n\n[Operation cancelled by user]";
-        break;
-      }
-      iterations++;
-      this.config.onStreamStart?.();
-      let response;
-      let responseContent = [];
-      let currentText = "";
-      let toolUses = [];
-      if (useStreaming) {
-        const systemWithCache = [
-          {
-            type: "text",
-            text: systemPrompt,
-            cache_control: { type: "ephemeral" }
-          }
-        ];
-        const streamOptions = {
-          model,
-          max_tokens: maxTokens,
-          system: systemWithCache,
-          tools: allTools,
-          messages: currentTurnMessages
-        };
-        if (contextManagement) {
-          streamOptions.context_management = contextManagement;
-        }
-        const stream = this.anthropic.messages.stream(streamOptions);
-        for await (const event of stream) {
-          if (event.type === "content_block_delta") {
-            const delta = event.delta;
-            if (delta.type === "text_delta" && delta.text) {
-              currentText += delta.text;
-              finalText += delta.text;
-              this.config.onText?.(delta.text, false);
-            } else if (delta.type === "thinking_delta" && delta.thinking) {
-              this.config.onThinking?.(delta.thinking);
-            } else if (delta.type === "input_json_delta" && delta.partial_json) {
-            }
-          } else if (event.type === "content_block_stop") {
-          }
-        }
-        response = await stream.finalMessage();
-        responseContent = response.content;
-        this.updateTokenUsage(response.usage);
-        toolUses = response.content.filter(
-          (block) => block.type === "tool_use"
-        );
-        if (currentText) {
-          this.config.onText?.("", true);
-        }
+      }
+    } else if (action.toLowerCase() === "d") {
+      kalshiKey = void 0;
+      skipKalshi = true;
+    }
+  } else {
+    console.log("Options:");
+    console.log(chalk.dim("  1. Create a new Kalshi wallet (recommended for new users)"));
+    console.log(chalk.dim("  2. Enter an existing Kalshi API key"));
+    console.log(chalk.dim("  3. Skip Kalshi for now\n"));
+    const choice = await prompt("Choose (1/2/3): ");
+    if (choice === "1") {
+      console.log(chalk.dim("\nCreating a new Solana wallet on Kalshi MCP..."));
+      const externalId = await prompt("Enter a unique identifier (e.g., email or username): ");
+      if (!externalId) {
+        console.log(chalk.red("Identifier is required to create an account."));
+        skipKalshi = true;
       } else {
-        const systemWithCache = [
-          {
-            type: "text",
-            text: systemPrompt,
-            cache_control: { type: "ephemeral" }
+        try {
+          const kalshiClient = createMCPClient(KALSHI_MCP_URL, "", "kalshi");
+          const result = await kalshiClient.callTool("kalshi_signup", { externalId });
+          if (result.success && typeof result.data === "object" && result.data !== null) {
+            const data = result.data;
+            kalshiKey = data.apiKey;
+            console.log(chalk.green("\n\u2713 Kalshi wallet created!"));
+            console.log(chalk.dim(`  Solana Address: ${data.walletAddress}`));
+            if (data.apiSecret) {
+              console.log(chalk.yellow("\n\u26A0\uFE0F  Save your API secret (shown only once):"));
+              console.log(chalk.bold.yellow(`   ${String(data.apiSecret)}`));
+              console.log();
+            }
+          } else {
+            console.log(chalk.red("Failed to create Kalshi account: " + (result.error || "Unknown error")));
+            console.log(chalk.dim("You can try again later via the agent."));
+            skipKalshi = true;
           }
-        ];
-        const createOptions = {
-          model,
-          max_tokens: maxTokens,
-          system: systemWithCache,
-          tools: allTools,
-          messages: currentTurnMessages
-        };
-        if (contextManagement) {
-          createOptions.context_management = contextManagement;
-        }
-        response = await this.anthropic.messages.create(createOptions);
-        responseContent = response.content;
-        this.updateTokenUsage(response.usage);
-        toolUses = response.content.filter(
-          (block) => block.type === "tool_use"
-        );
-        const textBlocks = response.content.filter(
-          (block) => block.type === "text"
-        );
-        for (const block of textBlocks) {
-          finalText += block.text;
-          this.config.onText?.(block.text, true);
+        } catch (error2) {
+          console.log(chalk.red("Failed to connect to Kalshi MCP."));
+          console.log(chalk.dim(String(error2)));
+          console.log(chalk.dim("You can try again later via the agent."));
+          skipKalshi = true;
         }
       }
-      this.config.onStreamEnd?.();
-      if (toolUses.length === 0) {
-        break;
-      }
-      const toolResults = [];
-      for (const toolUse of toolUses) {
-        this.config.onToolCall?.(toolUse.name, toolUse.input);
-        const { result, source } = await this.executeTool(
-          toolUse.name,
-          toolUse.input
-        );
-        const success2 = !(result && typeof result === "object" && "error" in result);
-        this.config.onToolResult?.(toolUse.name, result, success2);
-        this.addToolHistory(toolUse.name, toolUse.input, success2);
-        toolCalls.push({
-          name: toolUse.name,
-          input: toolUse.input,
-          result,
-          source
-        });
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: JSON.stringify(result)
-        });
-      }
-      currentTurnMessages.push({
-        role: "assistant",
-        content: responseContent
-      });
-      currentTurnMessages.push({
-        role: "user",
-        content: toolResults
-      });
-      if (response.stop_reason === "end_turn" && toolUses.length === 0) {
-        break;
-      }
-    }
-    if (finalText.trim()) {
-      this.storeTextExchange(userMessage, finalText.trim());
-    }
-    return {
-      text: finalText,
-      toolCalls,
-      iterations,
-      tokenUsage: { ...this.cumulativeTokenUsage }
-    };
-  }
-  /**
-   * Clear conversation history (start fresh)
-   */
-  clearHistory() {
-    this.conversationHistory = [];
-    this.conversationSummary = null;
-    this.toolHistory = [];
-    this.exchanges = [];
-  }
-  /**
-   * Get current conversation history
-   */
-  getHistory() {
-    return [...this.conversationHistory];
-  }
-  /**
-   * Extract primary input from tool arguments for compact history.
-   * Returns the most relevant parameter value, truncated if needed.
-   */
-  extractPrimaryInput(input) {
-    const primaryKeys = ["query", "path", "command", "marketId", "content", "url", "pattern", "ticker"];
-    for (const key of primaryKeys) {
-      if (input[key] && typeof input[key] === "string") {
-        const val = input[key];
-        return val.length > 40 ? val.slice(0, 40) + "..." : val;
-      }
-    }
-    for (const val of Object.values(input)) {
-      if (typeof val === "string" && val.length > 0) {
-        return val.length > 40 ? val.slice(0, 40) + "..." : val;
-      }
-    }
-    const firstKey = Object.keys(input)[0];
-    if (firstKey) {
-      const val = String(input[firstKey]);
-      return val.length > 40 ? val.slice(0, 40) + "..." : val;
-    }
-    return "(no input)";
-  }
-  /**
-   * Add a tool call to history after execution.
-   * Keeps only the last 10 entries.
-   */
-  addToolHistory(tool, input, success2) {
-    this.toolHistory.push({
-      tool,
-      primaryInput: this.extractPrimaryInput(input),
-      success: success2,
-      timestamp: Date.now()
-    });
-    if (this.toolHistory.length > _Agent.MAX_TOOL_HISTORY) {
-      this.toolHistory = this.toolHistory.slice(-_Agent.MAX_TOOL_HISTORY);
-    }
-  }
-  /**
-   * Format tool history for context injection.
-   * Simple, clean format without emojis.
-   */
-  formatToolHistory() {
-    if (this.toolHistory.length === 0) return "";
-    const lines = this.toolHistory.map((t) => {
-      const status = t.success ? "ok" : "failed";
-      return `- ${t.tool}: "${t.primaryInput}" - ${status}`;
-    });
-    return "Recent actions:\n" + lines.join("\n");
-  }
-  /**
-   * Add a user/model exchange to history.
-   * If we exceed max exchanges, compact older ones first.
-   * @deprecated Use storeTextExchange instead
-   */
-  /**
-   * Build the full system context including tool history and summary.
-   */
-  buildSystemContext() {
-    const basePrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    const parts = [basePrompt];
-    const toolHistoryStr = this.formatToolHistory();
-    if (toolHistoryStr) {
-      parts.push(toolHistoryStr);
-    }
-    if (this.conversationSummary) {
-      parts.push(`Previous context:
-${this.conversationSummary}`);
-    }
-    return parts.join("\n\n");
-  }
-  /**
-   * Build messages array from exchanges for API call.
-   * Converts stored exchanges to MessageParam format.
-   */
-  buildMessagesFromExchanges() {
-    const messages = [];
-    for (const exchange of this.exchanges) {
-      messages.push({ role: "user", content: exchange.userMessage });
-      messages.push({ role: "assistant", content: exchange.assistantResponse });
-    }
-    return messages;
-  }
-  /**
-   * Build slim history for API call: last 2 text exchanges + current user message.
-   * NO tool calls, NO tool results - just text.
-   */
-  buildSlimHistory(currentUserMessage) {
-    const messages = [];
-    const recentExchanges = this.exchanges.slice(-2);
-    for (const exchange of recentExchanges) {
-      messages.push({ role: "user", content: exchange.userMessage });
-      messages.push({ role: "assistant", content: exchange.assistantResponse });
-    }
-    messages.push({ role: "user", content: currentUserMessage });
-    return messages;
-  }
-  /**
-   * Store a text-only exchange (no tool calls).
-   * Keeps only last 2 exchanges for context.
-   */
-  storeTextExchange(userMessage, assistantResponse) {
-    this.exchanges.push({
-      userMessage,
-      assistantResponse,
-      timestamp: Date.now()
-    });
-    if (this.exchanges.length > 2) {
-      this.exchanges = this.exchanges.slice(-2);
+    } else if (choice === "2") {
+      kalshiKey = await prompt("Enter your Kalshi API key: ", true);
+    } else {
+      skipKalshi = true;
     }
   }
-  /**
-   * Extract final text response from assistant content blocks.
-   * Filters out tool_use blocks, returns only text.
-   */
-  extractTextResponse(content) {
-    const textBlocks = content.filter((block) => block.type === "text");
-    return textBlocks.map((block) => block.text).join("\n").trim();
-  }
-  /**
-   * Set working directory
-   */
-  setWorkingDirectory(dir) {
-    this.workingDirectory = dir;
+  if (kalshiKey) {
+    config.setKalshiApiKey(kalshiKey);
+    console.log(chalk.green("\u2713 Kalshi API key saved\n"));
+  } else if (skipKalshi) {
+    console.log(chalk.dim("\u2713 Kalshi disabled - you can set it up later via the agent\n"));
+  } else {
+    console.log(chalk.dim("\u2713 No Kalshi key - you can set it up later\n"));
   }
-  /**
-   * Get working directory
-   */
-  getWorkingDirectory() {
-    return this.workingDirectory;
+  console.log(chalk.bold("Step 4: Exa API Key (Optional)"));
+  console.log(chalk.dim("Powers web search. Get one free at https://dashboard.exa.ai"));
+  console.log(chalk.dim("Without this, web search will use DuckDuckGo as fallback.\n"));
+  const exaKey = await prompt("Enter your Exa API key (or press Enter to skip): ", true);
+  if (exaKey) {
+    console.log(chalk.green("\u2713 Great! Add this to your shell profile:"));
+    console.log(chalk.cyan(`   export EXA_API_KEY="${exaKey}"`));
+    console.log();
+  } else {
+    console.log(chalk.dim("Skipped. Web search will use DuckDuckGo.\n"));
   }
-  /**
-   * Update cumulative token usage from API response
-   * @param usage - Token counts from the API response
-   * @param preCalculatedCost - Optional pre-calculated cost (from OpenRouter provider)
-   */
-  /**
-   * Check if a tool call would create a loop (same call repeated too many times).
-   * Returns true if this call is part of a loop and should be stopped.
-   */
-  checkToolCallLoop(toolName, input) {
-    const inputStr = JSON.stringify(input);
-    const callSignature = `${toolName}:${inputStr}`;
-    this.recentToolCalls.push({ name: toolName, input: inputStr });
-    if (this.recentToolCalls.length > _Agent.MAX_RECENT_TOOL_CALLS) {
-      this.recentToolCalls.shift();
-    }
-    const duplicateCount = this.recentToolCalls.filter(
-      (call) => call.name === toolName && call.input === inputStr
-    ).length;
-    if (duplicateCount >= _Agent.LOOP_THRESHOLD) {
-      console.warn(`[Loop Detection] Tool "${toolName}" called ${duplicateCount} times with identical input. Stopping loop.`);
-      return true;
+  console.log(chalk.bold("Step 5: Verifying connections..."));
+  try {
+    const discoveryClient = createMCPClient(DISCOVERY_MCP_URL, DISCOVERY_MCP_PUBLIC_KEY, "discovery");
+    const discoveryResult = await discoveryClient.callTool("get_market_stats", {});
+    if (discoveryResult.success) {
+      console.log(chalk.green("\u2713 Discovery MCP connected"));
+    } else {
+      console.log(chalk.yellow("\u26A0 Discovery MCP: " + (discoveryResult.error || "Unknown error")));
     }
-    return false;
-  }
-  /**
-   * Clear the tool call loop tracking (call when starting a new user message)
-   */
-  clearToolCallLoopTracking() {
-    this.recentToolCalls = [];
-  }
-  updateTokenUsage(usage, preCalculatedCost) {
-    const model = this.config.model ?? DEFAULT_MODEL;
-    this.cumulativeTokenUsage.inputTokens = usage.input_tokens;
-    this.cumulativeTokenUsage.outputTokens += usage.output_tokens;
-    this.cumulativeTokenUsage.cacheCreationInputTokens = usage.cache_creation_input_tokens || 0;
-    this.cumulativeTokenUsage.cacheReadInputTokens = usage.cache_read_input_tokens || 0;
-    this.cumulativeTokenUsage.totalTokens = this.cumulativeTokenUsage.inputTokens + this.cumulativeTokenUsage.outputTokens;
-    const callCost = preCalculatedCost ?? calculateCost(
-      model,
-      usage.input_tokens,
-      usage.output_tokens,
-      usage.cache_creation_input_tokens || 0,
-      usage.cache_read_input_tokens || 0
-    );
-    this.sessionCost += callCost.totalCost;
-    this.cumulativeTokenUsage.cost = callCost;
-    this.cumulativeTokenUsage.sessionCost = this.sessionCost;
-    this.config.onTokenUsage?.(this.cumulativeTokenUsage);
-  }
-  /**
-   * Get current token usage estimate
-   */
-  getTokenUsage() {
-    return { ...this.cumulativeTokenUsage };
+  } catch (error2) {
+    console.log(chalk.yellow("\u26A0 Could not verify Discovery MCP"));
+    console.log(chalk.dim(String(error2)));
   }
-  /**
-   * Count tokens in current conversation (uses Anthropic's token counting API)
-   */
-  async countTokens() {
-    const model = this.config.model ?? (this.config.provider === "openrouter" ? "z-ai/glm-4.7" : "claude-sonnet-4-5-20250929");
-    const systemPrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    const allTools = await this.getAllTools();
+  if (quantishKey) {
     try {
-      const response = await this.anthropic.messages.countTokens({
-        model,
-        system: systemPrompt,
-        tools: allTools,
-        messages: this.conversationHistory
-      });
-      return response.input_tokens;
-    } catch (error2) {
-      return this.cumulativeTokenUsage.inputTokens;
-    }
-  }
-  /**
-   * Reset token usage (e.g., after compaction)
-   */
-  resetTokenUsage() {
-    this.sessionCost = 0;
-    this.cumulativeTokenUsage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheCreationInputTokens: 0,
-      cacheReadInputTokens: 0,
-      totalTokens: 0,
-      cost: { inputCost: 0, outputCost: 0, cacheWriteCost: 0, cacheReadCost: 0, totalCost: 0 },
-      sessionCost: 0
-    };
-  }
-  /**
-   * Get the current model being used
-   */
-  getModel() {
-    return this.config.model ?? DEFAULT_MODEL;
-  }
-  /**
-   * Set the model to use for future requests
-   */
-  setModel(modelIdOrAlias) {
-    let resolvedId = resolveModelId(modelIdOrAlias);
-    let displayName;
-    if (resolvedId) {
-      const modelConfig = getModelConfig(resolvedId);
-      displayName = modelConfig?.displayName;
-    } else {
-      resolvedId = resolveOpenRouterModelId(modelIdOrAlias);
-      if (resolvedId) {
-        const orConfig = getOpenRouterModelConfig(resolvedId);
-        displayName = orConfig?.displayName ?? resolvedId;
-        if (!this.isOpenRouter() && resolvedId.includes("/")) {
-          this.config.provider = "openrouter";
+      const tradingClient = createMCPClient(config.getTradingMcpUrl(), quantishKey, "trading");
+      const result = await tradingClient.callTool("get_wallet_status", {});
+      if (result.success && typeof result.data === "object" && result.data !== null) {
+        const data = result.data;
+        console.log(chalk.green("\u2713 Polymarket MCP connected"));
+        if (data.safeAddress) {
+          console.log(chalk.dim(`  Safe Address: ${data.safeAddress}`));
+          console.log(chalk.dim(`  Status: READY`));
+        } else {
+          console.log(chalk.dim(`  Safe Address: Will deploy on first trade`));
+          console.log(chalk.dim(`  Status: CREATED (wallet ready, Safe deploys on first trade)`));
         }
+      } else {
+        console.log(chalk.yellow("\u26A0 Polymarket MCP: " + (result.error || "Unknown error")));
       }
+    } catch (error2) {
+      console.log(chalk.yellow("\u26A0 Could not verify Polymarket MCP connection."));
+      console.log(chalk.dim(String(error2)));
     }
-    if (!resolvedId) {
-      const anthropicModels = Object.values(MODELS).map((m) => m.name).join(", ");
-      const orModels = Object.values(OPENROUTER_MODELS2).slice(0, 5).map((m) => m.name).join(", ");
-      return {
-        success: false,
-        error: `Unknown model: "${modelIdOrAlias}". Anthropic: ${anthropicModels}. OpenRouter: ${orModels}, ...`
-      };
-    }
-    this.config.model = resolvedId;
-    this.llmProvider = void 0;
-    return {
-      success: true,
-      model: displayName ?? resolvedId
-    };
-  }
-  /**
-   * Get session cost so far
-   */
-  getSessionCost() {
-    return this.sessionCost;
+  } else {
+    console.log(chalk.dim("\u23ED Polymarket MCP skipped (no API key)"));
   }
-  /**
-   * Compact the conversation history to reduce token usage.
-   * 
-   * This uses the current LLM to create a structured summary of the conversation,
-   * then replaces the history with just the summary. This dramatically
-   * reduces token count while preserving important context.
-   * 
-   * @returns Object with original/new token counts and the summary
-   */
-  async compactHistory() {
-    if (this.conversationHistory.length < 2) {
-      return {
-        success: false,
-        originalTokenCount: 0,
-        newTokenCount: 0,
-        error: "Conversation too short to compact"
-      };
-    }
+  if (kalshiKey) {
     try {
-      const originalContentLength = JSON.stringify(this.conversationHistory).length;
-      const originalTokens = Math.ceil(originalContentLength / 4);
-      const compactionPrompt = `Your context window is filling up. Create a concise summary of our conversation so far.
-
-Include:
-- User's main goals and what was accomplished
-- Files created/modified (with paths)
-- Key decisions and discoveries  
-- Next steps still needed
-- Any important context to preserve
-
-Be thorough but concise. The goal is to capture everything needed to continue seamlessly.`;
-      const compactionMessages = [
-        ...this.conversationHistory,
-        { role: "user", content: compactionPrompt }
-      ];
-      let summary;
-      if (this.config.provider === "openrouter" && this.llmProvider) {
-        const response = await this.llmProvider.chat(compactionMessages);
-        summary = response.text;
+      const kalshiClient = createMCPClient(KALSHI_MCP_URL, kalshiKey, "kalshi");
+      const result = await kalshiClient.callTool("kalshi_get_wallet_info", {});
+      if (result.success && typeof result.data === "object" && result.data !== null) {
+        const data = result.data;
+        const wallet = data.wallet;
+        const publicKey = wallet?.publicKey;
+        console.log(chalk.green("\u2713 Kalshi MCP connected"));
+        console.log(chalk.dim(`  Solana Address: ${publicKey || "No wallet yet"}`));
+        if (wallet) {
+          console.log(chalk.dim(`  Status: READY`));
+        }
       } else {
-        const model = this.config.model ?? DEFAULT_MODEL;
-        const response = await this.anthropic.messages.create({
-          model,
-          max_tokens: 4096,
-          messages: compactionMessages
-        });
-        const textBlocks = response.content.filter((block) => block.type === "text");
-        summary = textBlocks.map((block) => block.text).join("\n");
-      }
-      if (!summary || summary.trim().length === 0) {
-        throw new Error("Failed to generate summary");
+        console.log(chalk.yellow("\u26A0 Kalshi MCP: " + (result.error || "Unknown error")));
       }
-      const newHistory = [
-        { role: "assistant", content: summary.trim() }
-      ];
-      const newContentLength = JSON.stringify(newHistory).length;
-      const newTokens = Math.ceil(newContentLength / 4);
-      this.conversationHistory = newHistory;
-      this.resetTokenUsage();
-      this.cumulativeTokenUsage.inputTokens = newTokens;
-      this.cumulativeTokenUsage.totalTokens = newTokens;
-      this.config.onTokenUsage?.(this.cumulativeTokenUsage);
-      return {
-        success: true,
-        summary: summary.trim(),
-        originalTokenCount: originalTokens,
-        newTokenCount: newTokens
-      };
     } catch (error2) {
-      return {
-        success: false,
-        originalTokenCount: this.cumulativeTokenUsage.inputTokens,
-        newTokenCount: this.cumulativeTokenUsage.inputTokens,
-        error: error2 instanceof Error ? error2.message : String(error2)
-      };
+      console.log(chalk.yellow("\u26A0 Could not verify Kalshi MCP connection."));
+      console.log(chalk.dim(String(error2)));
     }
+  } else {
+    console.log(chalk.dim("\u23ED Kalshi MCP skipped (no API key)"));
   }
-  /**
-   * Set conversation history (useful for restoring state)
-   */
-  setHistory(history) {
-    this.conversationHistory = history;
-  }
-  /**
-   * Get conversation history (alias for getHistory)
-   */
-  getConversationHistory() {
-    return this.getHistory();
-  }
-  /**
-   * Set conversation history (alias for setHistory)
-   */
-  setConversationHistory(history) {
-    this.setHistory(history);
+  console.log();
+  console.log(chalk.bold.green("\u{1F389} Setup complete!"));
+  console.log();
+  console.log(chalk.bold("\u{1F4C1} Your credentials are saved:"));
+  console.log(chalk.dim(`   Local config: ${config.getConfigPath()}`));
+  console.log(chalk.dim("   Wallet keys:  Encrypted on Quantish server (accessible via your API key)"));
+  console.log();
+  console.log("You can now use Quantish CLI:");
+  console.log(chalk.yellow("  quantish") + " - Start interactive chat");
+  console.log(chalk.yellow('  quantish -p "check my balance"') + " - One-shot command");
+  console.log(chalk.yellow("  quantish tools") + " - List available tools");
+  console.log(chalk.yellow("  quantish config") + " - View configuration");
+  console.log(chalk.yellow("  quantish config --export") + " - Export keys for your own agents");
+  console.log();
+  console.log(chalk.dim("Your wallet is managed by the Quantish Signing Server."));
+  console.log(chalk.dim("The CLOB signing credentials are stored encrypted on the server."));
+  console.log(chalk.dim('To export your private key: quantish -p "export my private key"'));
+  console.log();
+  return true;
+}
+async function ensureConfigured() {
+  const config = getConfigManager();
+  if (!config.isConfigured()) {
+    console.log(chalk.yellow("Quantish CLI is not configured yet.\n"));
+    return await runSetup();
   }
-};
-function createAgent(config) {
-  return new Agent(config);
+  return true;
 }
 
 // src/ui/output.ts
@@ -4496,12 +722,12 @@ import Spinner from "ink-spinner";
 
 // src/config/sessions.ts
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync, readFileSync } from "fs";
-var SESSIONS_DIR = join3(homedir2(), ".quantish", "sessions");
-var INDEX_FILE = join3(SESSIONS_DIR, "index.json");
+import { join as join2 } from "path";
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync, readFileSync } from "fs";
+var SESSIONS_DIR = join2(homedir2(), ".quantish", "sessions");
+var INDEX_FILE = join2(SESSIONS_DIR, "index.json");
 function ensureSessionsDir() {
-  if (!existsSync2(SESSIONS_DIR)) {
+  if (!existsSync(SESSIONS_DIR)) {
     mkdirSync(SESSIONS_DIR, { recursive: true });
   }
 }
@@ -4512,7 +738,7 @@ function generateSessionId() {
 }
 function loadIndex() {
   ensureSessionsDir();
-  if (!existsSync2(INDEX_FILE)) {
+  if (!existsSync(INDEX_FILE)) {
     return { lastSessionId: null, sessions: [] };
   }
   try {
@@ -4527,7 +753,7 @@ function saveIndex(index) {
   writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2), "utf-8");
 }
 function getSessionPath(id) {
-  return join3(SESSIONS_DIR, `${id}.json`);
+  return join2(SESSIONS_DIR, `${id}.json`);
 }
 var SessionManager = class {
   /**
@@ -4582,7 +808,7 @@ var SessionManager = class {
    */
   getSession(id) {
     const sessionPath = getSessionPath(id);
-    if (!existsSync2(sessionPath)) {
+    if (!existsSync(sessionPath)) {
       return null;
     }
     try {
@@ -4627,7 +853,7 @@ var SessionManager = class {
    */
   deleteSession(id) {
     const sessionPath = getSessionPath(id);
-    if (!existsSync2(sessionPath)) {
+    if (!existsSync(sessionPath)) {
       return false;
     }
     try {
@@ -4652,7 +878,7 @@ var SessionManager = class {
       const files = readdirSync(SESSIONS_DIR);
       for (const file of files) {
         try {
-          unlinkSync(join3(SESSIONS_DIR, file));
+          unlinkSync(join2(SESSIONS_DIR, file));
         } catch {
         }
       }
@@ -4761,6 +987,9 @@ function App({ agent, onExit }) {
     cost: { inputCost: 0, outputCost: 0, cacheWriteCost: 0, cacheReadCost: 0, totalCost: 0 },
     sessionCost: 0
   });
+  const [prevInputTokens, setPrevInputTokens] = useState(0);
+  const [contextStatus, setContextStatus] = useState(null);
+  const [turnCount, setTurnCount] = useState(0);
   const completedToolCalls = useRef([]);
   const abortController = useRef(null);
   const [queuedInput, setQueuedInput] = useState("");
@@ -5382,7 +1611,22 @@ Use /load <id> to load a session.`
       onStreamEnd: () => {
       },
       onTokenUsage: (usage) => {
-        setTokenUsage(usage);
+        setTokenUsage((prev) => {
+          if (prev.inputTokens > 0 && usage.inputTokens < prev.inputTokens * 0.5) {
+            setContextStatus(`\u2193${formatTokenCount(prev.inputTokens - usage.inputTokens)} saved`);
+            setTimeout(() => setContextStatus(null), 5e3);
+          } else if (usage.inputTokens > prev.inputTokens * 1.5 && prev.inputTokens > 1e4) {
+            setContextStatus("tool results (ephemeral)");
+            setTimeout(() => setContextStatus(null), 8e3);
+          }
+          setPrevInputTokens(prev.inputTokens);
+          return usage;
+        });
+      },
+      onCompression: (toolName, originalSize, compressedSize) => {
+        const savedPercent = Math.round((1 - compressedSize / originalSize) * 100);
+        setContextStatus(`${toolName}: compressed ${savedPercent}%`);
+        setTimeout(() => setContextStatus(null), 5e3);
       }
     };
     return () => {
@@ -5547,8 +1791,13 @@ Stopped ${count} background process${count > 1 ? "es" : ""}.`);
           tokenUsage.sessionCost > 0 ? " \u2022 " : "",
           "~",
           formatTokenCount(tokenUsage.inputTokens),
-          " tokens",
-          tokenUsage.inputTokens >= 8e4 && " (/compact)"
+          " ctx",
+          contextStatus && /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+            " (",
+            contextStatus,
+            ")"
+          ] }),
+          !contextStatus && tokenUsage.inputTokens >= 8e4 && " (/compact)"
         ] }),
         /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
           tokenUsage.totalTokens > 0 ? " \u2022 " : "",
@@ -5972,17 +2221,17 @@ async function runOneShotPrompt(message, options = {}) {
   }
 }
 async function readStdin() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve2(data.trim());
+      resolve(data.trim());
     });
     setTimeout(() => {
-      resolve2(data.trim());
+      resolve(data.trim());
     }, 100);
   });
 }