@quantish/agent 0.1.15 → 0.1.17

package/dist/index.js

@@ -18,6 +18,9 @@ var schema = {
   anthropicApiKey: {
     type: "string"
   },
+  openrouterApiKey: {
+    type: "string"
+  },
   quantishApiKey: {
     type: "string"
   },
@@ -28,6 +31,10 @@ var schema = {
   model: {
     type: "string",
     default: "claude-sonnet-4-5-20250929"
+  },
+  provider: {
+    type: "string",
+    default: "anthropic"
   }
 };
 var ConfigManager = class {
@@ -54,6 +61,20 @@ var ConfigManager = class {
   setAnthropicApiKey(key) {
     this.conf.set("anthropicApiKey", key);
   }
+  /**
+   * Get the OpenRouter API key
+   */
+  getOpenRouterApiKey() {
+    const envKey = process.env.OPENROUTER_API_KEY;
+    if (envKey) return envKey;
+    return this.conf.get("openrouterApiKey");
+  }
+  /**
+   * Set the OpenRouter API key
+   */
+  setOpenRouterApiKey(key) {
+    this.conf.set("openrouterApiKey", key);
+  }
   /**
    * Get the Quantish API key
    */
@@ -68,13 +89,22 @@ var ConfigManager = class {
   setQuantishApiKey(key) {
     this.conf.set("quantishApiKey", key);
   }
+  /**
+   * Get the current LLM provider
+   */
+  getProvider() {
+    return this.conf.get("provider") ?? "anthropic";
+  }
+  /**
+   * Set the LLM provider
+   */
+  setProvider(provider) {
+    this.conf.set("provider", provider);
+  }
   /**
    * Get the Trading MCP server URL (user's wallet/orders)
-   * Priority: MCP_SERVER_URL env var > config file > default
    */
   getMcpServerUrl() {
-    const envUrl = process.env.MCP_SERVER_URL;
-    if (envUrl) return envUrl;
     return this.conf.get("mcpServerUrl") ?? DEFAULT_MCP_URL;
   }
   /**
@@ -101,12 +131,6 @@ var ConfigManager = class {
   setMcpServerUrl(url) {
     this.conf.set("mcpServerUrl", url);
   }
-  /**
-   * Generic setter for any config key
-   */
-  set(key, value) {
-    this.conf.set(key, value);
-  }
   /**
    * Get the model to use
    */
@@ -120,13 +144,27 @@ var ConfigManager = class {
     this.conf.set("model", model);
   }
   /**
-   * Check if the CLI is configured (has at least Anthropic key)
+   * Check if the CLI is configured (has required LLM API key)
    * Discovery MCP works without any user key (embedded public key)
    * Trading MCP requires a user key
    */
   isConfigured() {
+    const provider = this.getProvider();
+    if (provider === "openrouter") {
+      return !!this.getOpenRouterApiKey();
+    }
     return !!this.getAnthropicApiKey();
   }
+  /**
+   * Get the appropriate LLM API key based on current provider
+   */
+  getLLMApiKey() {
+    const provider = this.getProvider();
+    if (provider === "openrouter") {
+      return this.getOpenRouterApiKey();
+    }
+    return this.getAnthropicApiKey();
+  }
   /**
    * Check if trading is enabled (has Quantish API key)
    */
@@ -139,9 +177,11 @@ var ConfigManager = class {
   getAll() {
     return {
       anthropicApiKey: this.getAnthropicApiKey(),
+      openrouterApiKey: this.getOpenRouterApiKey(),
       quantishApiKey: this.getQuantishApiKey(),
       mcpServerUrl: this.getMcpServerUrl(),
-      model: this.getModel()
+      model: this.getModel(),
+      provider: this.getProvider()
     };
   }
   /**
@@ -527,27 +567,61 @@ async function runSetup() {
     return false;
   }
   console.log();
-  console.log(chalk.bold("Step 1: Anthropic API Key"));
-  console.log(chalk.dim("Powers the AI agent. Get yours at https://console.anthropic.com/"));
-  let anthropicKey = config.getAnthropicApiKey();
-  if (anthropicKey) {
-    console.log(chalk.dim(`Current: ${anthropicKey.slice(0, 10)}...`));
-    const newKey = await prompt("Enter new key (or press Enter to keep current): ", true);
-    if (newKey) {
-      anthropicKey = newKey;
+  console.log(chalk.bold("Step 1: Choose your LLM Provider"));
+  console.log(chalk.dim("The AI that powers the agent.\n"));
+  console.log("  1. " + chalk.cyan("Anthropic") + chalk.dim(" (Claude models - Opus, Sonnet, Haiku)"));
+  console.log("  2. " + chalk.green("OpenRouter") + chalk.dim(" (Access 100+ models - MiniMax, DeepSeek, etc.)\n"));
+  const providerChoice = await prompt("Choose (1 or 2): ");
+  const useOpenRouter = providerChoice === "2";
+  if (useOpenRouter) {
+    config.setProvider("openrouter");
+    console.log();
+    console.log(chalk.bold("OpenRouter API Key"));
+    console.log(chalk.dim("Get yours at https://openrouter.ai/keys\n"));
+    let openrouterKey = config.getOpenRouterApiKey();
+    if (openrouterKey) {
+      console.log(chalk.dim(`Current: ${openrouterKey.slice(0, 10)}...`));
+      const newKey = await prompt("Enter new key (or press Enter to keep current): ", true);
+      if (newKey) {
+        openrouterKey = newKey;
+      }
+    } else {
+      openrouterKey = await prompt("Enter your OpenRouter API key: ", true);
     }
+    if (!openrouterKey) {
+      console.log(chalk.red("OpenRouter API key is required."));
+      return false;
+    }
+    if (!openrouterKey.startsWith("sk-or-")) {
+      console.log(chalk.yellow("Warning: Key doesn't look like an OpenRouter key (should start with sk-or-)"));
+    }
+    config.setOpenRouterApiKey(openrouterKey);
+    console.log(chalk.green("\u2713 OpenRouter API key saved\n"));
   } else {
-    anthropicKey = await prompt("Enter your Anthropic API key: ", true);
-  }
-  if (!anthropicKey) {
-    console.log(chalk.red("Anthropic API key is required."));
-    return false;
-  }
-  if (!anthropicKey.startsWith("sk-ant-")) {
-    console.log(chalk.yellow("Warning: Key doesn't look like an Anthropic key (should start with sk-ant-)"));
+    config.setProvider("anthropic");
+    console.log();
+    console.log(chalk.bold("Anthropic API Key"));
+    console.log(chalk.dim("Get yours at https://console.anthropic.com/\n"));
+    let anthropicKey = config.getAnthropicApiKey();
+    if (anthropicKey) {
+      console.log(chalk.dim(`Current: ${anthropicKey.slice(0, 10)}...`));
+      const newKey = await prompt("Enter new key (or press Enter to keep current): ", true);
+      if (newKey) {
+        anthropicKey = newKey;
+      }
+    } else {
+      anthropicKey = await prompt("Enter your Anthropic API key: ", true);
+    }
+    if (!anthropicKey) {
+      console.log(chalk.red("Anthropic API key is required."));
+      return false;
+    }
+    if (!anthropicKey.startsWith("sk-ant-")) {
+      console.log(chalk.yellow("Warning: Key doesn't look like an Anthropic key (should start with sk-ant-)"));
+    }
+    config.setAnthropicApiKey(anthropicKey);
+    console.log(chalk.green("\u2713 Anthropic API key saved\n"));
   }
-  config.setAnthropicApiKey(anthropicKey);
-  console.log(chalk.green("\u2713 Anthropic API key saved\n"));
   console.log(chalk.bold("Step 2: Polymarket Trading (Optional)"));
   console.log(chalk.dim("Enable trading on Polymarket with your own managed wallet."));
   console.log(chalk.dim("Skip this if you only want to search/discover markets.\n"));
@@ -681,15 +755,14 @@ async function runSetup() {
 async function ensureConfigured() {
   const config = getConfigManager();
   if (!config.isConfigured()) {
-    console.log(chalk.yellow("Quantish CLI is not configured yet."));
-    console.log("Run " + chalk.yellow("quantish init") + " to set up.\n");
-    return false;
+    console.log(chalk.yellow("Quantish CLI is not configured yet.\n"));
+    return await runSetup();
   }
   return true;
 }
 
 // src/agent/loop.ts
-import Anthropic from "@anthropic-ai/sdk";
+import Anthropic2 from "@anthropic-ai/sdk";
 
 // src/tools/filesystem.ts
 import * as fs from "fs/promises";
@@ -780,41 +853,6 @@ async function fileExists(filePath) {
     return { success: false, error: `Failed to check file: ${error2 instanceof Error ? error2.message : String(error2)}` };
   }
 }
-async function editLines(filePath, startLine, endLine, newContent) {
-  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");
-    const lines = content.split("\n");
-    if (startLine < 1 || endLine < startLine || startLine > lines.length) {
-      return {
-        success: false,
-        error: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`
-      };
-    }
-    const startIdx = startLine - 1;
-    const endIdx = Math.min(endLine, lines.length);
-    const newLines = newContent.split("\n");
-    const beforeLines = lines.slice(0, startIdx);
-    const afterLines = lines.slice(endIdx);
-    const resultLines = [...beforeLines, ...newLines, ...afterLines];
-    const newFileContent = resultLines.join("\n");
-    await fs.writeFile(resolvedPath, newFileContent, "utf-8");
-    return {
-      success: true,
-      data: {
-        path: resolvedPath,
-        linesReplaced: endIdx - startIdx,
-        newLinesInserted: newLines.length,
-        totalLines: resultLines.length
-      }
-    };
-  } catch (error2) {
-    return { success: false, error: `Failed to edit lines: ${error2 instanceof Error ? error2.message : String(error2)}` };
-  }
-}
 async function editFile(filePath, oldString, newString, options) {
   try {
     const resolvedPath = path.resolve(filePath);
@@ -932,35 +970,9 @@ var filesystemTools = [
       required: ["path"]
     }
   },
-  {
-    name: "edit_lines",
-    description: "Edit specific lines in a file by line number. MORE EFFICIENT than edit_file - use this when you know the line numbers from read_file. Only sends line numbers + new content, not full old content.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: "The path to the file to edit"
-        },
-        start_line: {
-          type: "number",
-          description: "The first line number to replace (1-based, inclusive)"
-        },
-        end_line: {
-          type: "number",
-          description: "The last line number to replace (1-based, inclusive)"
-        },
-        new_content: {
-          type: "string",
-          description: "The new content to insert (replaces lines start_line through end_line)"
-        }
-      },
-      required: ["path", "start_line", "end_line", "new_content"]
-    }
-  },
   {
     name: "edit_file",
-    description: "Edit a file by replacing a specific string with new content. Use edit_lines instead when you know line numbers - it uses fewer tokens.",
+    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: {
@@ -983,111 +995,8 @@ var filesystemTools = [
       },
       required: ["path", "old_string", "new_string"]
     }
-  },
-  {
-    name: "setup_env",
-    description: "Setup or update environment variables in a .env file for an application. Creates .env if it doesn't exist. Optionally creates a .env.example template. Use this when building any application that needs API keys or configuration.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string",
-          description: 'Path to the .env file (default: ".env" in current directory)'
-        },
-        variables: {
-          type: "object",
-          description: 'Object with environment variable names as keys and values. Example: { "QUANTISH_API_KEY": "abc123", "TOKEN_ID": "xyz" }',
-          additionalProperties: { type: "string" }
-        },
-        overwrite: {
-          type: "boolean",
-          description: "If true, overwrite existing variables. Default false (skip existing)."
-        },
-        create_example: {
-          type: "boolean",
-          description: "If true, also create a .env.example template file with placeholder values."
-        }
-      },
-      required: ["variables"]
-    }
   }
 ];
-async function setupEnv(envPath = ".env", variables, options) {
-  try {
-    const resolvedPath = path.resolve(envPath);
-    let content = "";
-    const existingVars = {};
-    if (existsSync(resolvedPath)) {
-      content = await fs.readFile(resolvedPath, "utf-8");
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed && !trimmed.startsWith("#")) {
-          const eqIndex = trimmed.indexOf("=");
-          if (eqIndex > 0) {
-            const key = trimmed.slice(0, eqIndex);
-            const value = trimmed.slice(eqIndex + 1);
-            existingVars[key] = value;
-          }
-        }
-      }
-    }
-    const updatedVars = [];
-    const addedVars = [];
-    const skippedVars = [];
-    for (const [key, value] of Object.entries(variables)) {
-      if (existingVars[key] !== void 0) {
-        if (options?.overwrite) {
-          const regex = new RegExp(`^${key}=.*$`, "m");
-          content = content.replace(regex, `${key}=${value}`);
-          updatedVars.push(key);
-        } else {
-          skippedVars.push(key);
-        }
-      } else {
-        if (content && !content.endsWith("\n")) {
-          content += "\n";
-        }
-        content += `${key}=${value}
-`;
-        addedVars.push(key);
-      }
-    }
-    await fs.writeFile(resolvedPath, content, "utf-8");
-    if (options?.createExample) {
-      const examplePath = resolvedPath.replace(/\.env$/, ".env.example");
-      let exampleContent = "# Environment variables for this application\n";
-      exampleContent += "# Copy this file to .env and fill in your values\n\n";
-      for (const key of Object.keys({ ...existingVars, ...variables })) {
-        if (key === "QUANTISH_API_KEY") {
-          exampleContent += `# Get your API key at https://quantish.live
-`;
-          exampleContent += `${key}=your_api_key_here
-
-`;
-        } else {
-          exampleContent += `${key}=
-`;
-        }
-      }
-      await fs.writeFile(examplePath, exampleContent, "utf-8");
-    }
-    return {
-      success: true,
-      data: {
-        path: resolvedPath,
-        added: addedVars,
-        updated: updatedVars,
-        skipped: skippedVars,
-        exampleCreated: options?.createExample || false
-      }
-    };
-  } catch (error2) {
-    return {
-      success: false,
-      error: `Failed to setup env: ${error2 instanceof Error ? error2.message : String(error2)}`
-    };
-  }
-}
 async function executeFilesystemTool(name, args) {
   switch (name) {
     case "read_file":
@@ -1103,13 +1012,6 @@ async function executeFilesystemTool(name, args) {
       return deleteFile(args.path);
     case "file_exists":
       return fileExists(args.path);
-    case "edit_lines":
-      return editLines(
-        args.path,
-        args.start_line,
-        args.end_line,
-        args.new_content
-      );
     case "edit_file":
       return editFile(
         args.path,
@@ -1117,15 +1019,6 @@ async function executeFilesystemTool(name, args) {
         args.new_string,
         { replaceAll: args.replace_all }
       );
-    case "setup_env":
-      return setupEnv(
-        args.path || ".env",
-        args.variables,
-        {
-          overwrite: args.overwrite,
-          createExample: args.create_example
-        }
-      );
     default:
       return { success: false, error: `Unknown filesystem tool: ${name}` };
   }
@@ -2425,16 +2318,16 @@ async function compactConversation(anthropic, history, model, systemPrompt, tool
 
 // src/agent/pricing.ts
 var MODELS = {
-  "claude-opus-4-5-20251101": {
-    id: "claude-opus-4-5-20251101",
+  "claude-opus-4-5-20250929": {
+    id: "claude-opus-4-5-20250929",
     name: "opus-4.5",
     displayName: "Claude Opus 4.5",
     pricing: {
-      inputPerMTok: 15,
-      outputPerMTok: 75,
-      cacheWritePerMTok: 18.75,
+      inputPerMTok: 5,
+      outputPerMTok: 25,
+      cacheWritePerMTok: 6.25,
       // 1.25x input
-      cacheReadPerMTok: 1.5
+      cacheReadPerMTok: 0.5
       // 0.1x input
     },
     contextWindow: 2e5,
@@ -2455,8 +2348,8 @@ var MODELS = {
     contextWindow: 2e5,
     description: "Balanced performance and cost. Great for most coding and trading tasks."
   },
-  "claude-haiku-4-5-20251001": {
-    id: "claude-haiku-4-5-20251001",
+  "claude-haiku-4-5-20250929": {
+    id: "claude-haiku-4-5-20250929",
     name: "haiku-4.5",
     displayName: "Claude Haiku 4.5",
     pricing: {
@@ -2473,12 +2366,12 @@ var MODELS = {
 };
 var DEFAULT_MODEL = "claude-sonnet-4-5-20250929";
 var MODEL_ALIASES = {
-  "opus": "claude-opus-4-5-20251101",
-  "opus-4.5": "claude-opus-4-5-20251101",
+  "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-20251001",
-  "haiku-4.5": "claude-haiku-4-5-20251001"
+  "haiku": "claude-haiku-4-5-20250929",
+  "haiku-4.5": "claude-haiku-4-5-20250929"
 };
 function resolveModelId(nameOrAlias) {
   const lower = nameOrAlias.toLowerCase();
@@ -2545,6 +2438,744 @@ function listModels() {
   return Object.values(MODELS);
 }
 
+// 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_MODELS = {
+  // 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 = {
+  // 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_MODELS[lower]) {
+    return lower;
+  }
+  if (OPENROUTER_ALIASES[lower]) {
+    return OPENROUTER_ALIASES[lower];
+  }
+  for (const [id, config] of Object.entries(OPENROUTER_MODELS)) {
+    if (config.name.toLowerCase() === lower) {
+      return id;
+    }
+  }
+  if (nameOrAlias.includes("/")) {
+    return nameOrAlias;
+  }
+  return null;
+}
+function getOpenRouterModelConfig(modelId) {
+  return OPENROUTER_MODELS[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) {
+  const config = getOpenRouterModelConfig(modelId);
+  const pricing = config?.pricing ?? {
+    inputPerMTok: 1,
+    outputPerMTok: 3,
+    cacheReadPerMTok: 0.1,
+    cacheWritePerMTok: 1.25
+  };
+  const inputCost = inputTokens / 1e6 * pricing.inputPerMTok;
+  const outputCost = outputTokens / 1e6 * pricing.outputPerMTok;
+  const cacheReadCost = cacheReadTokens / 1e6 * (pricing.cacheReadPerMTok ?? pricing.inputPerMTok * 0.1);
+  const cacheWriteCost = cacheWriteTokens / 1e6 * (pricing.cacheWritePerMTok ?? pricing.inputPerMTok * 1.25);
+  return {
+    inputCost,
+    outputCost,
+    cacheReadCost,
+    cacheWriteCost,
+    totalCost: inputCost + outputCost + cacheReadCost + cacheWriteCost
+  };
+}
+function listOpenRouterModels() {
+  return Object.values(OPENROUTER_MODELS);
+}
+
+// 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 {
+        const input = JSON.parse(tc.arguments || "{}");
+        toolCalls.push({ id: tc.id, name: tc.name, input });
+        callbacks.onToolCall?.(tc.id, tc.name, input);
+      } catch {
+      }
+    }
+    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 MAX_TOOL_RESULT_CHARS = 8e3;
 function truncateToolResult(result, toolName) {
@@ -2729,82 +3360,36 @@ function extractTokenInfo(token) {
     price: token.price ?? token.probability
   };
 }
-var DEFAULT_SYSTEM_PROMPT = `You are Quantish, an AI coding and trading agent. Be concise.
-
-## APIs
-
-TRADING (requires QUANTISH_API_KEY):
-- URL: https://quantish-sdk-production.up.railway.app/mcp/execute
-- Format: JSON-RPC 2.0 { jsonrpc: '2.0', method: 'tools/call', params: { name, arguments }, id }
-- Tools: get_balances, get_positions, place_order, cancel_order, get_orders, get_orderbook, get_price
+var DEFAULT_SYSTEM_PROMPT = `You are Quantish, an AI coding and trading agent.
 
-DISCOVERY (free):
-- URL: https://quantish.live/mcp/execute
-- Format: { name, arguments }
-- Key: qm_ueQeqrmvZyHtR1zuVbLYkhx0fKyVAuV8
-- Tools: search_markets, get_market_details, get_trending_markets
+You have two sets of capabilities:
 
-## Response Structures (IMPORTANT - use these field paths)
-
-search_markets / get_trending_markets returns:
-{
-  "found": N,
-  "markets": [{ "platform", "id", "title", "markets": [{ "marketId", "question", "outcomes": [{ "name", "price" }], "clobTokenIds": "[json_array]", "conditionId" }] }]
-}
-
-get_market_details returns:
-{
-  "platform": "polymarket",
-  "id": "12345",
-  "conditionId": "0x...",
-  "title": "Market Title",
-  "clobTokenIds": "["TOKEN_YES","TOKEN_NO"]",
-  "markets": [{
-    "marketId": "67890",
-    "question": "Question?",
-    "outcomes": [{ "name": "Yes", "price": 0.55 }, { "name": "No", "price": 0.45 }],
-    "clobTokenIds": "["TOKEN_YES","TOKEN_NO"]"
-  }]
-}
+## Trading Tools (via MCP)
+You can interact with Polymarket prediction markets:
+- Check wallet balances and positions
+- Place, cancel, and manage orders  
+- Transfer funds and claim winnings
+- Get market prices and orderbook data
 
-KEY FIELDS:
-- market.id = top-level ID for get_market_details
-- market.markets[0].marketId = sub-market ID
-- market.markets[0].outcomes[].name = "Yes"/"No" or outcome name
-- market.markets[0].outcomes[].price = decimal 0-1
-- JSON.parse(market.clobTokenIds || market.markets[0].clobTokenIds) = token IDs array
-- market.conditionId = condition ID for trading
+## Coding Tools (local)
+You can work with the local filesystem:
+- Read and write files
+- List directories and search with grep
+- Run shell commands
+- Use git for version control
 
-## Standalone App Code
+## Guidelines
+- Be concise and helpful
+- When making trades, always confirm details before proceeding
+- Prices on Polymarket are between 0.01 and 0.99 (probabilities)
+- Minimum order value is $1
+- When writing code, follow existing patterns and conventions
+- For dangerous operations (rm, sudo), explain what you're doing
 
-Trading helper:
-async function callTradingTool(name, args = {}) {
-  const res = await fetch('https://quantish-sdk-production.up.railway.app/mcp/execute', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.QUANTISH_API_KEY },
-    body: JSON.stringify({ jsonrpc: '2.0', method: 'tools/call', params: { name, arguments: args }, id: Date.now() })
-  });
-  return JSON.parse((await res.json()).result.content[0].text);
-}
-
-Discovery helper:
-async function callDiscoveryTool(name, args = {}) {
-  const res = await fetch('https://quantish.live/mcp/execute', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', 'X-API-Key': 'qm_ueQeqrmvZyHtR1zuVbLYkhx0fKyVAuV8' },
-    body: JSON.stringify({ name, arguments: args })
-  });
-  return JSON.parse((await res.json()).result.content[0].text);
-}
-
-## Rules
-1. Never use @modelcontextprotocol/sdk - use fetch()
-2. Always create .env.example and use dotenv
-3. Never hardcode/mock data - always fetch real data
-4. Check logs before restarting servers
-5. PREFER edit_lines over edit_file - uses line numbers, saves tokens`;
+You help users build trading bots and agents by combining coding skills with trading capabilities.`;
 var Agent = class {
   anthropic;
+  llmProvider;
   mcpClient;
   mcpClientManager;
   config;
@@ -2825,6 +3410,8 @@ var Agent = class {
     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 || [
         {
@@ -2839,14 +3426,176 @@ var Agent = class {
     if (this.config.contextEditing && this.config.contextEditing.length > 0) {
       headers["anthropic-beta"] = "context-management-2025-06-27";
     }
-    this.anthropic = new Anthropic({
-      apiKey: config.anthropicApiKey,
+    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() {
+    if (this.llmProvider) {
+      return this.llmProvider;
+    }
+    const allTools = await this.getAllTools();
+    const systemPrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    const model = this.config.model ?? DEFAULT_MODEL;
+    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 contextMessage = `[Working directory: ${this.workingDirectory}]
+
+${userMessage}`;
+    this.conversationHistory.push({
+      role: "user",
+      content: contextMessage
+    });
+    const toolCalls = [];
+    let iterations = 0;
+    let finalText = "";
+    while (iterations < maxIterations) {
+      iterations++;
+      this.config.onStreamStart?.();
+      let response;
+      if (useStreaming) {
+        response = await provider.streamChat(this.conversationHistory, {
+          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(this.conversationHistory);
+        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
+      });
+      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) {
+        this.conversationHistory.push({
+          role: "assistant",
+          content: responseContent
+        });
+        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);
+        toolCalls.push({
+          name: toolCall2.name,
+          input: toolCall2.input,
+          result,
+          source
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolCall2.id,
+          content: JSON.stringify(result)
+        });
+      }
+      this.conversationHistory.push({
+        role: "assistant",
+        content: responseContent
+      });
+      this.conversationHistory.push({
+        role: "user",
+        content: toolResults
+      });
+      this.truncateLastToolResults();
+      if (response.stopReason === "end_turn" && response.toolCalls.length === 0) {
+        break;
+      }
+    }
+    return {
+      text: finalText,
+      toolCalls,
+      iterations,
+      tokenUsage: { ...this.cumulativeTokenUsage }
+    };
+  }
   /**
    * Get all available tools
    */
@@ -2899,16 +3648,16 @@ var Agent = class {
   }
   /**
    * Run the agent with a user message (supports streaming)
-   * @param userMessage - The user's input message
-   * @param options - Optional configuration including abort signal
    */
-  async run(userMessage, options) {
-    const maxIterations = this.config.maxIterations ?? 200;
+  async run(userMessage) {
+    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.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const useStreaming = this.config.streaming ?? true;
-    const signal = options?.signal;
     const allTools = await this.getAllTools();
     const contextManagement = this.config.contextEditing && this.config.contextEditing.length > 0 ? { edits: this.config.contextEditing } : void 0;
     const contextMessage = `[Working directory: ${this.workingDirectory}]
@@ -2922,9 +3671,6 @@ ${userMessage}`;
     let iterations = 0;
     let finalText = "";
     while (iterations < maxIterations) {
-      if (signal?.aborted) {
-        throw new Error("Operation aborted by user");
-      }
       iterations++;
       this.config.onStreamStart?.();
       let response;
@@ -2949,12 +3695,8 @@ ${userMessage}`;
         if (contextManagement) {
           streamOptions.context_management = contextManagement;
         }
-        const stream = this.anthropic.messages.stream(streamOptions, { signal });
+        const stream = this.anthropic.messages.stream(streamOptions);
         for await (const event of stream) {
-          if (signal?.aborted) {
-            stream.controller.abort();
-            throw new Error("Operation aborted by user");
-          }
           if (event.type === "content_block_delta") {
             const delta = event.delta;
             if (delta.type === "text_delta" && delta.text) {
@@ -3019,11 +3761,7 @@ ${userMessage}`;
       }
       const toolResults = [];
       for (const toolUse of toolUses) {
-        if (signal?.aborted) {
-          throw new Error("Operation aborted by user");
-        }
         this.config.onToolCall?.(toolUse.name, toolUse.input);
-        await new Promise((resolve2) => setImmediate(resolve2));
         const { result, source } = await this.executeTool(
           toolUse.name,
           toolUse.input
@@ -3204,19 +3942,34 @@ ${userMessage}`;
    * Set the model to use for future requests
    */
   setModel(modelIdOrAlias) {
-    const resolvedId = resolveModelId(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";
+        }
+      }
+    }
     if (!resolvedId) {
-      const availableModels = Object.values(MODELS).map((m) => m.name).join(", ");
+      const anthropicModels = Object.values(MODELS).map((m) => m.name).join(", ");
+      const orModels = Object.values(OPENROUTER_MODELS).slice(0, 5).map((m) => m.name).join(", ");
       return {
         success: false,
-        error: `Unknown model: "${modelIdOrAlias}". Available: ${availableModels}`
+        error: `Unknown model: "${modelIdOrAlias}". Anthropic: ${anthropicModels}. OpenRouter: ${orModels}, ...`
       };
     }
     this.config.model = resolvedId;
-    const modelConfig = getModelConfig(resolvedId);
+    this.llmProvider = void 0;
     return {
       success: true,
-      model: modelConfig?.displayName ?? resolvedId
+      model: displayName ?? resolvedId
     };
   }
   /**
@@ -3342,7 +4095,7 @@ import { useState, useCallback, useRef, useEffect } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import TextInput from "ink-text-input";
 import Spinner from "ink-spinner";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 function formatTokenCount(count) {
   if (count < 1e3) return String(count);
   if (count < 1e5) return `${(count / 1e3).toFixed(1)}k`;
@@ -3357,7 +4110,8 @@ var SLASH_COMMANDS = [
   { cmd: "/help", desc: "Show available commands" },
   { cmd: "/clear", desc: "Clear conversation history" },
   { cmd: "/compact", desc: "Summarize conversation to save tokens" },
-  { cmd: "/model", desc: "Switch model (opus, sonnet, haiku)" },
+  { cmd: "/model", desc: "Switch model (opus, sonnet, haiku, minimax, etc.)" },
+  { cmd: "/provider", desc: "Switch LLM provider (anthropic, openrouter)" },
   { cmd: "/cost", desc: "Show session cost breakdown" },
   { cmd: "/tools", desc: "List available tools" },
   { cmd: "/config", desc: "Show configuration info" },
@@ -3423,7 +4177,8 @@ function App({ agent, onExit }) {
           content: `\u{1F4DA} Available Commands:
 /clear      - Clear conversation history
 /compact    - Summarize conversation (keeps context, saves tokens)
-/model      - Switch model (opus, sonnet, haiku) 
+/model      - Switch model (opus, sonnet, haiku, minimax, deepseek, etc.)
+/provider   - Switch LLM provider (anthropic, openrouter)
 /cost       - Show session cost breakdown
 /help       - Show this help message
 /tools      - List available tools
@@ -3576,30 +4331,46 @@ Use /stop <id> to stop a process.`
       case "model":
         if (!args) {
           const currentModel = agent.getModel();
+          const currentProvider = agent.getProvider();
           const modelConfig = getModelConfig(currentModel);
-          const models = listModels();
-          const modelList = models.map((m) => {
+          const orModelConfig = getOpenRouterModelConfig(currentModel);
+          const displayName = modelConfig?.displayName || orModelConfig?.displayName || currentModel;
+          const anthropicModels = listModels();
+          const anthropicList = anthropicModels.map((m) => {
             const isCurrent = m.id === currentModel ? " (current)" : "";
             return `  ${m.name}${isCurrent} - ${m.description}`;
           }).join("\n");
+          const orModels = listOpenRouterModels().slice(0, 8);
+          const orList = orModels.map((m) => {
+            const isCurrent = m.id === currentModel ? " (current)" : "";
+            return `  ${m.name}${isCurrent} - ${m.description.slice(0, 50)}...`;
+          }).join("\n");
           setMessages((prev) => [...prev, {
             role: "system",
-            content: `\u{1F916} Current model: ${modelConfig?.displayName || currentModel}
+            content: `\u{1F916} Current: ${displayName} (${currentProvider})
+
+Anthropic Models:
+${anthropicList}
 
-Available models:
-${modelList}
+OpenRouter Models (selection):
+${orList}
+  ... and many more! Use any OpenRouter model ID like 'minimax/minimax-m2.1'
 
-Usage: /model <name>  (e.g., /model haiku, /model opus)`
+Usage: /model <name>  (e.g., /model haiku, /model minimax)
+       Using an OpenRouter model auto-switches to OpenRouter provider.`
           }]);
           return true;
         }
         const result = agent.setModel(args);
         if (result.success) {
-          const newConfig = getModelConfig(agent.getModel());
+          const anthropicConfig = getModelConfig(agent.getModel());
+          const orConfig = getOpenRouterModelConfig(agent.getModel());
+          const description = anthropicConfig?.description || orConfig?.description || "";
+          const providerInfo = agent.isOpenRouter() ? " (OpenRouter)" : " (Anthropic)";
           setMessages((prev) => [...prev, {
             role: "system",
-            content: `\u2705 Switched to ${result.model}
-   ${newConfig?.description || ""}`
+            content: `\u2705 Switched to ${result.model}${providerInfo}
+   ${description}`
           }]);
         } else {
           setMessages((prev) => [...prev, {
@@ -3608,6 +4379,43 @@ Usage: /model <name>  (e.g., /model haiku, /model opus)`
           }]);
         }
         return true;
+      case "provider":
+        if (!args) {
+          const currentProvider = agent.getProvider();
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u{1F527} LLM Provider
+
+Current: ${currentProvider}
+
+Available providers:
+  anthropic   - Claude models (Opus, Sonnet, Haiku)
+  openrouter  - Multi-provider access (MiniMax, DeepSeek, Gemini, etc.)
+
+Usage: /provider <name>  (e.g., /provider openrouter)
+
+Note: When switching to OpenRouter, make sure OPENROUTER_API_KEY is set.
+      You can also just use /model with an OpenRouter model name.`
+          }]);
+          return true;
+        }
+        const providerArg = args.toLowerCase();
+        if (providerArg !== "anthropic" && providerArg !== "openrouter") {
+          setMessages((prev) => [...prev, {
+            role: "system",
+            content: `\u274C Unknown provider: "${args}". Use: anthropic, openrouter`
+          }]);
+          return true;
+        }
+        agent.setProvider(providerArg);
+        const providerModels = providerArg === "openrouter" ? "minimax, deepseek, gemini, grok, devstral" : "opus, sonnet, haiku";
+        setMessages((prev) => [...prev, {
+          role: "system",
+          content: `\u2705 Switched to ${providerArg} provider
+   Available models: ${providerModels}
+   Use /model to select a model.`
+        }]);
+        return true;
       case "cost":
         const usage = agent.getTokenUsage();
         const sessionCost = agent.getSessionCost();
@@ -3680,7 +4488,7 @@ Last API Call Cost:
     completedToolCalls.current = [];
     abortController.current = new AbortController();
     try {
-      const result = await agent.run(trimmed, { signal: abortController.current?.signal });
+      const result = await agent.run(trimmed);
       if (isInterrupted) {
         setMessages((prev) => [...prev, {
           role: "system",
@@ -3819,22 +4627,18 @@ Stopped ${count} background process${count > 1 ? "es" : ""}.`);
       msg.role === "system" && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "gray", italic: true, children: msg.content }) })
     ] }, i)) }),
     currentToolCalls.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, marginLeft: 2, children: currentToolCalls.map((tc, i) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Box, { children: tc.pending ? /* @__PURE__ */ jsxs(Fragment, { children: [
-        /* @__PURE__ */ jsx(Text, { color: "yellow", children: /* @__PURE__ */ jsx(Spinner, { type: "dots" }) }),
-        /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        tc.pending ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+          /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
           " ",
           tc.name
-        ] }),
-        /* @__PURE__ */ jsx(Text, { color: "gray", children: formatArgs(tc.args) }),
-        /* @__PURE__ */ jsx(Text, { color: "yellow", dimColor: true, children: " Running..." })
-      ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-        /* @__PURE__ */ jsxs(Text, { color: tc.success ? "green" : "red", children: [
+        ] }) : /* @__PURE__ */ jsxs(Text, { color: tc.success ? "blue" : "red", children: [
           tc.success ? "\u2713" : "\u2717",
           " ",
           tc.name
         ] }),
         /* @__PURE__ */ jsx(Text, { color: "gray", children: formatArgs(tc.args) })
-      ] }) }),
+      ] }),
       !tc.pending && tc.result && /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
         "\u2192 ",
         formatResult(tc.result, 100)
@@ -3936,19 +4740,8 @@ program.name("quantish").description("AI coding & trading agent for Polymarket")
 program.command("init").description("Configure Quantish CLI with your API keys").action(async () => {
   await runSetup();
 });
-program.command("config").description("View or edit configuration").option("-s, --show", "Show current configuration").option("-c, --clear", "Clear all configuration").option("--path", "Show config file path").option("--export", "Export configuration as .env format").option("--show-keys", "Show full API keys (use with caution)").option("--server <url>", "Set custom Trading MCP server URL").action(async (options) => {
+program.command("config").description("View or edit configuration").option("-s, --show", "Show current configuration").option("-c, --clear", "Clear all configuration").option("--path", "Show config file path").option("--export", "Export configuration as .env format").option("--show-keys", "Show full API keys (use with caution)").action(async (options) => {
   const config = getConfigManager();
-  if (options.server) {
-    try {
-      new URL(options.server);
-    } catch {
-      error("Invalid URL format. Please provide a valid URL (e.g., https://your-server.com/mcp)");
-      return;
-    }
-    config.set("mcpServerUrl", options.server);
-    success(`Trading MCP server URL set to: ${options.server}`);
-    return;
-  }
   if (options.path) {
     console.log(config.getConfigPath());
     return;
@@ -3967,11 +4760,15 @@ program.command("config").description("View or edit configuration").option("-s,
     if (all2.anthropicApiKey) {
       console.log(`ANTHROPIC_API_KEY=${all2.anthropicApiKey}`);
     }
+    if (all2.openrouterApiKey) {
+      console.log(`OPENROUTER_API_KEY=${all2.openrouterApiKey}`);
+    }
     if (all2.quantishApiKey) {
       console.log(`QUANTISH_API_KEY=${all2.quantishApiKey}`);
     }
     console.log(`QUANTISH_MCP_URL=${all2.mcpServerUrl}`);
     console.log(`QUANTISH_MODEL=${all2.model || "claude-sonnet-4-5-20250929"}`);
+    console.log(`QUANTISH_PROVIDER=${all2.provider || "anthropic"}`);
     console.log();
     console.log(chalk3.dim("# Discovery MCP (public, read-only market data)"));
     console.log(`QUANTISH_DISCOVERY_URL=https://quantish.live/mcp`);
@@ -3986,11 +4783,14 @@ program.command("config").description("View or edit configuration").option("-s,
   printDivider();
   if (options.showKeys) {
     tableRow("Anthropic API Key", all.anthropicApiKey || chalk3.dim("Not set"));
+    tableRow("OpenRouter API Key", all.openrouterApiKey || chalk3.dim("Not set"));
     tableRow("Quantish API Key", all.quantishApiKey || chalk3.dim("Not set"));
   } else {
     tableRow("Anthropic API Key", all.anthropicApiKey ? `${all.anthropicApiKey.slice(0, 10)}...` : chalk3.dim("Not set"));
+    tableRow("OpenRouter API Key", all.openrouterApiKey ? `${all.openrouterApiKey.slice(0, 10)}...` : chalk3.dim("Not set"));
     tableRow("Quantish API Key", all.quantishApiKey ? `${all.quantishApiKey.slice(0, 12)}...` : chalk3.dim("Not set"));
   }
+  tableRow("Provider", all.provider || "anthropic");
   tableRow("MCP Server URL", all.mcpServerUrl);
   tableRow("Model", all.model || "claude-sonnet-4-5-20250929");
   printDivider();
@@ -4123,7 +4923,9 @@ async function runInteractiveChat(options = {}) {
   const config = getConfigManager();
   const mcpClientManager = createMCPManager(options);
   const agent = createAgent({
+    provider: config.getProvider(),
     anthropicApiKey: config.getAnthropicApiKey(),
+    openrouterApiKey: config.getOpenRouterApiKey(),
     mcpClientManager,
     model: config.getModel(),
     enableLocalTools: options.enableLocal !== false,
@@ -4256,7 +5058,9 @@ async function runOneShotPrompt(message, options = {}) {
   const config = getConfigManager();
   const mcpClientManager = createMCPManager(options);
   const agent = createAgent({
+    provider: config.getProvider(),
     anthropicApiKey: config.getAnthropicApiKey(),
+    openrouterApiKey: config.getOpenRouterApiKey(),
     mcpClientManager,
     model: config.getModel(),
     enableLocalTools: options.enableLocal !== false,