codelantern-agent-cli 1.0.0 → 1.0.1

package/dist/{chunk-Y3PEOLTZ.js → chunk-PELESOCI.js}

@@ -2,204 +2,1657 @@
 
 // src/provider/errors.ts
 import pc from "picocolors";
+var TimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs, operation = "Request") {
+    super(`${operation} timed out after ${(timeoutMs / 1e3).toFixed(1)}s.`);
+    this.name = "TimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var FirstTokenTimeoutError = class extends Error {
+  timeoutMs;
+  provider;
+  model;
+  constructor(timeoutMs, provider, model) {
+    super(`No response tokens received from ${provider} (${model}) after ${(timeoutMs / 1e3).toFixed(1)}s.`);
+    this.name = "FirstTokenTimeoutError";
+    this.timeoutMs = timeoutMs;
+    this.provider = provider;
+    this.model = model;
+  }
+};
+var CancelledError = class extends Error {
+  constructor(message = "Operation cancelled by user (Ctrl+C).") {
+    super(message);
+    this.name = "CancelledError";
+  }
+};
 var MissingApiKeyError = class extends Error {
-  constructor() {
+  provider;
+  constructor(provider = "gemini", envVar = "GEMINI_API_KEY") {
     super(
-      `GEMINI_API_KEY environment variable is not configured.
+      `API key for provider '${provider}' is not configured.
 
 To resolve this:
-  1. Get a Gemini API key from https://aistudio.google.com/app/apikey
-  2. Set the environment variable in your terminal or shell profile:
-     export GEMINI_API_KEY="your-api-key-here"
-  3. Or run Code Lantern with the key prefixed:
-     GEMINI_API_KEY="your-key" lantern
+  1. Set the environment variable:
+     export ${envVar}="your-api-key-here"
+  2. Or store it securely using Lantern:
+     lantern keys set ${provider}
 `
     );
     this.name = "MissingApiKeyError";
+    this.provider = provider;
   }
 };
 var RateLimitError = class extends Error {
-  constructor(message = "Gemini API rate limit exceeded.") {
+  constructor(message = "API rate limit exceeded.") {
     super(`${message}
-Please wait a moment before trying again or check your API quota at https://aistudio.google.com/`);
+Please wait a moment before trying again or check your account quota.`);
     this.name = "RateLimitError";
   }
 };
-var GeminiProviderError = class extends Error {
+var AuthenticationError = class extends Error {
+  constructor(message = "Authentication failed.") {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var ModelNotFoundError = class extends Error {
+  constructor(model, provider) {
+    super(`Model '${model}' not found or not available for provider '${provider}'.`);
+    this.name = "ModelNotFoundError";
+  }
+};
+var LanternProviderError = class extends Error {
   statusCode;
-  constructor(message, statusCode) {
+  provider;
+  constructor(message, statusCode, provider) {
     super(message);
-    this.name = "GeminiProviderError";
+    this.name = "LanternProviderError";
     this.statusCode = statusCode;
+    this.provider = provider;
   }
 };
 function formatErrorMessage(err) {
+  if (err instanceof CancelledError) {
+    return pc.yellow(`
+[Cancelled] ${err.message}`);
+  }
+  if (err instanceof FirstTokenTimeoutError) {
+    return pc.red(`
+\u23F1\uFE0F ${err.message}
+` + pc.yellow(`  Tip: Check your network connection or try lowering temperature or setting a faster model with 'lantern model set <id>'.`));
+  }
+  if (err instanceof TimeoutError) {
+    return pc.red(`
+\u23F1\uFE0F ${err.message}
+` + pc.yellow(`  Tip: You can increase the timeout limit using 'lantern config set timeoutMs 120000'.`));
+  }
   if (err instanceof MissingApiKeyError) {
-    return pc.red(err.message);
+    return pc.red(`
+${err.message}`);
+  }
+  if (err instanceof RateLimitError) {
+    return pc.yellow(`
+\u26A0\uFE0F ${err.message}`);
+  }
+  if (err instanceof AuthenticationError) {
+    return pc.red(`
+\u{1F512} ${err.message}`);
+  }
+  if (err instanceof ModelNotFoundError) {
+    return pc.red(`
+\u{1F50D} ${err.message}
+` + pc.dim(`Run 'lantern models list' to view available models for your account.`));
+  }
+  if (err instanceof Error) {
+    const msg = err.message || "";
+    if (msg.includes("API_KEY_INVALID") || msg.includes("401") || msg.includes("Incorrect API key")) {
+      return pc.red(`Authentication failed: Invalid API key. Update it with 'lantern keys set <provider>'.`);
+    }
+    if (msg.includes("RESOURCE_EXHAUSTED") || msg.includes("429")) {
+      return pc.yellow("Rate limit or quota reached. Please wait a few seconds before retrying.");
+    }
+    if (msg.includes("AbortError") || msg.includes("aborted") || msg.includes("canceled")) {
+      return pc.yellow("[Request aborted]");
+    }
+    return pc.red(`Error: ${msg}`);
+  }
+  return pc.red(`An unexpected error occurred: ${String(err)}`);
+}
+
+// src/provider/timeout.ts
+function createLinkedAbortController(parentSignal, timeoutMs) {
+  const controller = new AbortController();
+  let timer = null;
+  if (timeoutMs && timeoutMs > 0) {
+    timer = setTimeout(() => {
+      controller.abort(new TimeoutError(timeoutMs));
+    }, timeoutMs);
+  }
+  const onParentAbort = () => {
+    controller.abort(parentSignal?.reason || new CancelledError());
+  };
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      onParentAbort();
+    } else {
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    }
+  }
+  const cleanup = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (parentSignal) {
+      parentSignal.removeEventListener("abort", onParentAbort);
+    }
+  };
+  return { controller, cleanup };
+}
+async function* wrapStreamWithFirstTokenTimeout(stream, firstTokenTimeoutMs, provider, model, signal, onFirstToken) {
+  let firstTokenReceived = false;
+  const startTime = Date.now();
+  let timer = null;
+  let timedOut = false;
+  const timerPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      if (!firstTokenReceived) {
+        timedOut = true;
+        reject(new FirstTokenTimeoutError(firstTokenTimeoutMs, provider, model));
+      }
+    }, firstTokenTimeoutMs);
+  });
+  const abortPromise = new Promise((_, reject) => {
+    if (signal) {
+      if (signal.aborted) {
+        reject(signal.reason || new CancelledError());
+      } else {
+        signal.addEventListener("abort", () => reject(signal.reason || new CancelledError()), { once: true });
+      }
+    }
+  });
+  const iterator = stream[Symbol.asyncIterator]();
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw signal.reason || new CancelledError();
+      }
+      if (!firstTokenReceived) {
+        const nextPromise = iterator.next();
+        const result = await Promise.race([nextPromise, timerPromise, abortPromise]);
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        if (result.done) {
+          break;
+        }
+        firstTokenReceived = true;
+        if (onFirstToken) {
+          onFirstToken(Date.now() - startTime);
+        }
+        yield result.value;
+      } else {
+        if (signal?.aborted) {
+          throw signal.reason || new CancelledError();
+        }
+        const nextPromise = iterator.next();
+        const result = signal ? await Promise.race([nextPromise, abortPromise]) : await nextPromise;
+        if (result.done) {
+          break;
+        }
+        yield result.value;
+      }
+    }
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    if (typeof iterator.return === "function") {
+      try {
+        await iterator.return();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/config/schema.ts
+var DEFAULT_CONFIG = {
+  activeProvider: "gemini",
+  defaultModel: "gemini-3.8-flash",
+  maxSteps: 25,
+  temperature: 0.2,
+  maxOutputTokens: 8192,
+  yolo: false,
+  theme: "default",
+  autoCompactThreshold: 30,
+  // turns before auto-compacting
+  timeoutMs: 6e4,
+  firstTokenTimeoutMs: 3e4,
+  showTiming: false,
+  lowLatency: false,
+  activeSkills: [],
+  mcpServers: {},
+  providers: {}
+};
+var ALLOWED_CONFIG_KEYS = [
+  "activeProvider",
+  "defaultModel",
+  "maxSteps",
+  "temperature",
+  "maxOutputTokens",
+  "yolo",
+  "theme",
+  "autoCompactThreshold",
+  "timeoutMs",
+  "firstTokenTimeoutMs",
+  "showTiming",
+  "lowLatency",
+  "activeSkills"
+];
+function validateConfigValue(key, value) {
+  switch (key) {
+    case "activeProvider":
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return { valid: false, error: "activeProvider must be a non-empty string" };
+      }
+      return { valid: true, parsedValue: value.trim().toLowerCase() };
+    case "defaultModel":
+      if (typeof value !== "string" || value.trim().length === 0) {
+        return { valid: false, error: "defaultModel must be a non-empty string" };
+      }
+      return { valid: true, parsedValue: value.trim() };
+    case "maxSteps": {
+      const num = Number(value);
+      if (isNaN(num) || num < 1 || num > 100) {
+        return { valid: false, error: "maxSteps must be a number between 1 and 100" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "temperature": {
+      const num = Number(value);
+      if (isNaN(num) || num < 0 || num > 2) {
+        return { valid: false, error: "temperature must be a number between 0.0 and 2.0" };
+      }
+      return { valid: true, parsedValue: num };
+    }
+    case "maxOutputTokens": {
+      const num = Number(value);
+      if (isNaN(num) || num < 256 || num > 65536) {
+        return { valid: false, error: "maxOutputTokens must be between 256 and 65536" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "yolo": {
+      if (typeof value === "boolean") return { valid: true, parsedValue: value };
+      if (value === "true" || value === "1") return { valid: true, parsedValue: true };
+      if (value === "false" || value === "0") return { valid: true, parsedValue: false };
+      return { valid: false, error: "yolo must be a boolean (true/false)" };
+    }
+    case "theme": {
+      if (value === "default" || value === "ocean" || value === "minimal") {
+        return { valid: true, parsedValue: value };
+      }
+      return { valid: false, error: "theme must be 'default', 'ocean', or 'minimal'" };
+    }
+    case "autoCompactThreshold": {
+      const num = Number(value);
+      if (isNaN(num) || num < 5 || num > 200) {
+        return { valid: false, error: "autoCompactThreshold must be a number between 5 and 200" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "timeoutMs": {
+      const num = Number(value);
+      if (isNaN(num) || num < 5e3) {
+        return { valid: false, error: "timeoutMs must be at least 5000 (ms)" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "firstTokenTimeoutMs": {
+      const num = Number(value);
+      if (isNaN(num) || num < 3e3) {
+        return { valid: false, error: "firstTokenTimeoutMs must be at least 3000 (ms)" };
+      }
+      return { valid: true, parsedValue: Math.round(num) };
+    }
+    case "showTiming": {
+      if (typeof value === "boolean") return { valid: true, parsedValue: value };
+      if (value === "true" || value === "1") return { valid: true, parsedValue: true };
+      if (value === "false" || value === "0") return { valid: true, parsedValue: false };
+      return { valid: false, error: "showTiming must be a boolean (true/false)" };
+    }
+    case "lowLatency": {
+      if (typeof value === "boolean") return { valid: true, parsedValue: value };
+      if (value === "true" || value === "1") return { valid: true, parsedValue: true };
+      if (value === "false" || value === "0") return { valid: true, parsedValue: false };
+      return { valid: false, error: "lowLatency must be a boolean (true/false)" };
+    }
+    case "activeSkills": {
+      if (Array.isArray(value)) {
+        return { valid: true, parsedValue: value.map(String) };
+      }
+      if (typeof value === "string") {
+        return { valid: true, parsedValue: value.split(",").map((s) => s.trim()).filter(Boolean) };
+      }
+      return { valid: false, error: "activeSkills must be an array of strings or comma-separated string" };
+    }
+    default:
+      return { valid: false, error: `Unknown configuration key: ${key}` };
+  }
+}
+
+// src/config/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getLanternHomeDir() {
+  const customHome = process.env.CODELANTERN_HOME || process.env.LANTERN_HOME;
+  if (customHome) {
+    if (!fs.existsSync(customHome)) {
+      try {
+        fs.mkdirSync(customHome, { recursive: true });
+      } catch {
+      }
+    }
+    return customHome;
+  }
+  const defaultDir = path.join(os.homedir(), ".codelantern");
+  if (!fs.existsSync(defaultDir)) {
+    try {
+      fs.mkdirSync(defaultDir, { recursive: true });
+    } catch {
+    }
+  }
+  return defaultDir;
+}
+function getConfigFilePath() {
+  return path.join(getLanternHomeDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigFilePath();
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const merged = {
+      ...DEFAULT_CONFIG,
+      ...parsed
+    };
+    if (!merged.mcpServers || typeof merged.mcpServers !== "object") {
+      merged.mcpServers = {};
+    }
+    return merged;
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  const configPath = getConfigFilePath();
+  const safeConfig = {
+    activeProvider: config.activeProvider || DEFAULT_CONFIG.activeProvider,
+    defaultModel: config.defaultModel || DEFAULT_CONFIG.defaultModel,
+    maxSteps: config.maxSteps || DEFAULT_CONFIG.maxSteps,
+    temperature: config.temperature ?? DEFAULT_CONFIG.temperature,
+    maxOutputTokens: config.maxOutputTokens || DEFAULT_CONFIG.maxOutputTokens,
+    yolo: Boolean(config.yolo),
+    theme: config.theme || DEFAULT_CONFIG.theme,
+    autoCompactThreshold: config.autoCompactThreshold || DEFAULT_CONFIG.autoCompactThreshold,
+    timeoutMs: config.timeoutMs || DEFAULT_CONFIG.timeoutMs,
+    firstTokenTimeoutMs: config.firstTokenTimeoutMs || DEFAULT_CONFIG.firstTokenTimeoutMs,
+    showTiming: Boolean(config.showTiming),
+    lowLatency: Boolean(config.lowLatency),
+    activeSkills: Array.isArray(config.activeSkills) ? config.activeSkills : [],
+    mcpServers: config.mcpServers || {},
+    providers: config.providers || {}
+  };
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(safeConfig, null, 2), {
+      encoding: "utf8"
+    });
+  } catch (err) {
+    console.error(`Warning: Failed to save config to ${configPath}: ${err.message}`);
+  }
+}
+function setConfigValue(key, value) {
+  const validation = validateConfigValue(key, value);
+  if (!validation.valid) {
+    return { success: false, error: validation.error };
+  }
+  const current = loadConfig();
+  current[key] = validation.parsedValue;
+  saveConfig(current);
+  return { success: true, updatedConfig: current };
+}
+function getConfigValue(key) {
+  const current = loadConfig();
+  return current[key];
+}
+
+// src/security/credentials.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+import crypto from "crypto";
+var PROVIDER_ENV_VARS = {
+  gemini: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  anthropic: ["ANTHROPIC_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  custom: ["CUSTOM_API_KEY", "OPENAI_API_KEY"]
+};
+function getCredentialsFilePath() {
+  return path2.join(getLanternHomeDir(), "credentials.json");
+}
+function getMachineDerivedKey() {
+  const salt = `codelantern_${os2.hostname()}_${os2.userInfo().username}`;
+  const secret = `${os2.homedir()}_${process.platform}_${os2.arch()}`;
+  return crypto.scryptSync(secret, salt, 32);
+}
+function encryptSecret(plainText) {
+  const iv = crypto.randomBytes(12);
+  const key = getMachineDerivedKey();
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  let encrypted = cipher.update(plainText, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag().toString("hex");
+  return `${iv.toString("hex")}:${authTag}:${encrypted}`;
+}
+function decryptSecret(encryptedPayload) {
+  try {
+    const parts = encryptedPayload.split(":");
+    if (parts.length !== 3) return null;
+    const [ivHex, authTagHex, encryptedHex] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const key = getMachineDerivedKey();
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encryptedHex, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch {
+    return null;
+  }
+}
+function maskApiKey(key) {
+  if (!key) return "(not configured)";
+  const clean = key.trim();
+  if (clean.length <= 8) return "********";
+  return `${clean.slice(0, 4)}...${clean.slice(-4)}`;
+}
+function getApiKey(provider) {
+  const norm = provider.toLowerCase();
+  const envVarNames = PROVIDER_ENV_VARS[norm] || [`${norm.toUpperCase()}_API_KEY`];
+  for (const envVar of envVarNames) {
+    const val = process.env[envVar];
+    if (val && val.trim().length > 0) {
+      return { key: val.trim(), source: "env" };
+    }
+  }
+  const filePath = getCredentialsFilePath();
+  if (fs2.existsSync(filePath)) {
+    try {
+      const raw = fs2.readFileSync(filePath, "utf8");
+      const data = JSON.parse(raw);
+      if (data[norm]) {
+        const decrypted = decryptSecret(data[norm]);
+        if (decrypted) {
+          return { key: decrypted, source: "store" };
+        }
+      }
+    } catch {
+    }
+  }
+  return { key: null };
+}
+function setApiKey(provider, apiKey) {
+  const norm = provider.toLowerCase();
+  const filePath = getCredentialsFilePath();
+  let data = {};
+  if (fs2.existsSync(filePath)) {
+    try {
+      const raw = fs2.readFileSync(filePath, "utf8");
+      data = JSON.parse(raw);
+    } catch {
+      data = {};
+    }
+  }
+  data[norm] = encryptSecret(apiKey.trim());
+  try {
+    fs2.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+      encoding: "utf8",
+      mode: 384
+    });
+  } catch (err) {
+    console.error(`Warning: Failed to save credentials: ${err.message}`);
+  }
+}
+function removeApiKey(provider) {
+  const norm = provider.toLowerCase();
+  const filePath = getCredentialsFilePath();
+  if (!fs2.existsSync(filePath)) return false;
+  try {
+    const raw = fs2.readFileSync(filePath, "utf8");
+    const data = JSON.parse(raw);
+    if (data[norm]) {
+      delete data[norm];
+      fs2.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+        encoding: "utf8",
+        mode: 384
+      });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function listConfiguredKeys() {
+  const providers = ["gemini", "openai", "anthropic", "openrouter", "custom"];
+  const result = {};
+  for (const p of providers) {
+    const { key, source } = getApiKey(p);
+    result[p] = {
+      configured: Boolean(key),
+      source,
+      maskedKey: key ? maskApiKey(key) : "(not configured)"
+    };
+  }
+  return result;
+}
+
+// src/provider/gemini.ts
+import { GoogleGenAI, Type } from "@google/genai";
+var GeminiProvider = class {
+  id = "gemini";
+  name = "gemini";
+  displayName = "Google Gemini";
+  defaultModel = "gemini-3.8-flash";
+  cachedModels = null;
+  isConfigured() {
+    const { key } = getApiKey(this.id);
+    return Boolean(key && key.trim().length > 0);
+  }
+  getApiKey() {
+    return getApiKey(this.id).key;
+  }
+  getMaskedKey() {
+    const key = this.getApiKey();
+    return key ? maskApiKey(key) : "(not configured)";
+  }
+  getClient() {
+    const key = this.getApiKey();
+    if (!key) {
+      throw new MissingApiKeyError("gemini", "GEMINI_API_KEY");
+    }
+    return new GoogleGenAI({ apiKey: key });
+  }
+  getCapabilities(modelId) {
+    const isPro = modelId.includes("pro");
+    const isThinking = modelId.includes("thinking") || modelId.includes("2.0-flash-thinking");
+    return {
+      streaming: true,
+      tools: true,
+      images: true,
+      reasoning: isThinking || isPro,
+      contextWindow: isPro ? 2e6 : 1e6
+    };
+  }
+  async testConnection() {
+    const startTime = Date.now();
+    try {
+      const client = this.getClient();
+      const testModel = this.defaultModel;
+      await client.models.countTokens({
+        model: testModel,
+        contents: "test"
+      });
+      return {
+        success: true,
+        latencyMs: Date.now() - startTime,
+        resolvedModel: testModel
+      };
+    } catch (err) {
+      return {
+        success: false,
+        latencyMs: Date.now() - startTime,
+        error: err.message || String(err)
+      };
+    }
+  }
+  async listModels(refresh = false) {
+    if (!refresh && this.cachedModels && this.cachedModels.length > 0) {
+      return this.cachedModels;
+    }
+    try {
+      const client = this.getClient();
+      const pagedList = await client.models.list();
+      const models = [];
+      for await (const m of pagedList) {
+        const rawName = m.name || "";
+        const modelId = rawName.startsWith("models/") ? rawName.slice(7) : rawName;
+        if (!modelId.includes("gemini")) {
+          continue;
+        }
+        const capabilities = this.getCapabilities(modelId);
+        models.push({
+          id: modelId,
+          name: m.displayName || modelId,
+          provider: this.id,
+          description: m.description,
+          contextWindow: capabilities.contextWindow,
+          capabilities
+        });
+      }
+      if (models.length > 0) {
+        this.cachedModels = models;
+        return models;
+      }
+    } catch {
+    }
+    const verifiedModels = [
+      "gemini-3.8-flash",
+      "gemini-2.5-flash",
+      "gemini-2.5-pro",
+      "gemini-2.0-flash",
+      "gemini-2.0-flash-lite",
+      "gemini-1.5-flash",
+      "gemini-1.5-pro"
+    ];
+    return verifiedModels.map((id) => ({
+      id,
+      name: id,
+      provider: this.id,
+      capabilities: this.getCapabilities(id),
+      contextWindow: id.includes("pro") ? 2e6 : 1e6
+    }));
+  }
+  async streamGenerate(params) {
+    const overallStartTime = Date.now();
+    const timing = {
+      totalMs: 0,
+      toolExecutionMs: {}
+    };
+    const client = this.getClient();
+    const contents = this.convertHistoryToContents(params.history);
+    const functionDeclarations = this.convertToolsToDeclarations(params.tools);
+    const config = {
+      systemInstruction: params.systemInstruction,
+      temperature: params.temperature ?? (params.lowLatency ? 0.1 : 0.2)
+    };
+    if (params.maxOutputTokens) {
+      config.maxOutputTokens = params.maxOutputTokens;
+    }
+    const toolList = [];
+    if (functionDeclarations.length > 0) {
+      toolList.push({ functionDeclarations });
+    }
+    if (params.enableSearchGrounding) {
+      toolList.push({ googleSearch: {} });
+    }
+    if (toolList.length > 0) {
+      config.tools = toolList;
+    }
+    const timeoutMs = params.timeoutMs || 6e4;
+    const firstTokenTimeoutMs = params.firstTokenTimeoutMs || 3e4;
+    let attempts = 0;
+    const maxAttempts = 3;
+    let lastError = null;
+    while (attempts < maxAttempts) {
+      attempts++;
+      const connectStart = Date.now();
+      if (params.callbacks.onStateChange) {
+        params.callbacks.onStateChange(attempts > 1 ? `retrying:${attempts}` : "connecting");
+      }
+      const { controller, cleanup } = createLinkedAbortController(params.signal, timeoutMs);
+      try {
+        const responseStream = await client.models.generateContentStream({
+          model: params.model,
+          contents,
+          config
+        });
+        timing.connectMs = Date.now() - connectStart;
+        if (params.callbacks.onStateChange) {
+          params.callbacks.onStateChange("waiting_first_token");
+        }
+        let fullText = "";
+        const collectedToolCalls = [];
+        const usage = {
+          promptTokens: 0,
+          candidatesTokens: 0,
+          totalTokens: 0
+        };
+        const wrappedStream = wrapStreamWithFirstTokenTimeout(
+          responseStream,
+          firstTokenTimeoutMs,
+          this.displayName,
+          params.model,
+          controller.signal,
+          (latencyMs) => {
+            timing.ttftMs = latencyMs;
+            if (params.callbacks.onStateChange) {
+              params.callbacks.onStateChange("streaming");
+            }
+          }
+        );
+        const streamStart = Date.now();
+        for await (const chunk of wrappedStream) {
+          if (chunk.text) {
+            fullText += chunk.text;
+            if (params.callbacks.onChunk) {
+              params.callbacks.onChunk(chunk.text);
+            }
+          }
+          if (chunk.functionCalls && chunk.functionCalls.length > 0) {
+            for (const fc of chunk.functionCalls) {
+              collectedToolCalls.push({
+                id: fc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+                name: fc.name || "",
+                args: fc.args || {}
+              });
+            }
+          }
+          if (chunk.usageMetadata) {
+            usage.promptTokens = chunk.usageMetadata.promptTokenCount ?? usage.promptTokens;
+            usage.candidatesTokens = chunk.usageMetadata.candidatesTokenCount ?? usage.candidatesTokens;
+            usage.totalTokens = chunk.usageMetadata.totalTokenCount ?? usage.totalTokens;
+            if (params.callbacks.onUsage) {
+              params.callbacks.onUsage(usage);
+            }
+          }
+        }
+        timing.streamMs = Date.now() - streamStart;
+        timing.totalMs = Date.now() - overallStartTime;
+        if (params.callbacks.onToolCalls && collectedToolCalls.length > 0) {
+          params.callbacks.onToolCalls(collectedToolCalls);
+        }
+        cleanup();
+        return {
+          text: fullText,
+          toolCalls: collectedToolCalls,
+          usage,
+          timing
+        };
+      } catch (err) {
+        cleanup();
+        lastError = err;
+        if (params.signal?.aborted) {
+          throw err;
+        }
+        const msg = String(err?.message || err);
+        if (msg.includes("API_KEY_INVALID") || msg.includes("401") || msg.includes("403")) {
+          throw new LanternProviderError(`Authentication failed: ${msg}`, 401, this.id);
+        }
+        if (msg.includes("NOT_FOUND") || msg.includes("models/")) {
+          throw new ModelNotFoundError(params.model, this.displayName);
+        }
+        const isRateLimit = msg.includes("429") || msg.includes("RESOURCE_EXHAUSTED");
+        const isTransient = msg.includes("503") || msg.includes("overloaded") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT") || msg.includes("socket hang up");
+        if ((isRateLimit || isTransient) && attempts < maxAttempts) {
+          const backoff = Math.min(1e3 * Math.pow(1.5, attempts), 3e3);
+          if (params.callbacks.onStateChange) {
+            params.callbacks.onStateChange(`retrying:${attempts}`);
+          }
+          await new Promise((r) => setTimeout(r, backoff));
+          continue;
+        }
+        if (isRateLimit) {
+          throw new RateLimitError(msg);
+        }
+        throw new LanternProviderError(`Gemini request failed: ${msg}`, void 0, this.id);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  convertHistoryToContents(turns) {
+    const contents = [];
+    for (const turn of turns) {
+      const parts = [];
+      if (turn.role === "user") {
+        if (turn.text) {
+          parts.push({ text: turn.text });
+        }
+        if (turn.attachments && turn.attachments.length > 0) {
+          for (const att of turn.attachments) {
+            if (att.base64Data && att.mimeType) {
+              parts.push({
+                inlineData: {
+                  mimeType: att.mimeType,
+                  data: att.base64Data
+                }
+              });
+            } else if (att.textContent) {
+              parts.push({
+                text: `[Attached File: ${att.name}]
+\`\`\`
+${att.textContent}
+\`\`\``
+              });
+            }
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "user", parts });
+        }
+      } else if (turn.role === "model") {
+        if (turn.text) {
+          parts.push({ text: turn.text });
+        }
+        if (turn.toolCalls && turn.toolCalls.length > 0) {
+          for (const tc of turn.toolCalls) {
+            parts.push({
+              functionCall: {
+                id: tc.id,
+                name: tc.name,
+                args: tc.args
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "model", parts });
+        }
+      } else if (turn.role === "tool") {
+        if (turn.toolResults && turn.toolResults.length > 0) {
+          for (const res of turn.toolResults) {
+            parts.push({
+              functionResponse: {
+                id: res.callId,
+                name: res.name,
+                response: {
+                  result: res.error ? { error: res.error } : res.result
+                }
+              }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "tool", parts });
+        }
+      }
+    }
+    return contents;
+  }
+  convertToolsToDeclarations(tools) {
+    return tools.map((tool) => {
+      const properties = {};
+      for (const [propName, propDef] of Object.entries(tool.parameters.properties)) {
+        let typeVal = Type.STRING;
+        switch (propDef.type) {
+          case "number":
+          case "integer":
+            typeVal = Type.NUMBER;
+            break;
+          case "boolean":
+            typeVal = Type.BOOLEAN;
+            break;
+          case "array":
+            typeVal = Type.ARRAY;
+            break;
+          case "object":
+            typeVal = Type.OBJECT;
+            break;
+          default:
+            typeVal = Type.STRING;
+        }
+        properties[propName] = {
+          type: typeVal,
+          description: propDef.description,
+          ...propDef.enum ? { enum: propDef.enum } : {},
+          ...propDef.items ? { items: { type: Type.STRING } } : {}
+        };
+      }
+      return {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: Type.OBJECT,
+          properties,
+          required: tool.parameters.required || []
+        }
+      };
+    });
+  }
+};
+
+// src/provider/openaiProvider.ts
+var OpenAIProvider = class {
+  id;
+  name;
+  displayName;
+  defaultModel;
+  baseUrl;
+  customHeaders;
+  cachedModels = null;
+  constructor(options) {
+    this.id = options?.id || "openai";
+    this.name = options?.name || "openai";
+    this.displayName = options?.displayName || "OpenAI";
+    this.baseUrl = (options?.baseUrl || "https://api.openai.com/v1").replace(/\/+$/, "");
+    this.defaultModel = options?.defaultModel || "gpt-4o";
+    this.customHeaders = options?.headers || {};
+  }
+  isConfigured() {
+    const { key } = getApiKey(this.id);
+    return Boolean(key && key.trim().length > 0);
+  }
+  getApiKey() {
+    return getApiKey(this.id).key;
+  }
+  getMaskedKey() {
+    const key = this.getApiKey();
+    return key ? maskApiKey(key) : "(not configured)";
+  }
+  getCapabilities(modelId) {
+    const lower = modelId.toLowerCase();
+    const isReasoning = lower.includes("o1") || lower.includes("o3") || lower.includes("r1");
+    const isMini = lower.includes("mini") || lower.includes("nano");
+    return {
+      streaming: true,
+      tools: !isReasoning || lower.includes("o3-mini") || lower.includes("o1-mini"),
+      images: !isMini && !lower.includes("embedding"),
+      reasoning: isReasoning,
+      contextWindow: lower.includes("gpt-4o") ? 128e3 : 64e3
+    };
+  }
+  async testConnection() {
+    const key = this.getApiKey();
+    if (!key) {
+      return { success: false, latencyMs: 0, error: `Missing API key for ${this.displayName}` };
+    }
+    const startTime = Date.now();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1e4);
+      const res = await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${key}`,
+          ...this.customHeaders
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        const text = await res.text();
+        return {
+          success: false,
+          latencyMs: Date.now() - startTime,
+          error: `HTTP ${res.status}: ${text.slice(0, 200)}`
+        };
+      }
+      const data = await res.json();
+      const count = Array.isArray(data?.data) ? data.data.length : 0;
+      return {
+        success: true,
+        latencyMs: Date.now() - startTime,
+        modelsCount: count,
+        resolvedModel: this.defaultModel
+      };
+    } catch (err) {
+      return {
+        success: false,
+        latencyMs: Date.now() - startTime,
+        error: err.message || String(err)
+      };
+    }
   }
-  if (err instanceof RateLimitError) {
-    return pc.yellow(`\u26A0\uFE0F ${err.message}`);
+  async listModels(refresh = false) {
+    if (!refresh && this.cachedModels && this.cachedModels.length > 0) {
+      return this.cachedModels;
+    }
+    const key = this.getApiKey();
+    if (key) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 1e4);
+        const res = await fetch(`${this.baseUrl}/models`, {
+          method: "GET",
+          headers: {
+            "Authorization": `Bearer ${key}`,
+            ...this.customHeaders
+          },
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (res.ok) {
+          const json = await res.json();
+          if (Array.isArray(json?.data)) {
+            const models = [];
+            for (const item of json.data) {
+              const id = item.id;
+              if (typeof id !== "string") continue;
+              const lower = id.toLowerCase();
+              if (lower.includes("whisper") || lower.includes("tts") || lower.includes("dall-e") || lower.includes("text-embedding") || lower.includes("moderation")) {
+                continue;
+              }
+              models.push({
+                id,
+                name: id,
+                provider: this.id,
+                capabilities: this.getCapabilities(id)
+              });
+            }
+            if (models.length > 0) {
+              this.cachedModels = models;
+              return models;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const verified = [
+      "gpt-4o",
+      "gpt-4o-mini",
+      "o3-mini",
+      "o1",
+      "o1-mini",
+      "gpt-4-turbo"
+    ];
+    return verified.map((id) => ({
+      id,
+      name: id,
+      provider: this.id,
+      capabilities: this.getCapabilities(id)
+    }));
   }
-  if (err instanceof Error) {
-    const msg = err.message || "";
-    if (msg.includes("API_KEY_INVALID") || msg.includes("API key not valid")) {
-      return pc.red("Invalid Gemini API Key. Please verify your GEMINI_API_KEY at https://aistudio.google.com/app/apikey");
+  async streamGenerate(params) {
+    const key = this.getApiKey();
+    if (!key) {
+      throw new MissingApiKeyError(this.id, `${this.id.toUpperCase()}_API_KEY`);
     }
-    if (msg.includes("RESOURCE_EXHAUSTED") || msg.includes("429")) {
-      return pc.yellow("Rate limit / quota exceeded. Please wait a few seconds or check your quota limits.");
+    const overallStartTime = Date.now();
+    const timing = {
+      totalMs: 0,
+      toolExecutionMs: {}
+    };
+    const messages = this.convertHistoryToMessages(params.systemInstruction, params.history);
+    const tools = this.convertTools(params.tools);
+    const payload = {
+      model: params.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (tools.length > 0) {
+      payload.tools = tools;
+    }
+    if (typeof params.temperature === "number") {
+      payload.temperature = params.temperature;
+    }
+    if (params.maxOutputTokens) {
+      payload.max_tokens = params.maxOutputTokens;
+    }
+    const timeoutMs = params.timeoutMs || 6e4;
+    const firstTokenTimeoutMs = params.firstTokenTimeoutMs || 3e4;
+    let attempts = 0;
+    const maxAttempts = 3;
+    let lastError = null;
+    while (attempts < maxAttempts) {
+      attempts++;
+      const connectStart = Date.now();
+      if (params.callbacks.onStateChange) {
+        params.callbacks.onStateChange(attempts > 1 ? `retrying:${attempts}` : "connecting");
+      }
+      const { controller, cleanup } = createLinkedAbortController(params.signal, timeoutMs);
+      try {
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${key}`,
+            ...this.customHeaders
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        timing.connectMs = Date.now() - connectStart;
+        if (!response.ok) {
+          const errorBody = await response.text();
+          if (response.status === 401 || response.status === 403) {
+            throw new AuthenticationError(`OpenAI Auth Error (${response.status}): ${errorBody}`);
+          }
+          if (response.status === 429) {
+            throw new RateLimitError(`OpenAI Rate Limit: ${errorBody}`);
+          }
+          if (response.status === 404) {
+            throw new ModelNotFoundError(params.model, this.displayName);
+          }
+          throw new LanternProviderError(`OpenAI API Error (${response.status}): ${errorBody}`, response.status, this.id);
+        }
+        if (!response.body) {
+          throw new LanternProviderError("OpenAI response body is null", void 0, this.id);
+        }
+        if (params.callbacks.onStateChange) {
+          params.callbacks.onStateChange("waiting_first_token");
+        }
+        const rawStream = this.readSSEStream(response.body);
+        let fullText = "";
+        const toolCallsMap = {};
+        const usage = { promptTokens: 0, candidatesTokens: 0, totalTokens: 0 };
+        const wrappedStream = wrapStreamWithFirstTokenTimeout(
+          rawStream,
+          firstTokenTimeoutMs,
+          this.displayName,
+          params.model,
+          controller.signal,
+          (latencyMs) => {
+            timing.ttftMs = latencyMs;
+            if (params.callbacks.onStateChange) {
+              params.callbacks.onStateChange("streaming");
+            }
+          }
+        );
+        const streamStart = Date.now();
+        for await (const chunk of wrappedStream) {
+          const delta = chunk.choices?.[0]?.delta;
+          if (delta?.content) {
+            fullText += delta.content;
+            if (params.callbacks.onChunk) {
+              params.callbacks.onChunk(delta.content);
+            }
+          }
+          if (Array.isArray(delta?.tool_calls)) {
+            for (const tc of delta.tool_calls) {
+              const index = tc.index ?? 0;
+              if (!toolCallsMap[index]) {
+                toolCallsMap[index] = {
+                  id: tc.id || `call_${Date.now()}_${index}`,
+                  name: tc.function?.name || "",
+                  argsText: tc.function?.arguments || ""
+                };
+              } else {
+                if (tc.id) toolCallsMap[index].id = tc.id;
+                if (tc.function?.name) toolCallsMap[index].name = tc.function.name;
+                if (tc.function?.arguments) toolCallsMap[index].argsText += tc.function.arguments;
+              }
+            }
+          }
+          if (chunk.usage) {
+            usage.promptTokens = chunk.usage.prompt_tokens ?? usage.promptTokens;
+            usage.candidatesTokens = chunk.usage.completion_tokens ?? usage.candidatesTokens;
+            usage.totalTokens = chunk.usage.total_tokens ?? usage.totalTokens;
+            if (params.callbacks.onUsage) {
+              params.callbacks.onUsage(usage);
+            }
+          }
+        }
+        timing.streamMs = Date.now() - streamStart;
+        timing.totalMs = Date.now() - overallStartTime;
+        const collectedToolCalls = Object.values(toolCallsMap).map((tc) => {
+          let parsedArgs = {};
+          try {
+            parsedArgs = JSON.parse(tc.argsText || "{}");
+          } catch {
+            parsedArgs = { raw: tc.argsText };
+          }
+          return {
+            id: tc.id,
+            name: tc.name,
+            args: parsedArgs
+          };
+        });
+        if (params.callbacks.onToolCalls && collectedToolCalls.length > 0) {
+          params.callbacks.onToolCalls(collectedToolCalls);
+        }
+        cleanup();
+        return {
+          text: fullText,
+          toolCalls: collectedToolCalls,
+          usage,
+          timing
+        };
+      } catch (err) {
+        cleanup();
+        lastError = err;
+        if (params.signal?.aborted) {
+          throw err;
+        }
+        const msg = String(err?.message || err);
+        const isRateLimit = msg.includes("429") || err instanceof RateLimitError;
+        const isTransient = msg.includes("503") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT") || msg.includes("socket hang up");
+        if ((isRateLimit || isTransient) && attempts < maxAttempts) {
+          const backoff = Math.min(1e3 * Math.pow(1.5, attempts), 3e3);
+          if (params.callbacks.onStateChange) {
+            params.callbacks.onStateChange(`retrying:${attempts}`);
+          }
+          await new Promise((r) => setTimeout(r, backoff));
+          continue;
+        }
+        throw err instanceof Error ? err : new Error(String(err));
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  convertHistoryToMessages(systemInstruction, history) {
+    const messages = [];
+    if (systemInstruction) {
+      messages.push({ role: "system", content: systemInstruction });
     }
-    if (msg.includes("NOT_FOUND") || msg.includes("models/")) {
-      return pc.red(`Model not found or unavailable. Please check the requested model ID: ${msg}`);
+    for (const turn of history) {
+      if (turn.role === "user") {
+        const contentParts = [];
+        if (turn.text) {
+          contentParts.push({ type: "text", text: turn.text });
+        }
+        if (turn.attachments) {
+          for (const att of turn.attachments) {
+            if (att.base64Data && att.mimeType.startsWith("image/")) {
+              contentParts.push({
+                type: "image_url",
+                image_url: { url: `data:${att.mimeType};base64,${att.base64Data}` }
+              });
+            } else if (att.textContent) {
+              contentParts.push({
+                type: "text",
+                text: `[Attached File: ${att.name}]
+\`\`\`
+${att.textContent}
+\`\`\``
+              });
+            }
+          }
+        }
+        messages.push({
+          role: "user",
+          content: contentParts.length === 1 && contentParts[0].type === "text" ? contentParts[0].text : contentParts
+        });
+      } else if (turn.role === "model") {
+        const msg = { role: "assistant" };
+        if (turn.text) msg.content = turn.text;
+        if (turn.toolCalls && turn.toolCalls.length > 0) {
+          msg.tool_calls = turn.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.args)
+            }
+          }));
+        }
+        messages.push(msg);
+      } else if (turn.role === "tool") {
+        if (turn.toolResults) {
+          for (const tr of turn.toolResults) {
+            messages.push({
+              role: "tool",
+              tool_call_id: tr.callId,
+              content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
+            });
+          }
+        }
+      }
     }
-    return pc.red(`Gemini Error: ${msg}`);
+    return messages;
   }
-  return pc.red(`An unexpected error occurred: ${String(err)}`);
-}
-
-// src/provider/gemini.ts
-import { GoogleGenAI, Type } from "@google/genai";
-var GeminiProvider = class {
-  client = null;
-  apiKey = null;
-  constructor(apiKey) {
-    const key = apiKey || process.env.GEMINI_API_KEY;
-    if (key && key.trim().length > 0) {
-      this.apiKey = key.trim();
-      this.client = new GoogleGenAI({ apiKey: this.apiKey });
+  convertTools(tools) {
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    }));
+  }
+  async *readSSEStream(stream) {
+    const reader = stream.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.startsWith(":")) continue;
+          if (trimmed.startsWith("data: ")) {
+            const dataStr = trimmed.slice(6).trim();
+            if (dataStr === "[DONE]") return;
+            try {
+              yield JSON.parse(dataStr);
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
     }
   }
+};
+
+// src/provider/anthropicProvider.ts
+var AnthropicProvider = class {
+  id = "anthropic";
+  name = "anthropic";
+  displayName = "Anthropic Claude";
+  defaultModel = "claude-3-7-sonnet-20250219";
+  baseUrl = "https://api.anthropic.com/v1";
+  cachedModels = null;
   isConfigured() {
-    return Boolean(this.apiKey && this.client);
+    const { key } = getApiKey(this.id);
+    return Boolean(key && key.trim().length > 0);
+  }
+  getApiKey() {
+    return getApiKey(this.id).key;
   }
   getMaskedKey() {
-    if (!this.apiKey) return "Not configured";
-    if (this.apiKey.length <= 8) return "********";
-    return `${this.apiKey.slice(0, 4)}...${this.apiKey.slice(-4)}`;
-  }
-  ensureClient() {
-    if (!this.client || !this.apiKey) {
-      const envKey = process.env.GEMINI_API_KEY;
-      if (envKey && envKey.trim().length > 0) {
-        this.apiKey = envKey.trim();
-        this.client = new GoogleGenAI({ apiKey: this.apiKey });
-        return this.client;
-      }
-      throw new MissingApiKeyError();
-    }
-    return this.client;
-  }
-  async streamGenerate(modelId, systemInstruction, history, tools, callbacks, options) {
-    const client = this.ensureClient();
-    const contents = this.convertHistoryToContents(history);
-    const functionDeclarations = this.convertToolsToDeclarations(tools);
-    const config = {
-      systemInstruction,
-      temperature: options?.temperature ?? 0.2
+    const key = this.getApiKey();
+    return key ? maskApiKey(key) : "(not configured)";
+  }
+  getCapabilities(modelId) {
+    const lower = modelId.toLowerCase();
+    const isSonnet = lower.includes("sonnet");
+    const isOpus = lower.includes("opus");
+    return {
+      streaming: true,
+      tools: true,
+      images: true,
+      reasoning: isSonnet || isOpus,
+      contextWindow: 2e5
     };
-    if (options?.maxOutputTokens) {
-      config.maxOutputTokens = options.maxOutputTokens;
+  }
+  async testConnection() {
+    const key = this.getApiKey();
+    if (!key) {
+      return { success: false, latencyMs: 0, error: "Missing ANTHROPIC_API_KEY" };
     }
-    const toolList = [];
-    if (functionDeclarations.length > 0) {
-      toolList.push({ functionDeclarations });
+    const startTime = Date.now();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1e4);
+      const res = await fetch(`${this.baseUrl}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": key,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: "claude-3-5-haiku-20241022",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "ping" }]
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        const text = await res.text();
+        return {
+          success: false,
+          latencyMs: Date.now() - startTime,
+          error: `HTTP ${res.status}: ${text.slice(0, 200)}`
+        };
+      }
+      return {
+        success: true,
+        latencyMs: Date.now() - startTime,
+        resolvedModel: this.defaultModel
+      };
+    } catch (err) {
+      return {
+        success: false,
+        latencyMs: Date.now() - startTime,
+        error: err.message || String(err)
+      };
     }
-    if (options?.enableSearchGrounding) {
-      toolList.push({ googleSearch: {} });
+  }
+  async listModels(refresh = false) {
+    if (!refresh && this.cachedModels && this.cachedModels.length > 0) {
+      return this.cachedModels;
     }
-    if (toolList.length > 0) {
-      config.tools = toolList;
+    const key = this.getApiKey();
+    if (key) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 8e3);
+        const res = await fetch(`${this.baseUrl}/models`, {
+          method: "GET",
+          headers: {
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01"
+          },
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (res.ok) {
+          const json = await res.json();
+          if (Array.isArray(json?.data)) {
+            const models = json.data.map((m) => ({
+              id: m.id,
+              name: m.display_name || m.id,
+              provider: this.id,
+              capabilities: this.getCapabilities(m.id),
+              contextWindow: 2e5
+            }));
+            if (models.length > 0) {
+              this.cachedModels = models;
+              return models;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const verified = [
+      "claude-3-7-sonnet-20250219",
+      "claude-3-5-sonnet-20241022",
+      "claude-3-5-haiku-20241022",
+      "claude-3-opus-20240229"
+    ];
+    return verified.map((id) => ({
+      id,
+      name: id,
+      provider: this.id,
+      capabilities: this.getCapabilities(id),
+      contextWindow: 2e5
+    }));
+  }
+  async streamGenerate(params) {
+    const key = this.getApiKey();
+    if (!key) {
+      throw new MissingApiKeyError(this.id, "ANTHROPIC_API_KEY");
+    }
+    const overallStartTime = Date.now();
+    const timing = {
+      totalMs: 0,
+      toolExecutionMs: {}
+    };
+    const { messages, system } = this.convertHistoryToMessages(params.systemInstruction, params.history);
+    const tools = this.convertTools(params.tools);
+    const payload = {
+      model: params.model,
+      messages,
+      max_tokens: params.maxOutputTokens || 4096,
+      stream: true
+    };
+    if (system) {
+      payload.system = system;
     }
+    if (tools.length > 0) {
+      payload.tools = tools;
+    }
+    if (typeof params.temperature === "number") {
+      payload.temperature = params.temperature;
+    }
+    const timeoutMs = params.timeoutMs || 6e4;
+    const firstTokenTimeoutMs = params.firstTokenTimeoutMs || 3e4;
     let attempts = 0;
     const maxAttempts = 3;
     let lastError = null;
     while (attempts < maxAttempts) {
+      attempts++;
+      const connectStart = Date.now();
+      if (params.callbacks.onStateChange) {
+        params.callbacks.onStateChange(attempts > 1 ? `retrying:${attempts}` : "connecting");
+      }
+      const { controller, cleanup } = createLinkedAbortController(params.signal, timeoutMs);
       try {
-        attempts++;
-        const responseStream = await client.models.generateContentStream({
-          model: modelId,
-          contents,
-          config
+        const response = await fetch(`${this.baseUrl}/messages`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
         });
+        timing.connectMs = Date.now() - connectStart;
+        if (!response.ok) {
+          const errorBody = await response.text();
+          if (response.status === 401 || response.status === 403) {
+            throw new AuthenticationError(`Anthropic Auth Error (${response.status}): ${errorBody}`);
+          }
+          if (response.status === 429) {
+            throw new RateLimitError(`Anthropic Rate Limit: ${errorBody}`);
+          }
+          if (response.status === 404) {
+            throw new ModelNotFoundError(params.model, this.displayName);
+          }
+          throw new LanternProviderError(`Anthropic API Error (${response.status}): ${errorBody}`, response.status, this.id);
+        }
+        if (!response.body) {
+          throw new LanternProviderError("Anthropic response body is null", void 0, this.id);
+        }
+        if (params.callbacks.onStateChange) {
+          params.callbacks.onStateChange("waiting_first_token");
+        }
+        const rawStream = this.readSSEStream(response.body);
         let fullText = "";
-        const collectedToolCalls = [];
-        const usage = {
-          promptTokens: 0,
-          candidatesTokens: 0,
-          totalTokens: 0
-        };
-        for await (const chunk of responseStream) {
-          if (chunk.text) {
-            fullText += chunk.text;
-            if (callbacks.onChunk) {
-              callbacks.onChunk(chunk.text);
+        const toolCallsMap = {};
+        const usage = { promptTokens: 0, candidatesTokens: 0, totalTokens: 0 };
+        const wrappedStream = wrapStreamWithFirstTokenTimeout(
+          rawStream,
+          firstTokenTimeoutMs,
+          this.displayName,
+          params.model,
+          controller.signal,
+          (latencyMs) => {
+            timing.ttftMs = latencyMs;
+            if (params.callbacks.onStateChange) {
+              params.callbacks.onStateChange("streaming");
             }
           }
-          if (chunk.functionCalls && chunk.functionCalls.length > 0) {
-            for (const fc of chunk.functionCalls) {
-              collectedToolCalls.push({
-                id: fc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
-                name: fc.name || "",
-                args: fc.args || {}
-              });
+        );
+        const streamStart = Date.now();
+        for await (const event of wrappedStream) {
+          const type = event.type;
+          if (type === "message_start" && event.message?.usage) {
+            usage.promptTokens = event.message.usage.input_tokens || 0;
+          }
+          if (type === "content_block_start") {
+            const index = event.index ?? 0;
+            if (event.content_block?.type === "tool_use") {
+              toolCallsMap[index] = {
+                id: event.content_block.id || `call_${Date.now()}_${index}`,
+                name: event.content_block.name || "",
+                argsText: ""
+              };
             }
           }
-          if (chunk.usageMetadata) {
-            usage.promptTokens = chunk.usageMetadata.promptTokenCount ?? usage.promptTokens;
-            usage.candidatesTokens = chunk.usageMetadata.candidatesTokenCount ?? usage.candidatesTokens;
-            usage.totalTokens = chunk.usageMetadata.totalTokenCount ?? usage.totalTokens;
-            if (callbacks.onUsage) {
-              callbacks.onUsage(usage);
+          if (type === "content_block_delta") {
+            const index = event.index ?? 0;
+            const delta = event.delta;
+            if (delta?.type === "text_delta" && delta.text) {
+              fullText += delta.text;
+              if (params.callbacks.onChunk) {
+                params.callbacks.onChunk(delta.text);
+              }
+            } else if (delta?.type === "input_json_delta" && delta.partial_json) {
+              if (toolCallsMap[index]) {
+                toolCallsMap[index].argsText += delta.partial_json;
+              }
+            }
+          }
+          if (type === "message_delta" && event.usage) {
+            usage.candidatesTokens = event.usage.output_tokens || 0;
+            usage.totalTokens = usage.promptTokens + usage.candidatesTokens;
+            if (params.callbacks.onUsage) {
+              params.callbacks.onUsage(usage);
             }
           }
         }
-        if (callbacks.onToolCalls && collectedToolCalls.length > 0) {
-          callbacks.onToolCalls(collectedToolCalls);
+        timing.streamMs = Date.now() - streamStart;
+        timing.totalMs = Date.now() - overallStartTime;
+        const collectedToolCalls = Object.values(toolCallsMap).map((tc) => {
+          let parsedArgs = {};
+          try {
+            parsedArgs = JSON.parse(tc.argsText || "{}");
+          } catch {
+            parsedArgs = { raw: tc.argsText };
+          }
+          return {
+            id: tc.id,
+            name: tc.name,
+            args: parsedArgs
+          };
+        });
+        if (params.callbacks.onToolCalls && collectedToolCalls.length > 0) {
+          params.callbacks.onToolCalls(collectedToolCalls);
         }
+        cleanup();
         return {
           text: fullText,
           toolCalls: collectedToolCalls,
-          usage
+          usage,
+          timing
         };
       } catch (err) {
+        cleanup();
         lastError = err;
-        const msg = String(err?.message || err);
-        if (msg.includes("API_KEY_INVALID") || msg.includes("401") || msg.includes("403")) {
-          throw new GeminiProviderError(`Authentication failed: ${msg}`, 401);
+        if (params.signal?.aborted) {
+          throw err;
         }
-        const isRateLimit = msg.includes("429") || msg.includes("RESOURCE_EXHAUSTED");
+        const msg = String(err?.message || err);
+        const isRateLimit = msg.includes("429") || err instanceof RateLimitError;
         const isTransient = msg.includes("503") || msg.includes("overloaded") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT");
         if ((isRateLimit || isTransient) && attempts < maxAttempts) {
-          const delay = Math.pow(2, attempts) * 1e3 + Math.random() * 500;
-          await new Promise((r) => setTimeout(r, delay));
+          const backoff = Math.min(1e3 * Math.pow(1.5, attempts), 3e3);
+          if (params.callbacks.onStateChange) {
+            params.callbacks.onStateChange(`retrying:${attempts}`);
+          }
+          await new Promise((r) => setTimeout(r, backoff));
           continue;
         }
-        if (isRateLimit) {
-          throw new RateLimitError(msg);
-        }
-        throw new GeminiProviderError(`Gemini request failed: ${msg}`);
+        throw err instanceof Error ? err : new Error(String(err));
       }
     }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
-  convertHistoryToContents(turns) {
-    const contents = [];
-    for (const turn of turns) {
-      const parts = [];
+  convertHistoryToMessages(systemInstruction, history) {
+    const messages = [];
+    for (const turn of history) {
       if (turn.role === "user") {
+        const content = [];
         if (turn.text) {
-          parts.push({ text: turn.text });
+          content.push({ type: "text", text: turn.text });
         }
-        if (turn.attachments && turn.attachments.length > 0) {
+        if (turn.attachments) {
           for (const att of turn.attachments) {
-            if (att.base64Data && att.mimeType) {
-              parts.push({
-                inlineData: {
-                  mimeType: att.mimeType,
+            if (att.base64Data && att.mimeType.startsWith("image/")) {
+              content.push({
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: att.mimeType,
                   data: att.base64Data
                 }
               });
             } else if (att.textContent) {
-              parts.push({
+              content.push({
+                type: "text",
                 text: `[Attached File: ${att.name}]
 \`\`\`
 ${att.textContent}
@@ -208,92 +1661,259 @@ ${att.textContent}
             }
           }
         }
-        if (parts.length > 0) {
-          contents.push({ role: "user", parts });
-        }
+        messages.push({ role: "user", content });
       } else if (turn.role === "model") {
+        const content = [];
         if (turn.text) {
-          parts.push({ text: turn.text });
+          content.push({ type: "text", text: turn.text });
         }
-        if (turn.toolCalls && turn.toolCalls.length > 0) {
+        if (turn.toolCalls) {
           for (const tc of turn.toolCalls) {
-            parts.push({
-              functionCall: {
-                id: tc.id,
-                name: tc.name,
-                args: tc.args
-              }
-            });
-          }
-        }
-        if (parts.length > 0) {
-          contents.push({ role: "model", parts });
-        }
-      } else if (turn.role === "tool") {
-        if (turn.toolResults && turn.toolResults.length > 0) {
-          for (const res of turn.toolResults) {
-            parts.push({
-              functionResponse: {
-                id: res.callId,
-                name: res.name,
-                response: {
-                  result: res.error ? { error: res.error } : res.result
-                }
-              }
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.name,
+              input: tc.args
             });
           }
         }
-        if (parts.length > 0) {
-          contents.push({ role: "tool", parts });
+        messages.push({ role: "assistant", content });
+      } else if (turn.role === "tool") {
+        if (turn.toolResults) {
+          const content = [];
+          for (const tr of turn.toolResults) {
+            content.push({
+              type: "tool_result",
+              tool_use_id: tr.callId,
+              content: typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
+            });
+          }
+          messages.push({ role: "user", content });
         }
       }
     }
-    return contents;
+    return { messages, system: systemInstruction || void 0 };
   }
-  convertToolsToDeclarations(tools) {
-    return tools.map((tool) => {
-      const properties = {};
-      for (const [propName, propDef] of Object.entries(tool.parameters.properties)) {
-        let typeVal = Type.STRING;
-        switch (propDef.type) {
-          case "number":
-          case "integer":
-            typeVal = Type.NUMBER;
-            break;
-          case "boolean":
-            typeVal = Type.BOOLEAN;
-            break;
-          case "array":
-            typeVal = Type.ARRAY;
-            break;
-          case "object":
-            typeVal = Type.OBJECT;
-            break;
-          default:
-            typeVal = Type.STRING;
+  convertTools(tools) {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    }));
+  }
+  async *readSSEStream(stream) {
+    const reader = stream.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.startsWith(":")) continue;
+          if (trimmed.startsWith("data: ")) {
+            const dataStr = trimmed.slice(6).trim();
+            try {
+              yield JSON.parse(dataStr);
+            } catch {
+            }
+          }
         }
-        properties[propName] = {
-          type: typeVal,
-          description: propDef.description,
-          ...propDef.enum ? { enum: propDef.enum } : {},
-          ...propDef.items ? { items: { type: Type.STRING } } : {}
-        };
       }
-      return {
-        name: tool.name,
-        description: tool.description,
-        parameters: {
-          type: Type.OBJECT,
-          properties,
-          required: tool.parameters.required || []
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/provider/openrouterProvider.ts
+var OpenRouterProvider = class extends OpenAIProvider {
+  constructor() {
+    super({
+      id: "openrouter",
+      name: "openrouter",
+      displayName: "OpenRouter",
+      baseUrl: "https://openrouter.ai/api/v1",
+      defaultModel: "anthropic/claude-3.7-sonnet",
+      headers: {
+        "HTTP-Referer": "https://github.com/codelantern/codelantern-agent-cli",
+        "X-Title": "Code Lantern CLI"
+      }
+    });
+  }
+  getCapabilities(modelId) {
+    const lower = modelId.toLowerCase();
+    const isReasoning = lower.includes("r1") || lower.includes("o1") || lower.includes("o3") || lower.includes("reason");
+    return {
+      streaming: true,
+      tools: !lower.includes(":free") && !lower.includes("deepseek-r1"),
+      // Most OpenRouter models support tool calling
+      images: lower.includes("vision") || lower.includes("gpt-4o") || lower.includes("claude-3") || lower.includes("gemini"),
+      reasoning: isReasoning,
+      contextWindow: 128e3
+    };
+  }
+  async listModels(refresh = false) {
+    const key = this.getApiKey();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 1e4);
+      const headers = { ...this.customHeaders };
+      if (key) {
+        headers["Authorization"] = `Bearer ${key}`;
+      }
+      const res = await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (res.ok) {
+        const json = await res.json();
+        if (Array.isArray(json?.data)) {
+          const models = json.data.slice(0, 100).map((m) => ({
+            id: m.id,
+            name: m.name || m.id,
+            provider: this.id,
+            description: m.description,
+            contextWindow: m.context_length || 128e3,
+            capabilities: this.getCapabilities(m.id),
+            pricing: m.pricing ? {
+              promptPer1k: parseFloat(m.pricing.prompt) * 1e3,
+              completionPer1k: parseFloat(m.pricing.completion) * 1e3
+            } : void 0
+          }));
+          return models;
         }
-      };
+      }
+    } catch {
+    }
+    const verified = [
+      "anthropic/claude-3.7-sonnet",
+      "anthropic/claude-3.5-sonnet",
+      "openai/gpt-4o",
+      "openai/o3-mini",
+      "google/gemini-2.5-flash",
+      "deepseek/deepseek-chat",
+      "meta-llama/llama-3.3-70b-instruct"
+    ];
+    return verified.map((id) => ({
+      id,
+      name: id,
+      provider: this.id,
+      capabilities: this.getCapabilities(id)
+    }));
+  }
+};
+
+// src/provider/registry.ts
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerBuiltins();
+    this.loadCustomProviders();
+  }
+  registerBuiltins() {
+    const gemini = new GeminiProvider();
+    const openai = new OpenAIProvider();
+    const anthropic = new AnthropicProvider();
+    const openrouter = new OpenRouterProvider();
+    this.providers.set(gemini.id, gemini);
+    this.providers.set(openai.id, openai);
+    this.providers.set(anthropic.id, anthropic);
+    this.providers.set(openrouter.id, openrouter);
+  }
+  loadCustomProviders() {
+    const config = loadConfig();
+    if (config.providers) {
+      for (const [id, provConfig] of Object.entries(config.providers)) {
+        if (!provConfig.disabled) {
+          const adapter = new OpenAIProvider({
+            id,
+            name: provConfig.name || id,
+            displayName: provConfig.name || id,
+            baseUrl: provConfig.baseUrl,
+            defaultModel: provConfig.defaultModel || "default",
+            headers: provConfig.headers
+          });
+          this.providers.set(id, adapter);
+        }
+      }
+    }
+  }
+  getProvider(id) {
+    const targetId = (id || loadConfig().activeProvider || "gemini").toLowerCase();
+    const provider = this.providers.get(targetId);
+    if (provider) {
+      return provider;
+    }
+    const gemini = this.providers.get("gemini");
+    if (gemini) return gemini;
+    const first = Array.from(this.providers.values())[0];
+    if (first) return first;
+    throw new Error(`No provider adapter registered for '${targetId}'.`);
+  }
+  hasProvider(id) {
+    return this.providers.has(id.toLowerCase());
+  }
+  listProviders() {
+    const activeId = (loadConfig().activeProvider || "gemini").toLowerCase();
+    return Array.from(this.providers.values()).map((p) => ({
+      id: p.id,
+      name: p.name,
+      displayName: p.displayName,
+      isConfigured: p.isConfigured(),
+      maskedKey: p.getMaskedKey(),
+      defaultModel: p.defaultModel,
+      isActive: p.id === activeId
+    }));
+  }
+  registerCustomProvider(cfg) {
+    const id = cfg.id.toLowerCase();
+    const adapter = new OpenAIProvider({
+      id,
+      name: cfg.name || id,
+      displayName: cfg.name || id,
+      baseUrl: cfg.baseUrl,
+      defaultModel: cfg.defaultModel || "default",
+      headers: cfg.headers
     });
+    this.providers.set(id, adapter);
+    const currentConfig = loadConfig();
+    if (!currentConfig.providers) currentConfig.providers = {};
+    currentConfig.providers[id] = cfg;
+    saveConfig(currentConfig);
+  }
+  removeCustomProvider(id) {
+    const norm = id.toLowerCase();
+    const builtins = ["gemini", "openai", "anthropic", "openrouter"];
+    if (builtins.includes(norm)) {
+      return false;
+    }
+    const deleted = this.providers.delete(norm);
+    const currentConfig = loadConfig();
+    if (currentConfig.providers && currentConfig.providers[norm]) {
+      delete currentConfig.providers[norm];
+      saveConfig(currentConfig);
+    }
+    return deleted;
+  }
+  async testProvider(id) {
+    const p = this.getProvider(id);
+    return await p.testConnection();
+  }
+  async listModels(providerId, refresh = false) {
+    const p = this.getProvider(providerId);
+    return await p.listModels(refresh);
   }
 };
 
 // src/security/secrets.ts
-import path from "path";
+import path3 from "path";
 var SECRET_FILE_PATTERNS = [
   /^\.env(\..+)?$/i,
   /\.pem$/i,
@@ -311,7 +1931,7 @@ var SECRET_FILE_PATTERNS = [
   /\.secret/i
 ];
 function isSecretFile(filePath) {
-  const base = path.basename(filePath);
+  const base = path3.basename(filePath);
   return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(base));
 }
 function sanitizeSecrets(text) {
@@ -328,18 +1948,18 @@ function sanitizeSecrets(text) {
 }
 
 // src/security/sandbox.ts
-import path2 from "path";
-import fs from "fs";
+import path4 from "path";
+import fs3 from "fs";
 var isWindows = process.platform === "win32";
 function normalizeForComparison(p) {
-  const resolved = path2.resolve(p);
+  const resolved = path4.resolve(p);
   return isWindows ? resolved.toLowerCase() : resolved;
 }
 function isContainedWithin(parent, target) {
   const normParent = normalizeForComparison(parent);
   const normTarget = normalizeForComparison(target);
-  const rel = path2.relative(normParent, normTarget);
-  return !rel.startsWith("..") && !path2.isAbsolute(rel);
+  const rel = path4.relative(normParent, normTarget);
+  return !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths = []) {
   if (!targetPath || typeof targetPath !== "string") {
@@ -350,14 +1970,14 @@ function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths =
       reason: "Empty or invalid file path provided."
     };
   }
-  let normalizedWorkspace = path2.resolve(workspaceDir);
+  let normalizedWorkspace = path4.resolve(workspaceDir);
   try {
-    if (fs.existsSync(normalizedWorkspace)) {
-      normalizedWorkspace = fs.realpathSync(normalizedWorkspace);
+    if (fs3.existsSync(normalizedWorkspace)) {
+      normalizedWorkspace = fs3.realpathSync(normalizedWorkspace);
     }
   } catch {
   }
-  const resolvedTarget = path2.isAbsolute(targetPath) ? path2.resolve(targetPath) : path2.resolve(normalizedWorkspace, targetPath);
+  const resolvedTarget = path4.isAbsolute(targetPath) ? path4.resolve(targetPath) : path4.resolve(normalizedWorkspace, targetPath);
   const isExplicitlyAllowed = allowedExternalPaths.some((p) => {
     const normAllowed = normalizeForComparison(p);
     const normTarget = normalizeForComparison(resolvedTarget);
@@ -367,25 +1987,25 @@ function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths =
     return {
       allowed: true,
       resolvedPath: resolvedTarget,
-      relativePath: path2.relative(normalizedWorkspace, resolvedTarget) || path2.basename(resolvedTarget)
+      relativePath: path4.relative(normalizedWorkspace, resolvedTarget) || path4.basename(resolvedTarget)
     };
   }
   if (!isContainedWithin(normalizedWorkspace, resolvedTarget)) {
     return {
       allowed: false,
       resolvedPath: resolvedTarget,
-      relativePath: path2.relative(normalizedWorkspace, resolvedTarget),
+      relativePath: path4.relative(normalizedWorkspace, resolvedTarget),
       reason: `Path '${targetPath}' is outside the authorized workspace: ${normalizedWorkspace}`
     };
   }
   try {
-    if (fs.existsSync(resolvedTarget)) {
-      const realTarget = fs.realpathSync(resolvedTarget);
+    if (fs3.existsSync(resolvedTarget)) {
+      const realTarget = fs3.realpathSync(resolvedTarget);
       if (!isContainedWithin(normalizedWorkspace, realTarget)) {
         return {
           allowed: false,
           resolvedPath: realTarget,
-          relativePath: path2.relative(normalizedWorkspace, realTarget),
+          relativePath: path4.relative(normalizedWorkspace, realTarget),
           reason: `Symlink target points outside the workspace: ${realTarget}`
         };
       }
@@ -396,14 +2016,14 @@ function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths =
     return {
       allowed: false,
       resolvedPath: resolvedTarget,
-      relativePath: path2.relative(normalizedWorkspace, resolvedTarget),
-      reason: `Access to secret or credential file '${path2.basename(resolvedTarget)}' is blocked for security.`
+      relativePath: path4.relative(normalizedWorkspace, resolvedTarget),
+      reason: `Access to secret or credential file '${path4.basename(resolvedTarget)}' is blocked for security.`
     };
   }
   return {
     allowed: true,
     resolvedPath: resolvedTarget,
-    relativePath: path2.relative(normalizedWorkspace, resolvedTarget) || "."
+    relativePath: path4.relative(normalizedWorkspace, resolvedTarget) || "."
   };
 }
 
@@ -488,8 +2108,8 @@ function validateCommand(command) {
 }
 
 // src/tools/fsTools.ts
-import fs2 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path5 from "path";
 var readFileTool = {
   definition: {
     name: "read_file",
@@ -524,14 +2144,14 @@ var readFileTool = {
         error: validation.reason
       };
     }
-    if (!fs2.existsSync(validation.resolvedPath)) {
+    if (!fs4.existsSync(validation.resolvedPath)) {
       return {
         success: false,
         output: `Error: File not found at '${validation.relativePath}'`,
         error: "File not found"
       };
     }
-    const stat = fs2.statSync(validation.resolvedPath);
+    const stat = fs4.statSync(validation.resolvedPath);
     if (!stat.isFile()) {
       return {
         success: false,
@@ -547,7 +2167,7 @@ var readFileTool = {
       };
     }
     try {
-      const content = fs2.readFileSync(validation.resolvedPath, "utf8");
+      const content = fs4.readFileSync(validation.resolvedPath, "utf8");
       const lines = content.split("\n");
       const totalLines = lines.length;
       let start = 1;
@@ -619,11 +2239,11 @@ var writeFileTool = {
         error: validation.reason
       };
     }
-    const fileExists = fs2.existsSync(validation.resolvedPath);
+    const fileExists = fs4.existsSync(validation.resolvedPath);
     let oldContent = "";
     if (fileExists) {
       try {
-        oldContent = fs2.readFileSync(validation.resolvedPath, "utf8");
+        oldContent = fs4.readFileSync(validation.resolvedPath, "utf8");
       } catch {
         oldContent = "";
       }
@@ -646,11 +2266,11 @@ var writeFileTool = {
       };
     }
     try {
-      const parentDir = path3.dirname(validation.resolvedPath);
-      if (!fs2.existsSync(parentDir)) {
-        fs2.mkdirSync(parentDir, { recursive: true });
+      const parentDir = path5.dirname(validation.resolvedPath);
+      if (!fs4.existsSync(parentDir)) {
+        fs4.mkdirSync(parentDir, { recursive: true });
       }
-      fs2.writeFileSync(validation.resolvedPath, content, "utf8");
+      fs4.writeFileSync(validation.resolvedPath, content, "utf8");
       const lines = content.split("\n").length;
       return {
         success: true,
@@ -702,7 +2322,7 @@ var editFileTool = {
         error: validation.reason
       };
     }
-    if (!fs2.existsSync(validation.resolvedPath)) {
+    if (!fs4.existsSync(validation.resolvedPath)) {
       return {
         success: false,
         output: `Error: File not found at '${validation.relativePath}'`,
@@ -710,7 +2330,7 @@ var editFileTool = {
       };
     }
     try {
-      const original = fs2.readFileSync(validation.resolvedPath, "utf8");
+      const original = fs4.readFileSync(validation.resolvedPath, "utf8");
       const hasCrlf = original.includes("\r\n");
       let matchedTarget = target;
       if (!original.includes(target)) {
@@ -760,7 +2380,7 @@ var editFileTool = {
           error: "Approval rejected"
         };
       }
-      fs2.writeFileSync(validation.resolvedPath, updated, "utf8");
+      fs4.writeFileSync(validation.resolvedPath, updated, "utf8");
       return {
         success: true,
         output: `Successfully applied edit to ${validation.relativePath}`,
@@ -777,8 +2397,8 @@ var editFileTool = {
 };
 
 // src/tools/searchTools.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import fg from "fast-glob";
 import ignore from "ignore";
 var DEFAULT_IGNORED_DIRS = [
@@ -800,10 +2420,10 @@ var DEFAULT_IGNORED_DIRS = [
 function getWorkspaceIgnore(workspaceDir) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORED_DIRS);
-  const gitignorePath = path4.join(workspaceDir, ".gitignore");
-  if (fs3.existsSync(gitignorePath)) {
+  const gitignorePath = path6.join(workspaceDir, ".gitignore");
+  if (fs5.existsSync(gitignorePath)) {
     try {
-      const gitignoreContent = fs3.readFileSync(gitignorePath, "utf8");
+      const gitignoreContent = fs5.readFileSync(gitignorePath, "utf8");
       ig.add(gitignoreContent);
     } catch {
     }
@@ -831,9 +2451,9 @@ var listDirectoryTool = {
   },
   async execute(args, context) {
     const rawPath = String(args.path || "").trim();
-    let realWorkspace = path4.resolve(context.workspace);
+    let realWorkspace = path6.resolve(context.workspace);
     try {
-      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
     } catch {
     }
     const validation = validateWorkspacePath(rawPath || ".", realWorkspace);
@@ -844,7 +2464,7 @@ var listDirectoryTool = {
         error: validation.reason
       };
     }
-    if (!fs3.existsSync(validation.resolvedPath)) {
+    if (!fs5.existsSync(validation.resolvedPath)) {
       return {
         success: false,
         output: `Directory not found: ${validation.relativePath || "."}`,
@@ -856,10 +2476,10 @@ var listDirectoryTool = {
     try {
       let walk2 = function(currentDir, currentDepth) {
         if (currentDepth > maxDepth) return;
-        const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs5.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path4.join(currentDir, entry.name);
-          const relToWorkspace = path4.relative(realWorkspace, fullPath).replace(/\\/g, "/");
+          const fullPath = path6.join(currentDir, entry.name);
+          const relToWorkspace = path6.relative(realWorkspace, fullPath).replace(/\\/g, "/");
           if (ig.ignores(relToWorkspace) || DEFAULT_IGNORED_DIRS.includes(entry.name)) {
             continue;
           }
@@ -914,14 +2534,14 @@ var fileSearchTool = {
     if (!rawPattern) {
       return { success: false, output: "Pattern parameter is required.", error: "Missing pattern" };
     }
-    let realWorkspace = path4.resolve(context.workspace);
+    let realWorkspace = path6.resolve(context.workspace);
     try {
-      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
     } catch {
     }
     const subDir = String(args.directory || "").trim();
-    const searchRoot = subDir ? path4.resolve(realWorkspace, subDir) : realWorkspace;
-    const validation = validateWorkspacePath(path4.relative(realWorkspace, searchRoot) || ".", realWorkspace);
+    const searchRoot = subDir ? path6.resolve(realWorkspace, subDir) : realWorkspace;
+    const validation = validateWorkspacePath(path6.relative(realWorkspace, searchRoot) || ".", realWorkspace);
     if (!validation.allowed) {
       return { success: false, output: `Access denied: ${validation.reason}`, error: validation.reason };
     }
@@ -937,8 +2557,8 @@ var fileSearchTool = {
       });
       const ig = getWorkspaceIgnore(realWorkspace);
       const filtered = matches.filter((m) => {
-        const full = path4.join(searchRoot, m);
-        const rel = path4.relative(realWorkspace, full).replace(/\\/g, "/");
+        const full = path6.join(searchRoot, m);
+        const rel = path6.relative(realWorkspace, full).replace(/\\/g, "/");
         return !ig.ignores(rel);
       });
       if (filtered.length === 0) {
@@ -987,9 +2607,9 @@ var grepSearchTool = {
     if (!query) {
       return { success: false, output: "Query parameter is required.", error: "Missing query" };
     }
-    let realWorkspace = path4.resolve(context.workspace);
+    let realWorkspace = path6.resolve(context.workspace);
     try {
-      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
     } catch {
     }
     const pathPattern = args.path_pattern ? String(args.path_pattern).replace(/\\/g, "/") : "**/*";
@@ -1008,11 +2628,11 @@ var grepSearchTool = {
         const normalizedRel = relFile.replace(/\\/g, "/");
         if (ig.ignores(normalizedRel)) continue;
         if (relFile.endsWith(".map") || relFile.endsWith(".min.js") || relFile.endsWith(".lock")) continue;
-        const fullPath = path4.join(realWorkspace, relFile);
+        const fullPath = path6.join(realWorkspace, relFile);
         try {
-          const stat = fs3.statSync(fullPath);
+          const stat = fs5.statSync(fullPath);
           if (stat.size > 500 * 1024) continue;
-          const rawContent = fs3.readFileSync(fullPath, "utf8");
+          const rawContent = fs5.readFileSync(fullPath, "utf8");
           const lines = rawContent.replace(/\r\n/g, "\n").split("\n");
           for (let i = 0; i < lines.length; i++) {
             if (regex.test(lines[i])) {
@@ -1065,9 +2685,9 @@ var projectTreeTool = {
   },
   async execute(args, context) {
     const rawDir = String(args.directory || "").trim();
-    let realWorkspace = path4.resolve(context.workspace);
+    let realWorkspace = path6.resolve(context.workspace);
     try {
-      if (fs3.existsSync(realWorkspace)) realWorkspace = fs3.realpathSync(realWorkspace);
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
     } catch {
     }
     const validation = validateWorkspacePath(rawDir || ".", realWorkspace);
@@ -1081,14 +2701,14 @@ var projectTreeTool = {
         if (depth > maxDepth) return;
         let entries = [];
         try {
-          entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+          entries = fs5.readdirSync(currentDir, { withFileTypes: true });
         } catch {
           return;
         }
         const validEntries = entries.filter((e) => {
           if (DEFAULT_IGNORED_DIRS.includes(e.name)) return false;
-          const full = path4.join(currentDir, e.name);
-          const rel = path4.relative(realWorkspace, full).replace(/\\/g, "/");
+          const full = path6.join(currentDir, e.name);
+          const rel = path6.relative(realWorkspace, full).replace(/\\/g, "/");
           return !ig.ignores(rel);
         });
         validEntries.sort((a, b) => {
@@ -1099,7 +2719,7 @@ var projectTreeTool = {
         validEntries.forEach((entry, idx) => {
           const isLast = idx === validEntries.length - 1;
           const pointer = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-          const fullPath = path4.join(currentDir, entry.name);
+          const fullPath = path6.join(currentDir, entry.name);
           lines.push(`${prefix}${pointer}${entry.name}${entry.isDirectory() ? "/" : ""}`);
           if (entry.isDirectory()) {
             buildTree2(fullPath, prefix + (isLast ? "    " : "\u2502   "), depth + 1);
@@ -1107,7 +2727,7 @@ var projectTreeTool = {
         });
       };
       var buildTree = buildTree2;
-      const lines = [path4.basename(validation.resolvedPath) || "."];
+      const lines = [path6.basename(validation.resolvedPath) || "."];
       buildTree2(validation.resolvedPath, "", 1);
       return {
         success: true,
@@ -1360,263 +2980,98 @@ ${snippets.join("\n\n")}`,
       return {
         success: false,
         output: `Web search could not reach external network: ${err.message}`,
-        error: err.message
-      };
-    }
-  }
-};
-
-// src/tools/registry.ts
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  constructor() {
-    this.registerBuiltins();
-  }
-  registerBuiltins() {
-    const builtins = [
-      readFileTool,
-      writeFileTool,
-      editFileTool,
-      listDirectoryTool,
-      fileSearchTool,
-      grepSearchTool,
-      projectTreeTool,
-      runCommandTool,
-      gitStatusTool,
-      gitDiffTool,
-      webSearchTool
-    ];
-    for (const tool of builtins) {
-      this.tools.set(tool.definition.name, tool);
-    }
-  }
-  registerTool(tool) {
-    this.tools.set(tool.definition.name, tool);
-  }
-  registerTools(tools) {
-    for (const tool of tools) {
-      this.tools.set(tool.definition.name, tool);
-    }
-  }
-  getTool(name) {
-    return this.tools.get(name);
-  }
-  getDefinitions(planMode = false) {
-    const defs = [];
-    for (const tool of this.tools.values()) {
-      if (planMode && !tool.definition.readOnly) {
-        continue;
-      }
-      defs.push(tool.definition);
-    }
-    return defs;
-  }
-  async executeTool(name, args, context) {
-    const tool = this.tools.get(name);
-    if (!tool) {
-      return {
-        success: false,
-        output: `Error: Unknown tool "${name}". Available tools: ${Array.from(this.tools.keys()).join(", ")}`,
-        error: "Tool not found"
-      };
-    }
-    if (context.planMode && !tool.definition.readOnly) {
-      return {
-        success: false,
-        output: `Plan mode is active (read-only). Action "${name}" was blocked.`,
-        error: "Plan mode read-only restriction"
-      };
-    }
-    try {
-      return await tool.execute(args, context);
-    } catch (err) {
-      return {
-        success: false,
-        output: `Error executing tool "${name}": ${err.message}`,
-        error: err.message
-      };
-    }
-  }
-};
-
-// src/config/schema.ts
-var DEFAULT_CONFIG = {
-  defaultModel: "gemini-3.8-flash",
-  maxSteps: 25,
-  temperature: 0.2,
-  maxOutputTokens: 8192,
-  yolo: false,
-  theme: "default",
-  autoCompactThreshold: 30,
-  // turns before auto-compacting
-  timeoutMs: 6e4,
-  mcpServers: {}
-};
-var ALLOWED_CONFIG_KEYS = [
-  "defaultModel",
-  "maxSteps",
-  "temperature",
-  "maxOutputTokens",
-  "yolo",
-  "theme",
-  "autoCompactThreshold",
-  "timeoutMs"
-];
-function validateConfigValue(key, value) {
-  switch (key) {
-    case "defaultModel":
-      if (typeof value !== "string" || value.trim().length === 0) {
-        return { valid: false, error: "defaultModel must be a non-empty string" };
-      }
-      return { valid: true, parsedValue: value.trim() };
-    case "maxSteps": {
-      const num = Number(value);
-      if (isNaN(num) || num < 1 || num > 100) {
-        return { valid: false, error: "maxSteps must be a number between 1 and 100" };
-      }
-      return { valid: true, parsedValue: Math.round(num) };
-    }
-    case "temperature": {
-      const num = Number(value);
-      if (isNaN(num) || num < 0 || num > 2) {
-        return { valid: false, error: "temperature must be a number between 0.0 and 2.0" };
-      }
-      return { valid: true, parsedValue: num };
-    }
-    case "maxOutputTokens": {
-      const num = Number(value);
-      if (isNaN(num) || num < 256 || num > 65536) {
-        return { valid: false, error: "maxOutputTokens must be between 256 and 65536" };
-      }
-      return { valid: true, parsedValue: Math.round(num) };
-    }
-    case "yolo": {
-      if (typeof value === "boolean") return { valid: true, parsedValue: value };
-      if (value === "true" || value === "1") return { valid: true, parsedValue: true };
-      if (value === "false" || value === "0") return { valid: true, parsedValue: false };
-      return { valid: false, error: "yolo must be a boolean (true/false)" };
-    }
-    case "theme": {
-      if (value === "default" || value === "ocean" || value === "minimal") {
-        return { valid: true, parsedValue: value };
-      }
-      return { valid: false, error: "theme must be 'default', 'ocean', or 'minimal'" };
-    }
-    case "autoCompactThreshold": {
-      const num = Number(value);
-      if (isNaN(num) || num < 5 || num > 200) {
-        return { valid: false, error: "autoCompactThreshold must be a number between 5 and 200" };
-      }
-      return { valid: true, parsedValue: Math.round(num) };
-    }
-    case "timeoutMs": {
-      const num = Number(value);
-      if (isNaN(num) || num < 5e3) {
-        return { valid: false, error: "timeoutMs must be at least 5000 (ms)" };
-      }
-      return { valid: true, parsedValue: Math.round(num) };
+        error: err.message
+      };
     }
-    default:
-      return { valid: false, error: `Unknown configuration key: ${key}` };
   }
-}
+};
 
-// src/config/config.ts
-import fs4 from "fs";
-import path5 from "path";
-import os from "os";
-function getLanternHomeDir() {
-  const customHome = process.env.CODELANTERN_HOME || process.env.LANTERN_HOME;
-  if (customHome) {
-    if (!fs4.existsSync(customHome)) {
-      try {
-        fs4.mkdirSync(customHome, { recursive: true });
-      } catch {
-      }
-    }
-    return customHome;
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerBuiltins();
   }
-  const defaultDir = path5.join(os.homedir(), ".codelantern");
-  if (!fs4.existsSync(defaultDir)) {
-    try {
-      fs4.mkdirSync(defaultDir, { recursive: true });
-    } catch {
+  registerBuiltins() {
+    const builtins = [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      listDirectoryTool,
+      fileSearchTool,
+      grepSearchTool,
+      projectTreeTool,
+      runCommandTool,
+      gitStatusTool,
+      gitDiffTool,
+      webSearchTool
+    ];
+    for (const tool of builtins) {
+      this.tools.set(tool.definition.name, tool);
     }
   }
-  return defaultDir;
-}
-function getConfigFilePath() {
-  return path5.join(getLanternHomeDir(), "config.json");
-}
-function loadConfig() {
-  const configPath = getConfigFilePath();
-  if (!fs4.existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
+  registerTool(tool) {
+    this.tools.set(tool.definition.name, tool);
   }
-  try {
-    const raw = fs4.readFileSync(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    const merged = {
-      ...DEFAULT_CONFIG,
-      ...parsed
-    };
-    if (!merged.mcpServers || typeof merged.mcpServers !== "object") {
-      merged.mcpServers = {};
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.tools.set(tool.definition.name, tool);
     }
-    return merged;
-  } catch {
-    return { ...DEFAULT_CONFIG };
   }
-}
-function saveConfig(config) {
-  const configPath = getConfigFilePath();
-  const safeConfig = {
-    defaultModel: config.defaultModel || DEFAULT_CONFIG.defaultModel,
-    maxSteps: config.maxSteps || DEFAULT_CONFIG.maxSteps,
-    temperature: config.temperature ?? DEFAULT_CONFIG.temperature,
-    maxOutputTokens: config.maxOutputTokens || DEFAULT_CONFIG.maxOutputTokens,
-    yolo: Boolean(config.yolo),
-    theme: config.theme || DEFAULT_CONFIG.theme,
-    autoCompactThreshold: config.autoCompactThreshold || DEFAULT_CONFIG.autoCompactThreshold,
-    timeoutMs: config.timeoutMs || DEFAULT_CONFIG.timeoutMs,
-    mcpServers: config.mcpServers || {}
-  };
-  try {
-    fs4.writeFileSync(configPath, JSON.stringify(safeConfig, null, 2), {
-      encoding: "utf8"
-    });
-  } catch (err) {
-    console.error(`Warning: Failed to save config to ${configPath}: ${err.message}`);
+  getTool(name) {
+    return this.tools.get(name);
   }
-}
-function setConfigValue(key, value) {
-  const validation = validateConfigValue(key, value);
-  if (!validation.valid) {
-    return { success: false, error: validation.error };
+  getDefinitions(planMode = false) {
+    const defs = [];
+    for (const tool of this.tools.values()) {
+      if (planMode && !tool.definition.readOnly) {
+        continue;
+      }
+      defs.push(tool.definition);
+    }
+    return defs;
   }
-  const current = loadConfig();
-  current[key] = validation.parsedValue;
-  saveConfig(current);
-  return { success: true, updatedConfig: current };
-}
-function getConfigValue(key) {
-  const current = loadConfig();
-  return current[key];
-}
+  async executeTool(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        success: false,
+        output: `Error: Unknown tool "${name}". Available tools: ${Array.from(this.tools.keys()).join(", ")}`,
+        error: "Tool not found"
+      };
+    }
+    if (context.planMode && !tool.definition.readOnly) {
+      return {
+        success: false,
+        output: `Plan mode is active (read-only). Action "${name}" was blocked.`,
+        error: "Plan mode read-only restriction"
+      };
+    }
+    try {
+      return await tool.execute(args, context);
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error executing tool "${name}": ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
 
 // src/mcp/mcpConfig.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function getMcpConfigPath() {
-  return path6.join(getLanternHomeDir(), "mcp.json");
+  return path7.join(getLanternHomeDir(), "mcp.json");
 }
 function loadMcpConfig() {
   const filePath = getMcpConfigPath();
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     return {};
   }
   try {
-    const raw = fs5.readFileSync(filePath, "utf8");
+    const raw = fs6.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
       return parsed.mcpServers || parsed;
@@ -1630,7 +3085,7 @@ function saveMcpConfig(servers) {
   const filePath = getMcpConfigPath();
   const data = { mcpServers: servers };
   try {
-    fs5.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf8" });
+    fs6.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf8" });
   } catch (err) {
     console.error(`Warning: Failed to save MCP config: ${err.message}`);
   }
@@ -1890,8 +3345,8 @@ var ApprovalEngine = class {
 };
 
 // src/config/projectInstructions.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 var INSTRUCTION_FILES = [
   "LANTERN.md",
   "CODELANTERN.md",
@@ -1902,12 +3357,12 @@ var INSTRUCTION_FILES = [
 ];
 function loadProjectInstructions(workspaceDir) {
   for (const filename of INSTRUCTION_FILES) {
-    const filePath = path7.join(workspaceDir, filename);
-    if (fs6.existsSync(filePath)) {
+    const filePath = path8.join(workspaceDir, filename);
+    if (fs7.existsSync(filePath)) {
       try {
-        const stat = fs6.statSync(filePath);
+        const stat = fs7.statSync(filePath);
         if (stat.isFile() && stat.size <= 200 * 1024) {
-          const content = fs6.readFileSync(filePath, "utf8").trim();
+          const content = fs7.readFileSync(filePath, "utf8").trim();
           if (content.length > 0) {
             return {
               found: true,
@@ -1924,14 +3379,14 @@ function loadProjectInstructions(workspaceDir) {
 }
 
 // src/session/sessionManager.ts
-import fs7 from "fs";
-import path8 from "path";
-import crypto from "crypto";
+import fs8 from "fs";
+import path9 from "path";
+import crypto2 from "crypto";
 function getSessionsDir() {
-  const dir = path8.join(getLanternHomeDir(), "sessions");
-  if (!fs7.existsSync(dir)) {
+  const dir = path9.join(getLanternHomeDir(), "sessions");
+  if (!fs8.existsSync(dir)) {
     try {
-      fs7.mkdirSync(dir, { recursive: true });
+      fs8.mkdirSync(dir, { recursive: true });
     } catch {
     }
   }
@@ -1939,17 +3394,17 @@ function getSessionsDir() {
 }
 function generateSessionId() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
-  const rand = crypto.randomBytes(3).toString("hex");
+  const rand = crypto2.randomBytes(3).toString("hex");
   return `session_${timestamp}_${rand}`;
 }
 function createNewSession(workspace, model, initialTitle) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     id: generateSessionId(),
-    title: initialTitle || `Session in ${path8.basename(workspace) || "workspace"}`,
+    title: initialTitle || `Session in ${path9.basename(workspace) || "workspace"}`,
     createdAt: now,
     updatedAt: now,
-    workspace: path8.resolve(workspace),
+    workspace: path9.resolve(workspace),
     model,
     turns: [],
     totalUsage: {
@@ -1961,7 +3416,7 @@ function createNewSession(workspace, model, initialTitle) {
 }
 function saveSession(session) {
   const sessionsDir = getSessionsDir();
-  const filePath = path8.join(sessionsDir, `${session.id}.json`);
+  const filePath = path9.join(sessionsDir, `${session.id}.json`);
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const serialized = JSON.stringify(session, (_key, val) => {
     if (typeof val === "string") {
@@ -1970,7 +3425,7 @@ function saveSession(session) {
     return val;
   }, 2);
   try {
-    fs7.writeFileSync(filePath, serialized, { encoding: "utf8" });
+    fs8.writeFileSync(filePath, serialized, { encoding: "utf8" });
   } catch (err) {
     console.error(`Warning: Failed to save session to ${filePath}: ${err.message}`);
   }
@@ -1978,14 +3433,14 @@ function saveSession(session) {
 function loadSession(sessionId) {
   const sessionsDir = getSessionsDir();
   const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.json`;
-  const filePath = path8.join(sessionsDir, normalizedId);
-  if (!fs7.existsSync(filePath)) {
-    if (!fs7.existsSync(sessionsDir)) return null;
-    const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  const filePath = path9.join(sessionsDir, normalizedId);
+  if (!fs8.existsSync(filePath)) {
+    if (!fs8.existsSync(sessionsDir)) return null;
+    const files = fs8.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
     const match = files.find((f) => f.startsWith(sessionId));
     if (match) {
       try {
-        const raw = fs7.readFileSync(path8.join(sessionsDir, match), "utf8");
+        const raw = fs8.readFileSync(path9.join(sessionsDir, match), "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
@@ -1994,7 +3449,7 @@ function loadSession(sessionId) {
     return null;
   }
   try {
-    const raw = fs7.readFileSync(filePath, "utf8");
+    const raw = fs8.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2002,12 +3457,12 @@ function loadSession(sessionId) {
 }
 function listSessions() {
   const sessionsDir = getSessionsDir();
-  if (!fs7.existsSync(sessionsDir)) return [];
-  const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs8.existsSync(sessionsDir)) return [];
+  const files = fs8.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   const sessions = [];
   for (const file of files) {
     try {
-      const raw = fs7.readFileSync(path8.join(sessionsDir, file), "utf8");
+      const raw = fs8.readFileSync(path9.join(sessionsDir, file), "utf8");
       const data = JSON.parse(raw);
       sessions.push({
         id: data.id,
@@ -2025,16 +3480,16 @@ function listSessions() {
 function deleteSession(sessionId) {
   const sessionsDir = getSessionsDir();
   const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.json`;
-  const filePath = path8.join(sessionsDir, normalizedId);
-  if (fs7.existsSync(filePath)) {
-    fs7.unlinkSync(filePath);
+  const filePath = path9.join(sessionsDir, normalizedId);
+  if (fs8.existsSync(filePath)) {
+    fs8.unlinkSync(filePath);
     return true;
   }
-  if (!fs7.existsSync(sessionsDir)) return false;
-  const files = fs7.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+  if (!fs8.existsSync(sessionsDir)) return false;
+  const files = fs8.readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
   const match = files.find((f) => f.startsWith(sessionId));
   if (match) {
-    fs7.unlinkSync(path8.join(sessionsDir, match));
+    fs8.unlinkSync(path9.join(sessionsDir, match));
     return true;
   }
   return false;
@@ -2120,8 +3575,229 @@ ${summaryPoints.join("\n")}`,
   return [compactedTurn, ackTurn, ...toKeep];
 }
 
-// src/agent/orbitAgent.ts
-import path9 from "path";
+// src/skills/skillManager.ts
+import fs9 from "fs";
+import path10 from "path";
+import { execSync } from "child_process";
+var SkillManager = class {
+  userSkillsDir;
+  constructor() {
+    this.userSkillsDir = path10.join(getLanternHomeDir(), "skills");
+    if (!fs9.existsSync(this.userSkillsDir)) {
+      try {
+        fs9.mkdirSync(this.userSkillsDir, { recursive: true });
+      } catch {
+      }
+    }
+  }
+  getUserSkillsDir() {
+    return this.userSkillsDir;
+  }
+  getProjectSkillsDirs(workspace) {
+    return [
+      path10.join(workspace, ".codelantern", "skills"),
+      path10.join(workspace, ".lantern", "skills")
+    ];
+  }
+  /**
+   * Discovers all available skills from user-level and project-level directories
+   */
+  listSkills(workspace = process.cwd()) {
+    const skillsMap = /* @__PURE__ */ new Map();
+    const config = loadConfig();
+    const activeSkillsList = new Set(config.activeSkills || []);
+    this.scanDirectoryForSkills(this.userSkillsDir, "user", skillsMap, activeSkillsList);
+    const projectDirs = this.getProjectSkillsDirs(workspace);
+    for (const pDir of projectDirs) {
+      if (fs9.existsSync(pDir)) {
+        this.scanDirectoryForSkills(pDir, "project", skillsMap, activeSkillsList);
+      }
+    }
+    return Array.from(skillsMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  scanDirectoryForSkills(rootDir, source, map, activeSkillsList) {
+    if (!fs9.existsSync(rootDir)) return;
+    try {
+      const entries = fs9.readdirSync(rootDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillFolder = path10.join(rootDir, entry.name);
+        const skillMdPath = path10.join(skillFolder, "SKILL.md");
+        if (fs9.existsSync(skillMdPath)) {
+          try {
+            const raw = fs9.readFileSync(skillMdPath, "utf8");
+            const { name, description, content } = this.parseSkillMd(raw, entry.name);
+            const references = [];
+            const refsDir = path10.join(skillFolder, "references");
+            if (fs9.existsSync(refsDir)) {
+              try {
+                const refFiles = fs9.readdirSync(refsDir).filter((f) => f.endsWith(".md") || f.endsWith(".txt"));
+                for (const rf of refFiles) {
+                  references.push(path10.join(refsDir, rf));
+                }
+              } catch {
+              }
+            }
+            const isExplicitlyActive = activeSkillsList.has(name);
+            map.set(name, {
+              name,
+              description,
+              path: skillFolder,
+              source,
+              enabled: isExplicitlyActive,
+              content,
+              references
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  parseSkillMd(rawContent, defaultName) {
+    let name = defaultName;
+    let description = "";
+    let content = rawContent.trim();
+    if (rawContent.startsWith("---")) {
+      const endIdx = rawContent.indexOf("---", 3);
+      if (endIdx !== -1) {
+        const frontmatter = rawContent.slice(3, endIdx).trim();
+        content = rawContent.slice(endIdx + 3).trim();
+        const lines = frontmatter.split("\n");
+        for (const line of lines) {
+          const colonIdx = line.indexOf(":");
+          if (colonIdx !== -1) {
+            const key = line.slice(0, colonIdx).trim().toLowerCase();
+            const val = line.slice(colonIdx + 1).trim().replace(/^['"]|['"]$/g, "");
+            if (key === "name" && val) name = val;
+            if (key === "description" && val) description = val;
+          }
+        }
+      }
+    }
+    if (!description) {
+      const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+      description = firstLine ? firstLine.slice(0, 100) : "Custom skill instructions";
+    }
+    return { name, description, content };
+  }
+  getSkill(name, workspace = process.cwd()) {
+    const all = this.listSkills(workspace);
+    return all.find((s) => s.name.toLowerCase() === name.toLowerCase()) || null;
+  }
+  enableSkill(name) {
+    const config = loadConfig();
+    const skills = new Set(config.activeSkills || []);
+    skills.add(name);
+    config.activeSkills = Array.from(skills);
+    saveConfig(config);
+    return true;
+  }
+  disableSkill(name) {
+    const config = loadConfig();
+    const skills = new Set(config.activeSkills || []);
+    const removed = skills.delete(name);
+    config.activeSkills = Array.from(skills);
+    saveConfig(config);
+    return removed;
+  }
+  addSkillFromPath(sourcePath) {
+    const resolved = path10.resolve(sourcePath);
+    if (!fs9.existsSync(resolved)) {
+      return { success: false, error: `Path does not exist: ${sourcePath}` };
+    }
+    const stat = fs9.statSync(resolved);
+    let targetSkillDir = "";
+    let skillName = "";
+    if (stat.isDirectory()) {
+      const skillMd = path10.join(resolved, "SKILL.md");
+      if (!fs9.existsSync(skillMd)) {
+        return { success: false, error: `No SKILL.md found in directory: ${sourcePath}` };
+      }
+      const raw = fs9.readFileSync(skillMd, "utf8");
+      const parsed = this.parseSkillMd(raw, path10.basename(resolved));
+      skillName = parsed.name;
+      targetSkillDir = path10.join(this.userSkillsDir, skillName);
+      fs9.cpSync(resolved, targetSkillDir, { recursive: true });
+    } else if (stat.isFile() && path10.basename(resolved).toLowerCase().endsWith(".md")) {
+      const raw = fs9.readFileSync(resolved, "utf8");
+      skillName = path10.basename(resolved, path10.extname(resolved));
+      const parsed = this.parseSkillMd(raw, skillName);
+      skillName = parsed.name;
+      targetSkillDir = path10.join(this.userSkillsDir, skillName);
+      if (!fs9.existsSync(targetSkillDir)) {
+        fs9.mkdirSync(targetSkillDir, { recursive: true });
+      }
+      fs9.writeFileSync(path10.join(targetSkillDir, "SKILL.md"), raw, "utf8");
+    } else {
+      return { success: false, error: "Source must be a skill folder with SKILL.md or a markdown file." };
+    }
+    this.enableSkill(skillName);
+    return { success: true, skillName };
+  }
+  addSkillFromGit(repoUrl) {
+    try {
+      const tempCloneDir = path10.join(this.userSkillsDir, `_temp_${Date.now()}`);
+      execSync(`git clone --depth 1 "${repoUrl}" "${tempCloneDir}"`, { stdio: "pipe" });
+      const res = this.addSkillFromPath(tempCloneDir);
+      try {
+        fs9.rmSync(tempCloneDir, { recursive: true, force: true });
+      } catch {
+      }
+      return res;
+    } catch (err) {
+      return { success: false, error: `Git clone failed: ${err.message}` };
+    }
+  }
+  removeSkill(name) {
+    this.disableSkill(name);
+    const targetDir = path10.join(this.userSkillsDir, name);
+    if (fs9.existsSync(targetDir)) {
+      try {
+        fs9.rmSync(targetDir, { recursive: true, force: true });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Matches prompt against available skills by keyword and intent.
+   * Transparent and non-intrusive.
+   */
+  matchSkillsForPrompt(userPrompt, workspace = process.cwd()) {
+    const allSkills = this.listSkills(workspace);
+    const matched = [];
+    const promptLower = userPrompt.toLowerCase();
+    for (const skill of allSkills) {
+      if (skill.enabled) {
+        matched.push(skill);
+        continue;
+      }
+      const skillName = skill.name.toLowerCase();
+      const descWords = skill.description.toLowerCase().split(/\W+/).filter((w) => w.length > 3);
+      if (promptLower.includes(skillName)) {
+        matched.push(skill);
+        continue;
+      }
+      let matchCount = 0;
+      for (const word of descWords) {
+        if (promptLower.includes(word)) {
+          matchCount++;
+        }
+      }
+      if (matchCount >= 2) {
+        matched.push(skill);
+      }
+    }
+    return matched;
+  }
+};
+
+// src/agent/lanternAgent.ts
+import path11 from "path";
 import pc5 from "picocolors";
 
 // src/ui/spinner.ts
@@ -2159,9 +3835,26 @@ var TerminalSpinner = class {
     }
     return this;
   }
+  connecting(provider, model) {
+    return this.update(`Connecting to ${pc4.cyan(provider)} (${pc4.bold(model)})...`);
+  }
+  waitingFirstToken(provider, model) {
+    return this.update(`Waiting for first token from ${pc4.cyan(provider)}...`);
+  }
+  receiving(tokensCount) {
+    const suffix = tokensCount ? ` (${tokensCount} tokens)` : "...";
+    return this.update(`Receiving streaming response${suffix}`);
+  }
+  retrying(attempt, maxAttempts, waitMs) {
+    return this.update(`Transient error encountered. Retrying (${attempt}/${maxAttempts}) in ${(waitMs / 1e3).toFixed(1)}s...`);
+  }
+  toolExecuting(toolName, preview) {
+    const detail = preview ? `: ${preview}` : "";
+    return this.update(`Executing tool ${pc4.bold(toolName)}${detail}...`);
+  }
   render() {
     if (!this.isTTY || !this.isRunning) return;
-    const frame = pc4.cyan(SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length]);
+    const frame = pc4.yellow(SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length]);
     this.frameIdx++;
     process.stdout.write(`\r\x1B[2K${frame} ${pc4.dim(this.message)}`);
   }
@@ -2194,20 +3887,28 @@ var TerminalSpinner = class {
   }
 };
 
-// src/agent/orbitAgent.ts
-var OrbitAgent = class {
-  provider;
+// src/agent/lanternAgent.ts
+var LanternAgent = class {
+  providerRegistry;
   tools;
   mcpManager;
+  skillManager;
   approvalEngine;
   spinner;
-  constructor(apiKey) {
-    this.provider = new GeminiProvider(apiKey);
+  constructor() {
+    this.providerRegistry = new ProviderRegistry();
     this.tools = new ToolRegistry();
     this.mcpManager = new McpManager();
+    this.skillManager = new SkillManager();
     this.approvalEngine = new ApprovalEngine({});
     this.spinner = new TerminalSpinner();
   }
+  getProviderRegistry() {
+    return this.providerRegistry;
+  }
+  getSkillManager() {
+    return this.skillManager;
+  }
   async initMcp() {
     try {
       const mcpTools = await this.mcpManager.initialize();
@@ -2218,12 +3919,12 @@ var OrbitAgent = class {
   async shutdown() {
     await this.mcpManager.closeAll();
   }
-  buildSystemPrompt(workspace, planMode = false) {
+  buildSystemPrompt(workspace, planMode = false, activeSkills = []) {
     const projectInstructions = loadProjectInstructions(workspace);
     const basePrompt = [
       "You are Code Lantern, an elite AI coding assistant operating directly in the terminal.",
-      `Current Workspace: ${path9.resolve(workspace)}`,
-      `Environment OS: ${process.platform}`,
+      `Current Workspace: ${path11.resolve(workspace)}`,
+      `Environment OS: ${process.platform} (${process.arch})`,
       "",
       "CORE OPERATING PRINCIPLES:",
       "1. Be direct, pragmatic, and helpful. Prioritize working, robust code over verbosity.",
@@ -2247,20 +3948,50 @@ var OrbitAgent = class {
     if (projectInstructions.found && projectInstructions.content) {
       basePrompt.push(
         "",
-        `PROJECT INSTRUCTIONS (${path9.basename(projectInstructions.filePath || "instructions")}):`,
+        `PROJECT INSTRUCTIONS (${path11.basename(projectInstructions.filePath || "instructions")}):`,
         "---",
         projectInstructions.content,
         "---"
       );
     }
+    if (activeSkills.length > 0) {
+      basePrompt.push("", "ACTIVE SKILLS & GUIDELINES:");
+      for (const skill of activeSkills) {
+        basePrompt.push(
+          `### Skill: ${skill.name}`,
+          `Description: ${skill.description}`,
+          "Instructions:",
+          skill.content,
+          "---"
+        );
+      }
+    }
     return basePrompt.join("\n");
   }
   async runTurn(session, userPrompt, context, attachments = []) {
+    const turnStartTime = Date.now();
     this.approvalEngine = new ApprovalEngine({
       yolo: context.yolo,
       planMode: context.planMode
     });
-    const systemPrompt = this.buildSystemPrompt(context.workspace, context.planMode);
+    const candidateSkills = this.skillManager.matchSkillsForPrompt(userPrompt, context.workspace);
+    const explicitlyRequested = (context.activeSkills || []).map(
+      (name) => this.skillManager.getSkill(name, context.workspace)
+    ).filter((s) => Boolean(s));
+    const combinedSkillsMap = /* @__PURE__ */ new Map();
+    for (const s of [...explicitlyRequested, ...candidateSkills]) {
+      combinedSkillsMap.set(s.name, s);
+    }
+    const activeSkills = Array.from(combinedSkillsMap.values());
+    if (activeSkills.length > 0 && !context.jsonOutput) {
+      const names = activeSkills.map((s) => pc5.yellow(s.name)).join(", ");
+      console.log(pc5.dim(`\u{1F4A1} Active Skills: ${names}`));
+    }
+    session.activeSkills = activeSkills.map((s) => s.name);
+    const provider = this.providerRegistry.getProvider(context.provider);
+    session.provider = provider.id;
+    session.model = context.model;
+    const systemPrompt = this.buildSystemPrompt(context.workspace, context.planMode, activeSkills);
     const activeTools = this.tools.getDefinitions(context.planMode);
     const userTurn = {
       role: "user",
@@ -2278,18 +4009,43 @@ var OrbitAgent = class {
       candidatesTokens: 0,
       totalTokens: 0
     };
+    const aggregatedTiming = {
+      totalMs: 0,
+      toolExecutionMs: {}
+    };
     while (step < maxSteps) {
       step++;
-      this.spinner.start(`Thinking (step ${step}/${maxSteps})...`);
+      if (context.signal?.aborted) {
+        this.spinner.stop();
+        throw context.signal.reason || new Error("Operation cancelled by user.");
+      }
+      this.spinner.start(`Connecting to ${provider.displayName} (${context.model})...`);
       let currentStepText = "";
       let currentToolCalls = [];
       try {
-        const result = await this.provider.streamGenerate(
-          context.model,
-          systemPrompt,
-          session.turns,
-          activeTools,
-          {
+        const streamResult = await provider.streamGenerate({
+          model: context.model,
+          systemInstruction: systemPrompt,
+          history: session.turns,
+          tools: activeTools,
+          signal: context.signal,
+          temperature: 0.2,
+          timeoutMs: context.timeoutMs,
+          firstTokenTimeoutMs: context.firstTokenTimeoutMs,
+          lowLatency: context.lowLatency,
+          callbacks: {
+            onStateChange: (state) => {
+              if (state === "connecting") {
+                this.spinner.connecting(provider.displayName, context.model);
+              } else if (state === "waiting_first_token") {
+                this.spinner.waitingFirstToken(provider.displayName, context.model);
+              } else if (state.startsWith("retrying:")) {
+                const attempt = state.split(":")[1];
+                this.spinner.retrying(parseInt(attempt, 10), 3, 1500);
+              } else if (state === "streaming") {
+                this.spinner.stop();
+              }
+            },
             onChunk: (chunk) => {
               if (currentStepText === "") {
                 this.spinner.stop();
@@ -2308,15 +4064,21 @@ var OrbitAgent = class {
               sessionUsage.totalTokens = usage.totalTokens;
             }
           }
-        );
+        });
         this.spinner.stop();
+        if (streamResult.timing) {
+          aggregatedTiming.providerInitMs = streamResult.timing.providerInitMs;
+          aggregatedTiming.connectMs = streamResult.timing.connectMs;
+          aggregatedTiming.ttftMs = streamResult.timing.ttftMs;
+          aggregatedTiming.streamMs = streamResult.timing.streamMs;
+        }
         if (currentStepText) {
           if (!currentStepText.endsWith("\n")) {
             console.log("");
           }
           finalAssistantText = currentStepText;
         }
-        if (!result.toolCalls || result.toolCalls.length === 0) {
+        if (!streamResult.toolCalls || streamResult.toolCalls.length === 0) {
           session.turns.push({
             role: "model",
             text: currentStepText,
@@ -2327,38 +4089,49 @@ var OrbitAgent = class {
         session.turns.push({
           role: "model",
           text: currentStepText || void 0,
-          toolCalls: result.toolCalls,
+          toolCalls: streamResult.toolCalls,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
         const toolResults = [];
-        for (const call of result.toolCalls) {
+        for (const call of streamResult.toolCalls) {
+          if (context.signal?.aborted) {
+            throw context.signal.reason || new Error("Cancelled by user.");
+          }
           totalToolsExecuted++;
           const callSummary = `${call.name}(${Object.keys(call.args).map((k) => `${k}: ${JSON.stringify(call.args[k])}`).join(", ")})`;
           if (!context.jsonOutput) {
             console.log(pc5.cyan(`
-\u{1F6E0}\uFE0F  Tool: ${pc5.bold(call.name)}`) + pc5.dim(` ${callSummary.slice(0, 100)}`));
+\u{1F6E0}\uFE0F  Tool: ${pc5.bold(call.name)}`) + pc5.dim(` ${callSummary.slice(0, 90)}`));
           }
-          this.spinner.start(`Executing ${call.name}...`);
+          this.spinner.toolExecuting(call.name);
           const toolContext = {
             workspace: context.workspace,
             yolo: this.approvalEngine.isYolo(),
             planMode: context.planMode,
+            signal: context.signal,
             requestApproval: (req) => {
               this.spinner.stop();
               return this.approvalEngine.requestApproval(req);
             }
           };
+          const toolStart = Date.now();
           const executionResult = await this.tools.executeTool(call.name, call.args, toolContext);
+          const toolDuration = Date.now() - toolStart;
+          aggregatedTiming.toolExecutionMs[call.name] = (aggregatedTiming.toolExecutionMs[call.name] || 0) + toolDuration;
           this.spinner.stop();
+          let trimmedOutput = executionResult.output;
+          if (trimmedOutput.length > 15e3) {
+            trimmedOutput = trimmedOutput.slice(0, 15e3) + "\n\n... [Output truncated to 15KB for context efficiency]";
+          }
           if (executionResult.success) {
             if (!context.jsonOutput) {
-              const preview = executionResult.output.length > 200 ? executionResult.output.slice(0, 200) + "..." : executionResult.output;
-              console.log(pc5.green(`\u2713 Result:`) + pc5.dim(` ${preview.replace(/\n/g, " ")}`));
+              const preview = executionResult.output.length > 180 ? executionResult.output.slice(0, 180) + "..." : executionResult.output;
+              console.log(pc5.green(`\u2713 Result:`) + pc5.dim(` ${preview.replace(/\n/g, " ")} (${toolDuration}ms)`));
             }
             toolResults.push({
               callId: call.id,
               name: call.name,
-              result: executionResult.output
+              result: sanitizeSecrets(trimmedOutput)
             });
           } else {
             if (!context.jsonOutput) {
@@ -2392,6 +4165,7 @@ var OrbitAgent = class {
     if (shouldCompact(session.turns)) {
       session.turns = compactTurns(session.turns);
     }
+    aggregatedTiming.totalMs = Date.now() - turnStartTime;
     session.totalUsage.promptTokens += sessionUsage.promptTokens;
     session.totalUsage.candidatesTokens += sessionUsage.candidatesTokens;
     session.totalUsage.totalTokens += sessionUsage.totalTokens;
@@ -2399,14 +4173,15 @@ var OrbitAgent = class {
     return {
       reply: finalAssistantText,
       toolCount: totalToolsExecuted,
-      usage: sessionUsage
+      usage: sessionUsage,
+      timing: aggregatedTiming
     };
   }
 };
 
 // src/provider/attachment.ts
-import fs8 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path12 from "path";
 var MIME_MAP = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -2427,22 +4202,22 @@ var MIME_MAP = {
 var BINARY_IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".pdf"]);
 var MAX_ATTACHMENT_SIZE = 15 * 1024 * 1024;
 function loadAttachment(filePath) {
-  const resolved = path10.resolve(filePath);
-  if (!fs8.existsSync(resolved)) {
+  const resolved = path12.resolve(filePath);
+  if (!fs10.existsSync(resolved)) {
     throw new Error(`Attached file does not exist: ${filePath}`);
   }
-  const stat = fs8.statSync(resolved);
+  const stat = fs10.statSync(resolved);
   if (!stat.isFile()) {
     throw new Error(`Attachment target is not a file: ${filePath}`);
   }
   if (stat.size > MAX_ATTACHMENT_SIZE) {
     throw new Error(`Attachment file too large: ${filePath} (${(stat.size / (1024 * 1024)).toFixed(1)}MB, max 15MB)`);
   }
-  const ext = path10.extname(resolved).toLowerCase();
+  const ext = path12.extname(resolved).toLowerCase();
   const mimeType = MIME_MAP[ext] || "application/octet-stream";
-  const name = path10.basename(resolved);
+  const name = path12.basename(resolved);
   if (BINARY_IMAGE_EXTS.has(ext)) {
-    const buffer = fs8.readFileSync(resolved);
+    const buffer = fs10.readFileSync(resolved);
     return {
       path: resolved,
       name,
@@ -2451,7 +4226,7 @@ function loadAttachment(filePath) {
       base64Data: buffer.toString("base64")
     };
   }
-  const textContent = fs8.readFileSync(resolved, "utf8");
+  const textContent = fs10.readFileSync(resolved, "utf8");
   return {
     path: resolved,
     name,
@@ -2466,18 +4241,17 @@ function loadAttachments(filePaths) {
 }
 
 export {
+  TimeoutError,
+  FirstTokenTimeoutError,
+  CancelledError,
   MissingApiKeyError,
   RateLimitError,
-  GeminiProviderError,
+  AuthenticationError,
+  ModelNotFoundError,
+  LanternProviderError,
   formatErrorMessage,
-  GeminiProvider,
-  isSecretFile,
-  sanitizeSecrets,
-  validateWorkspacePath,
-  formatTerminalDiff,
-  formatNewFilePreview,
-  validateCommand,
-  ToolRegistry,
+  createLinkedAbortController,
+  wrapStreamWithFirstTokenTimeout,
   DEFAULT_CONFIG,
   ALLOWED_CONFIG_KEYS,
   validateConfigValue,
@@ -2487,6 +4261,25 @@ export {
   saveConfig,
   setConfigValue,
   getConfigValue,
+  encryptSecret,
+  decryptSecret,
+  maskApiKey,
+  getApiKey,
+  setApiKey,
+  removeApiKey,
+  listConfiguredKeys,
+  GeminiProvider,
+  OpenAIProvider,
+  AnthropicProvider,
+  OpenRouterProvider,
+  ProviderRegistry,
+  isSecretFile,
+  sanitizeSecrets,
+  validateWorkspacePath,
+  formatTerminalDiff,
+  formatNewFilePreview,
+  validateCommand,
+  ToolRegistry,
   getMcpConfigPath,
   loadMcpConfig,
   saveMcpConfig,
@@ -2506,8 +4299,9 @@ export {
   exportSessionMarkdown,
   shouldCompact,
   compactTurns,
-  OrbitAgent,
+  SkillManager,
+  LanternAgent,
   loadAttachment,
   loadAttachments
 };
-//# sourceMappingURL=chunk-Y3PEOLTZ.js.map
+//# sourceMappingURL=chunk-PELESOCI.js.map