codelantern-agent-cli 0.0.0-stage → 1.0.1

package/dist/chunk-PELESOCI.js

@@ -0,0 +1,4307 @@
+#!/usr/bin/env node
+
+// 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 {
+  provider;
+  constructor(provider = "gemini", envVar = "GEMINI_API_KEY") {
+    super(
+      `API key for provider '${provider}' is not configured.
+
+To resolve this:
+  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 = "API rate limit exceeded.") {
+    super(`${message}
+Please wait a moment before trying again or check your account quota.`);
+    this.name = "RateLimitError";
+  }
+};
+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;
+  provider;
+  constructor(message, statusCode, provider) {
+    super(message);
+    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}`);
+  }
+  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)
+      };
+    }
+  }
+  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)
+    }));
+  }
+  async streamGenerate(params) {
+    const key = this.getApiKey();
+    if (!key) {
+      throw new MissingApiKeyError(this.id, `${this.id.toUpperCase()}_API_KEY`);
+    }
+    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 });
+    }
+    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 messages;
+  }
+  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() {
+    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 isSonnet = lower.includes("sonnet");
+    const isOpus = lower.includes("opus");
+    return {
+      streaming: true,
+      tools: true,
+      images: true,
+      reasoning: isSonnet || isOpus,
+      contextWindow: 2e5
+    };
+  }
+  async testConnection() {
+    const key = this.getApiKey();
+    if (!key) {
+      return { success: false, latencyMs: 0, error: "Missing ANTHROPIC_API_KEY" };
+    }
+    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)
+      };
+    }
+  }
+  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(), 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 {
+        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 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 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 (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);
+            }
+          }
+        }
+        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("overloaded") || msg.includes("ECONNRESET") || msg.includes("ETIMEDOUT");
+        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 = [];
+    for (const turn of history) {
+      if (turn.role === "user") {
+        const content = [];
+        if (turn.text) {
+          content.push({ type: "text", text: turn.text });
+        }
+        if (turn.attachments) {
+          for (const att of turn.attachments) {
+            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) {
+              content.push({
+                type: "text",
+                text: `[Attached File: ${att.name}]
+\`\`\`
+${att.textContent}
+\`\`\``
+              });
+            }
+          }
+        }
+        messages.push({ role: "user", content });
+      } else if (turn.role === "model") {
+        const content = [];
+        if (turn.text) {
+          content.push({ type: "text", text: turn.text });
+        }
+        if (turn.toolCalls) {
+          for (const tc of turn.toolCalls) {
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.name,
+              input: tc.args
+            });
+          }
+        }
+        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 { messages, system: systemInstruction || void 0 };
+  }
+  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 {
+            }
+          }
+        }
+      }
+    } 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 path3 from "path";
+var SECRET_FILE_PATTERNS = [
+  /^\.env(\..+)?$/i,
+  /\.pem$/i,
+  /\.key$/i,
+  /\.pfx$/i,
+  /\.p12$/i,
+  /^id_rsa/i,
+  /^id_dsa/i,
+  /^id_ecdsa/i,
+  /^id_ed25519/i,
+  /service[_-]?account.*\.json$/i,
+  /credentials.*\.json$/i,
+  /\.keystore$/i,
+  /\.token$/i,
+  /\.secret/i
+];
+function isSecretFile(filePath) {
+  const base = path3.basename(filePath);
+  return SECRET_FILE_PATTERNS.some((pattern) => pattern.test(base));
+}
+function sanitizeSecrets(text) {
+  if (!text) return text;
+  let sanitized = text;
+  sanitized = sanitized.replace(/AIza[0-9A-Za-z\-_]{30,40}/g, "AIza***********************************");
+  sanitized = sanitized.replace(/ghp_[0-9a-zA-Z]{36}/g, "ghp_************************************");
+  sanitized = sanitized.replace(/github_pat_[0-9a-zA-Z_]{82}/g, "github_pat_**********************************************************************************");
+  const currentKey = process.env.GEMINI_API_KEY;
+  if (currentKey && currentKey.length > 5) {
+    sanitized = sanitized.split(currentKey).join("[REDACTED_GEMINI_API_KEY]");
+  }
+  return sanitized;
+}
+
+// src/security/sandbox.ts
+import path4 from "path";
+import fs3 from "fs";
+var isWindows = process.platform === "win32";
+function normalizeForComparison(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 = path4.relative(normParent, normTarget);
+  return !rel.startsWith("..") && !path4.isAbsolute(rel);
+}
+function validateWorkspacePath(targetPath, workspaceDir, allowedExternalPaths = []) {
+  if (!targetPath || typeof targetPath !== "string") {
+    return {
+      allowed: false,
+      resolvedPath: "",
+      relativePath: "",
+      reason: "Empty or invalid file path provided."
+    };
+  }
+  let normalizedWorkspace = path4.resolve(workspaceDir);
+  try {
+    if (fs3.existsSync(normalizedWorkspace)) {
+      normalizedWorkspace = fs3.realpathSync(normalizedWorkspace);
+    }
+  } catch {
+  }
+  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);
+    return normAllowed === normTarget;
+  });
+  if (isExplicitlyAllowed) {
+    return {
+      allowed: true,
+      resolvedPath: resolvedTarget,
+      relativePath: path4.relative(normalizedWorkspace, resolvedTarget) || path4.basename(resolvedTarget)
+    };
+  }
+  if (!isContainedWithin(normalizedWorkspace, resolvedTarget)) {
+    return {
+      allowed: false,
+      resolvedPath: resolvedTarget,
+      relativePath: path4.relative(normalizedWorkspace, resolvedTarget),
+      reason: `Path '${targetPath}' is outside the authorized workspace: ${normalizedWorkspace}`
+    };
+  }
+  try {
+    if (fs3.existsSync(resolvedTarget)) {
+      const realTarget = fs3.realpathSync(resolvedTarget);
+      if (!isContainedWithin(normalizedWorkspace, realTarget)) {
+        return {
+          allowed: false,
+          resolvedPath: realTarget,
+          relativePath: path4.relative(normalizedWorkspace, realTarget),
+          reason: `Symlink target points outside the workspace: ${realTarget}`
+        };
+      }
+    }
+  } catch {
+  }
+  if (isSecretFile(resolvedTarget)) {
+    return {
+      allowed: false,
+      resolvedPath: resolvedTarget,
+      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: path4.relative(normalizedWorkspace, resolvedTarget) || "."
+  };
+}
+
+// src/approval/diffViewer.ts
+import * as Diff from "diff";
+import pc2 from "picocolors";
+function formatTerminalDiff(filePath, oldContent, newContent, contextLines = 3) {
+  const normalizedOld = oldContent.replace(/\r\n/g, "\n");
+  const normalizedNew = newContent.replace(/\r\n/g, "\n");
+  const patch = Diff.createPatch(filePath, normalizedOld, normalizedNew, "Original", "Modified", {
+    context: contextLines
+  });
+  const lines = patch.split("\n");
+  const formatted = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("---") || line.startsWith("+++")) {
+      formatted.push(pc2.bold(pc2.cyan(line)));
+    } else if (line.startsWith("@@")) {
+      formatted.push(pc2.magenta(line));
+    } else if (line.startsWith("+")) {
+      formatted.push(pc2.green(line));
+    } else if (line.startsWith("-")) {
+      formatted.push(pc2.red(line));
+    } else {
+      formatted.push(pc2.dim(line));
+    }
+  }
+  return formatted.join("\n");
+}
+function formatNewFilePreview(filePath, content, maxPreviewLines = 30) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const preview = lines.slice(0, maxPreviewLines).map((line, idx) => {
+    const lineNum = String(idx + 1).padStart(4, " ");
+    return `${pc2.dim(lineNum)} ${pc2.green("+")} ${pc2.green(line)}`;
+  });
+  if (lines.length > maxPreviewLines) {
+    preview.push(pc2.dim(`    ... and ${lines.length - maxPreviewLines} more lines`));
+  }
+  return [
+    pc2.bold(pc2.cyan(`+++ Create new file: ${filePath} (${lines.length} lines)`)),
+    ...preview
+  ].join("\n");
+}
+
+// src/security/commandGuard.ts
+var DESTRUCTIVE_PATTERNS = [
+  // Unix root/home deletion
+  { regex: /\brm\s+-[rf]{1,2}\s+([/~]|\$HOME|\.\.\/|\.\.\\)/i, reason: "Attempt to delete root, home, or parent directories." },
+  { regex: /\brm\s+-[rf]{1,2}\s+\*\s*$/i, reason: "Attempt to recursively delete everything in directory." },
+  // Unix filesystem destruction
+  { regex: /\bmkfs(\.\w+)?\b/i, reason: "Filesystem format commands are forbidden." },
+  { regex: /\bdd\s+.*of=\/dev\/(r?[shv]d[a-z]|disk|nvme)/i, reason: "Direct disk write commands are forbidden." },
+  { regex: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/, reason: "Fork bombs are strictly blocked." },
+  { regex: /\b(shutdown|reboot|poweroff|init\s+0)\b/i, reason: "System shutdown/reboot commands are forbidden." },
+  { regex: /\bchmod\s+-[rR]\s+777\s+([/~]|\$HOME)/i, reason: "Dangerous permissions modification at root/home." },
+  // Windows destructive commands
+  { regex: /\bformat\s+[a-z]:/i, reason: "Disk format command is forbidden." },
+  { regex: /\b(del|erase)\s+.*\/s.*\/q.*[a-z]:\\/i, reason: "Recursive deletion of root Windows drive is forbidden." },
+  { regex: /\b(rd|rmdir)\s+.*\/s.*\/q.*[a-z]:\\/i, reason: "Recursive removal of root Windows drive is forbidden." },
+  { regex: /\bRemove-Item\s+.*-Recurse\s+.*[a-z]:\\/i, reason: "Recursive PowerShell deletion of drive root is forbidden." }
+];
+function validateCommand(command) {
+  if (!command || command.trim().length === 0) {
+    return { allowed: false, reason: "Empty command string." };
+  }
+  const trimmed = command.trim();
+  for (const check of DESTRUCTIVE_PATTERNS) {
+    if (check.regex.test(trimmed)) {
+      return {
+        allowed: false,
+        reason: `Blocked dangerous command pattern: ${check.reason}`
+      };
+    }
+  }
+  const isPublishOrPush = /\b(npm\s+publish|git\s+push|docker\s+push)\b/i.test(trimmed);
+  return {
+    allowed: true,
+    isHighRisk: isPublishOrPush
+  };
+}
+
+// src/tools/fsTools.ts
+import fs4 from "fs";
+import path5 from "path";
+var readFileTool = {
+  definition: {
+    name: "read_file",
+    description: "Read the contents of a text file inside the workspace. Optionally specify a line range.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to read within the workspace."
+        },
+        start_line: {
+          type: "integer",
+          description: "Optional 1-indexed start line number to read from."
+        },
+        end_line: {
+          type: "integer",
+          description: "Optional 1-indexed end line number to read until (inclusive)."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs4.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Error: File not found at '${validation.relativePath}'`,
+        error: "File not found"
+      };
+    }
+    const stat = fs4.statSync(validation.resolvedPath);
+    if (!stat.isFile()) {
+      return {
+        success: false,
+        output: `Error: Path is a directory, not a file: '${validation.relativePath}'`,
+        error: "Path is a directory"
+      };
+    }
+    if (stat.size > 1024 * 1024) {
+      return {
+        success: false,
+        output: `Error: File is too large to read entirely (${(stat.size / 1024).toFixed(0)}KB). Please specify start_line and end_line.`,
+        error: "File too large"
+      };
+    }
+    try {
+      const content = fs4.readFileSync(validation.resolvedPath, "utf8");
+      const lines = content.split("\n");
+      const totalLines = lines.length;
+      let start = 1;
+      let end = totalLines;
+      if (typeof args.start_line === "number" && args.start_line > 0) {
+        start = Math.max(1, Math.min(args.start_line, totalLines));
+      }
+      if (typeof args.end_line === "number" && args.end_line >= start) {
+        end = Math.min(args.end_line, totalLines);
+      }
+      const selectedLines = lines.slice(start - 1, end);
+      const numberedLines = selectedLines.map((line, idx) => {
+        const lineNum = String(start + idx).padStart(4, " ");
+        return `${lineNum} | ${line}`;
+      });
+      const output = [
+        `File: ${validation.relativePath} (${start}-${end} of ${totalLines} lines)`,
+        "```",
+        ...numberedLines,
+        "```"
+      ].join("\n");
+      return {
+        success: true,
+        output,
+        metadata: {
+          path: validation.relativePath,
+          startLine: start,
+          endLine: end,
+          totalLines
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error reading file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var writeFileTool = {
+  definition: {
+    name: "write_file",
+    description: "Create a new file or completely overwrite an existing file with the provided content.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to create or overwrite."
+        },
+        content: {
+          type: "string",
+          description: "The complete text content to write to the file."
+        }
+      },
+      required: ["path", "content"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const content = String(args.content ?? "");
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    const fileExists = fs4.existsSync(validation.resolvedPath);
+    let oldContent = "";
+    if (fileExists) {
+      try {
+        oldContent = fs4.readFileSync(validation.resolvedPath, "utf8");
+      } catch {
+        oldContent = "";
+      }
+    }
+    const approved = await context.requestApproval({
+      type: "file_write",
+      summary: fileExists ? `Overwrite existing file: ${validation.relativePath}` : `Create new file: ${validation.relativePath}`,
+      details: {
+        path: validation.relativePath,
+        before: oldContent,
+        after: content,
+        diff: fileExists ? formatTerminalDiff(validation.relativePath, oldContent, content) : formatNewFilePreview(validation.relativePath, content)
+      }
+    });
+    if (!approved) {
+      return {
+        success: false,
+        output: `Write rejected: User declined approval to write '${validation.relativePath}'.`,
+        error: "Approval rejected"
+      };
+    }
+    try {
+      const parentDir = path5.dirname(validation.resolvedPath);
+      if (!fs4.existsSync(parentDir)) {
+        fs4.mkdirSync(parentDir, { recursive: true });
+      }
+      fs4.writeFileSync(validation.resolvedPath, content, "utf8");
+      const lines = content.split("\n").length;
+      return {
+        success: true,
+        output: `Successfully wrote ${lines} lines to ${validation.relativePath}`,
+        metadata: { path: validation.relativePath, lines }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to write file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var editFileTool = {
+  definition: {
+    name: "edit_file",
+    description: "Propose and apply a focused edit by replacing exact existing text with new replacement text.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of the file to edit."
+        },
+        target: {
+          type: "string",
+          description: "The exact string in the file to be replaced. Must match character-for-character including indentation."
+        },
+        replacement: {
+          type: "string",
+          description: "The replacement string to insert in place of target."
+        }
+      },
+      required: ["path", "target", "replacement"]
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    const target = String(args.target ?? "");
+    const replacement = String(args.replacement ?? "");
+    const validation = validateWorkspacePath(rawPath, context.workspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs4.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Error: File not found at '${validation.relativePath}'`,
+        error: "File not found"
+      };
+    }
+    try {
+      const original = fs4.readFileSync(validation.resolvedPath, "utf8");
+      const hasCrlf = original.includes("\r\n");
+      let matchedTarget = target;
+      if (!original.includes(target)) {
+        if (hasCrlf && !target.includes("\r\n")) {
+          const crlfTarget = target.replace(/\n/g, "\r\n");
+          if (original.includes(crlfTarget)) {
+            matchedTarget = crlfTarget;
+          }
+        } else if (!hasCrlf && target.includes("\r\n")) {
+          const lfTarget = target.replace(/\r\n/g, "\n");
+          if (original.includes(lfTarget)) {
+            matchedTarget = lfTarget;
+          }
+        }
+      }
+      if (!original.includes(matchedTarget)) {
+        return {
+          success: false,
+          output: `Error: Target string not found in ${validation.relativePath}. Please verify whitespace, indentation, or read the file again to confirm line contents.`,
+          error: "Target string not found"
+        };
+      }
+      const occurrences = original.split(matchedTarget).length - 1;
+      if (occurrences > 1) {
+        return {
+          success: false,
+          output: `Warning: Target string appears ${occurrences} times in ${validation.relativePath}. Please provide more surrounding context in 'target' to make the match unique.`,
+          error: "Target string ambiguous"
+        };
+      }
+      const matchedReplacement = hasCrlf && !replacement.includes("\r\n") ? replacement.replace(/\n/g, "\r\n") : replacement;
+      const updated = original.replace(matchedTarget, matchedReplacement);
+      const approved = await context.requestApproval({
+        type: "file_edit",
+        summary: `Edit file: ${validation.relativePath}`,
+        details: {
+          path: validation.relativePath,
+          before: original,
+          after: updated,
+          diff: formatTerminalDiff(validation.relativePath, original, updated)
+        }
+      });
+      if (!approved) {
+        return {
+          success: false,
+          output: `Edit rejected: User declined approval to edit '${validation.relativePath}'.`,
+          error: "Approval rejected"
+        };
+      }
+      fs4.writeFileSync(validation.resolvedPath, updated, "utf8");
+      return {
+        success: true,
+        output: `Successfully applied edit to ${validation.relativePath}`,
+        metadata: { path: validation.relativePath }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Failed to edit file: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/tools/searchTools.ts
+import fs5 from "fs";
+import path6 from "path";
+import fg from "fast-glob";
+import ignore from "ignore";
+var DEFAULT_IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  ".codelantern",
+  ".lantern",
+  ".orbit",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".next",
+  ".cache",
+  ".gemini",
+  ".vscode",
+  ".idea"
+];
+function getWorkspaceIgnore(workspaceDir) {
+  const ig = ignore();
+  ig.add(DEFAULT_IGNORED_DIRS);
+  const gitignorePath = path6.join(workspaceDir, ".gitignore");
+  if (fs5.existsSync(gitignorePath)) {
+    try {
+      const gitignoreContent = fs5.readFileSync(gitignorePath, "utf8");
+      ig.add(gitignoreContent);
+    } catch {
+    }
+  }
+  return ig;
+}
+var listDirectoryTool = {
+  definition: {
+    name: "list_directory",
+    description: "List the contents of a directory in the workspace, respecting ignore rules.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Relative path of directory to inspect. Omit or pass empty for workspace root."
+        },
+        depth: {
+          type: "integer",
+          description: "Maximum depth of recursion (default 1, max 4)."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const rawPath = String(args.path || "").trim();
+    let realWorkspace = path6.resolve(context.workspace);
+    try {
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
+    } catch {
+    }
+    const validation = validateWorkspacePath(rawPath || ".", realWorkspace);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        output: `Error: Access denied. ${validation.reason}`,
+        error: validation.reason
+      };
+    }
+    if (!fs5.existsSync(validation.resolvedPath)) {
+      return {
+        success: false,
+        output: `Directory not found: ${validation.relativePath || "."}`,
+        error: "Not found"
+      };
+    }
+    const maxDepth = Math.min(Math.max(1, Number(args.depth) || 1), 4);
+    const ig = getWorkspaceIgnore(realWorkspace);
+    try {
+      let walk2 = function(currentDir, currentDepth) {
+        if (currentDepth > maxDepth) return;
+        const entries = fs5.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          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;
+          }
+          const prefix = "  ".repeat(currentDepth - 1);
+          if (entry.isDirectory()) {
+            results.push(`${prefix}\u{1F4C1} ${entry.name}/`);
+            walk2(fullPath, currentDepth + 1);
+          } else {
+            results.push(`${prefix}\u{1F4C4} ${entry.name}`);
+          }
+        }
+      };
+      var walk = walk2;
+      const results = [];
+      walk2(validation.resolvedPath, 1);
+      return {
+        success: true,
+        output: results.length > 0 ? results.join("\n") : "(empty directory)",
+        metadata: { count: results.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error listing directory: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var fileSearchTool = {
+  definition: {
+    name: "file_search",
+    description: "Find files matching a glob pattern or partial filename across the project workspace.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Glob pattern (e.g. "**/*.ts", "src/**/*.json", "*config*").'
+        },
+        directory: {
+          type: "string",
+          description: "Subdirectory to search inside. Defaults to workspace root."
+        }
+      },
+      required: ["pattern"]
+    }
+  },
+  async execute(args, context) {
+    const rawPattern = String(args.pattern || "").trim();
+    if (!rawPattern) {
+      return { success: false, output: "Pattern parameter is required.", error: "Missing pattern" };
+    }
+    let realWorkspace = path6.resolve(context.workspace);
+    try {
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
+    } catch {
+    }
+    const subDir = String(args.directory || "").trim();
+    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 };
+    }
+    try {
+      const normalizedSearchRoot = searchRoot.replace(/\\/g, "/");
+      const normalizedPattern = rawPattern.replace(/\\/g, "/");
+      const globPattern = normalizedPattern.includes("/") ? normalizedPattern : `**/*${normalizedPattern}*`;
+      const matches = await fg(globPattern, {
+        cwd: normalizedSearchRoot,
+        dot: false,
+        ignore: DEFAULT_IGNORED_DIRS.map((d) => `**/${d}/**`),
+        onlyFiles: true
+      });
+      const ig = getWorkspaceIgnore(realWorkspace);
+      const filtered = matches.filter((m) => {
+        const full = path6.join(searchRoot, m);
+        const rel = path6.relative(realWorkspace, full).replace(/\\/g, "/");
+        return !ig.ignores(rel);
+      });
+      if (filtered.length === 0) {
+        return {
+          success: true,
+          output: `No files found matching '${rawPattern}' in ${subDir || "workspace"}.`
+        };
+      }
+      return {
+        success: true,
+        output: filtered.slice(0, 100).join("\n") + (filtered.length > 100 ? `
+... and ${filtered.length - 100} more matches` : ""),
+        metadata: { total: filtered.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error during file search: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var grepSearchTool = {
+  definition: {
+    name: "grep_search",
+    description: "Search for text or regex patterns within project files.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search string or regular expression to search for."
+        },
+        path_pattern: {
+          type: "string",
+          description: 'Optional glob pattern to restrict files searched (e.g. "*.ts", "src/**/*.js").'
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async execute(args, context) {
+    const query = String(args.query || "").trim();
+    if (!query) {
+      return { success: false, output: "Query parameter is required.", error: "Missing query" };
+    }
+    let realWorkspace = path6.resolve(context.workspace);
+    try {
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
+    } catch {
+    }
+    const pathPattern = args.path_pattern ? String(args.path_pattern).replace(/\\/g, "/") : "**/*";
+    try {
+      const normalizedCwd = realWorkspace.replace(/\\/g, "/");
+      const files = await fg(pathPattern, {
+        cwd: normalizedCwd,
+        dot: false,
+        ignore: DEFAULT_IGNORED_DIRS.map((d) => `**/${d}/**`),
+        onlyFiles: true
+      });
+      const ig = getWorkspaceIgnore(realWorkspace);
+      const matchingLines = [];
+      const regex = new RegExp(query, "i");
+      for (const relFile of files) {
+        const normalizedRel = relFile.replace(/\\/g, "/");
+        if (ig.ignores(normalizedRel)) continue;
+        if (relFile.endsWith(".map") || relFile.endsWith(".min.js") || relFile.endsWith(".lock")) continue;
+        const fullPath = path6.join(realWorkspace, relFile);
+        try {
+          const stat = fs5.statSync(fullPath);
+          if (stat.size > 500 * 1024) continue;
+          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])) {
+              matchingLines.push(`${normalizedRel}:${i + 1}: ${lines[i].trim()}`);
+              if (matchingLines.length >= 100) break;
+            }
+          }
+        } catch {
+        }
+        if (matchingLines.length >= 100) break;
+      }
+      if (matchingLines.length === 0) {
+        return {
+          success: true,
+          output: `No occurrences found for "${query}".`
+        };
+      }
+      return {
+        success: true,
+        output: matchingLines.join("\n") + (matchingLines.length >= 100 ? "\n(Search truncated to first 100 matches)" : ""),
+        metadata: { matchCount: matchingLines.length }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error executing grep search: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+var projectTreeTool = {
+  definition: {
+    name: "project_tree",
+    description: "Display an ASCII tree visualization of the project structure.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "Optional subfolder to show tree for. Defaults to workspace root."
+        },
+        max_depth: {
+          type: "integer",
+          description: "Maximum depth (default 3, max 5)."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const rawDir = String(args.directory || "").trim();
+    let realWorkspace = path6.resolve(context.workspace);
+    try {
+      if (fs5.existsSync(realWorkspace)) realWorkspace = fs5.realpathSync(realWorkspace);
+    } catch {
+    }
+    const validation = validateWorkspacePath(rawDir || ".", realWorkspace);
+    if (!validation.allowed) {
+      return { success: false, output: `Access denied: ${validation.reason}`, error: validation.reason };
+    }
+    const maxDepth = Math.min(Math.max(1, Number(args.max_depth) || 3), 5);
+    const ig = getWorkspaceIgnore(realWorkspace);
+    try {
+      let buildTree2 = function(currentDir, prefix, depth) {
+        if (depth > maxDepth) return;
+        let entries = [];
+        try {
+          entries = fs5.readdirSync(currentDir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        const validEntries = entries.filter((e) => {
+          if (DEFAULT_IGNORED_DIRS.includes(e.name)) return false;
+          const full = path6.join(currentDir, e.name);
+          const rel = path6.relative(realWorkspace, full).replace(/\\/g, "/");
+          return !ig.ignores(rel);
+        });
+        validEntries.sort((a, b) => {
+          if (a.isDirectory() && !b.isDirectory()) return -1;
+          if (!a.isDirectory() && b.isDirectory()) return 1;
+          return a.name.localeCompare(b.name);
+        });
+        validEntries.forEach((entry, idx) => {
+          const isLast = idx === validEntries.length - 1;
+          const pointer = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          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);
+          }
+        });
+      };
+      var buildTree = buildTree2;
+      const lines = [path6.basename(validation.resolvedPath) || "."];
+      buildTree2(validation.resolvedPath, "", 1);
+      return {
+        success: true,
+        output: lines.join("\n")
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Error building tree: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/tools/bashTool.ts
+import { exec } from "child_process";
+var runCommandTool = {
+  definition: {
+    name: "run_command",
+    description: "Execute a terminal shell command inside the project workspace directory.",
+    readOnly: false,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: 'The shell command to execute (e.g. "npm test", "git status", "dir").'
+        },
+        timeout_ms: {
+          type: "integer",
+          description: "Optional execution timeout in milliseconds (default 30000)."
+        }
+      },
+      required: ["command"]
+    }
+  },
+  async execute(args, context) {
+    const command = String(args.command || "").trim();
+    if (!command) {
+      return { success: false, output: "Command argument is required.", error: "Missing command" };
+    }
+    const guard = validateCommand(command);
+    if (!guard.allowed) {
+      return {
+        success: false,
+        output: `Command blocked by security guard: ${guard.reason}`,
+        error: guard.reason
+      };
+    }
+    const approved = await context.requestApproval({
+      type: "command",
+      summary: `Execute command: ${command}`,
+      details: {
+        command
+      }
+    });
+    if (!approved) {
+      return {
+        success: false,
+        output: `Command execution cancelled: User declined approval for '${command}'.`,
+        error: "Approval rejected"
+      };
+    }
+    const timeout = Math.min(Math.max(1e3, Number(args.timeout_ms) || 3e4), 12e4);
+    const startTime = Date.now();
+    return new Promise((resolve) => {
+      exec(
+        command,
+        {
+          cwd: context.workspace,
+          timeout,
+          maxBuffer: 5 * 1024 * 1024,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            CI: "true"
+          }
+        },
+        (error, stdout, stderr) => {
+          const duration = Date.now() - startTime;
+          const exitCode = error && typeof error.code === "number" ? error.code : error ? 1 : 0;
+          let rawOutput = "";
+          if (stdout) rawOutput += stdout;
+          if (stderr) {
+            if (rawOutput) rawOutput += "\n--- stderr ---\n";
+            rawOutput += stderr;
+          }
+          if (!rawOutput) {
+            rawOutput = "(no output)";
+          }
+          const normalized = rawOutput.replace(/\r\n/g, "\n");
+          const cleanOutput = sanitizeSecrets(normalized.trim());
+          const formattedOutput = [
+            `Command: ${command}`,
+            `Exit code: ${exitCode}`,
+            `Duration: ${duration}ms`,
+            "Output:",
+            cleanOutput
+          ].join("\n");
+          resolve({
+            success: exitCode === 0,
+            output: formattedOutput,
+            error: error ? error.message : void 0,
+            metadata: { exitCode, duration }
+          });
+        }
+      );
+    });
+  }
+};
+
+// src/tools/gitTools.ts
+import { exec as exec2 } from "child_process";
+var gitStatusTool = {
+  definition: {
+    name: "git_status",
+    description: "Get current Git working tree status (branch, modified, untracked files).",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {}
+    }
+  },
+  async execute(_args, context) {
+    return new Promise((resolve) => {
+      exec2("git status --short --branch", { cwd: context.workspace, timeout: 1e4 }, (error, stdout, stderr) => {
+        if (error) {
+          return resolve({
+            success: false,
+            output: stderr.includes("not a git repository") ? "Workspace is not a Git repository." : `Git status error: ${error.message}`,
+            error: error.message
+          });
+        }
+        const out = stdout.trim() || "Working tree clean. Nothing to commit.";
+        resolve({
+          success: true,
+          output: out
+        });
+      });
+    });
+  }
+};
+var gitDiffTool = {
+  definition: {
+    name: "git_diff",
+    description: "Inspect git diff of unstaged or staged changes in the workspace repository.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        staged: {
+          type: "boolean",
+          description: "If true, shows diff of staged changes (--staged). Defaults to false."
+        }
+      }
+    }
+  },
+  async execute(args, context) {
+    const cmd = args.staged ? "git diff --staged" : "git diff";
+    return new Promise((resolve) => {
+      exec2(cmd, { cwd: context.workspace, timeout: 15e3, maxBuffer: 5 * 1024 * 1024 }, (error, stdout, stderr) => {
+        if (error) {
+          return resolve({
+            success: false,
+            output: `Git diff error: ${error.message}`,
+            error: error.message
+          });
+        }
+        const out = stdout.trim();
+        if (!out) {
+          return resolve({
+            success: true,
+            output: args.staged ? "No staged changes." : "No unstaged working tree changes."
+          });
+        }
+        const truncated = out.length > 5e4 ? out.slice(0, 5e4) + "\n\n[Diff truncated: exceeded 50KB]" : out;
+        resolve({
+          success: true,
+          output: truncated
+        });
+      });
+    });
+  }
+};
+
+// src/tools/webSearchTool.ts
+var webSearchTool = {
+  definition: {
+    name: "web_search",
+    description: "Search the web for up-to-date documentation, libraries, or error troubleshooting solutions.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search terms or question to look up."
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async execute(args) {
+    const query = String(args.query || "").trim();
+    if (!query) {
+      return { success: false, output: "Missing query argument.", error: "Missing query" };
+    }
+    try {
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 8e3);
+      const res = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko)"
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        return {
+          success: true,
+          output: `Search for "${query}" completed with status ${res.status}. No immediate text parsed.`
+        };
+      }
+      const html = await res.text();
+      const snippets = [];
+      const regex = /<a class="result__snippet[^>]*>([\s\S]*?)<\/a>/gi;
+      let match;
+      while ((match = regex.exec(html)) !== null && snippets.length < 5) {
+        const text = match[1].replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+        if (text) {
+          snippets.push(`- ${text}`);
+        }
+      }
+      if (snippets.length === 0) {
+        return {
+          success: true,
+          output: `Web search executed for "${query}". Found related topics, but snippets were condensed.`
+        };
+      }
+      return {
+        success: true,
+        output: `Search results for "${query}":
+
+${snippets.join("\n\n")}`,
+        metadata: { resultCount: snippets.length }
+      };
+    } catch (err) {
+      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/mcp/mcpConfig.ts
+import fs6 from "fs";
+import path7 from "path";
+function getMcpConfigPath() {
+  return path7.join(getLanternHomeDir(), "mcp.json");
+}
+function loadMcpConfig() {
+  const filePath = getMcpConfigPath();
+  if (!fs6.existsSync(filePath)) {
+    return {};
+  }
+  try {
+    const raw = fs6.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed.mcpServers || parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function saveMcpConfig(servers) {
+  const filePath = getMcpConfigPath();
+  const data = { mcpServers: servers };
+  try {
+    fs6.writeFileSync(filePath, JSON.stringify(data, null, 2), { encoding: "utf8" });
+  } catch (err) {
+    console.error(`Warning: Failed to save MCP config: ${err.message}`);
+  }
+}
+function addMcpServer(name, config) {
+  const current = loadMcpConfig();
+  current[name] = config;
+  saveMcpConfig(current);
+}
+function removeMcpServer(name) {
+  const current = loadMcpConfig();
+  if (current[name]) {
+    delete current[name];
+    saveMcpConfig(current);
+    return true;
+  }
+  return false;
+}
+function toggleMcpServer(name, disabled) {
+  const current = loadMcpConfig();
+  if (current[name]) {
+    current[name].disabled = disabled;
+    saveMcpConfig(current);
+    return true;
+  }
+  return false;
+}
+
+// src/mcp/mcpManager.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var McpManager = class {
+  connections = /* @__PURE__ */ new Map();
+  async initialize() {
+    const servers = loadMcpConfig();
+    const allTools = [];
+    for (const [serverName, config] of Object.entries(servers)) {
+      if (config.disabled) {
+        continue;
+      }
+      try {
+        const tools = await this.connectServer(serverName, config);
+        allTools.push(...tools);
+      } catch (err) {
+        console.error(`Warning: Failed to connect MCP server '${serverName}': ${err.message}`);
+      }
+    }
+    return allTools;
+  }
+  async connectServer(serverName, config) {
+    if (this.connections.has(serverName)) {
+      await this.disconnectServer(serverName);
+    }
+    const safeEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (typeof v === "string") safeEnv[k] = v;
+    }
+    if (config.env) {
+      Object.assign(safeEnv, config.env);
+    }
+    const transport = new StdioClientTransport({
+      command: config.command,
+      args: config.args || [],
+      env: safeEnv
+    });
+    const client = new Client(
+      {
+        name: `orbit-client-${serverName}`,
+        version: "1.0.0"
+      },
+      {
+        capabilities: {}
+      }
+    );
+    await client.connect(transport);
+    const toolsResponse = await client.listTools();
+    const serverTools = [];
+    for (const mcpTool of toolsResponse.tools) {
+      const toolName = `mcp__${serverName}__${mcpTool.name}`.replace(/[^a-zA-Z0-9_]/g, "_");
+      const properties = {};
+      const required = [];
+      if (mcpTool.inputSchema && typeof mcpTool.inputSchema === "object") {
+        const schema = mcpTool.inputSchema;
+        if (schema.properties && typeof schema.properties === "object") {
+          for (const [k, v] of Object.entries(schema.properties)) {
+            properties[k] = {
+              type: v.type || "string",
+              description: v.description || ""
+            };
+          }
+        }
+        if (Array.isArray(schema.required)) {
+          required.push(...schema.required);
+        }
+      }
+      const definition = {
+        name: toolName,
+        description: `[MCP Server: ${serverName}] ${mcpTool.description || mcpTool.name}`,
+        readOnly: false,
+        parameters: {
+          type: "object",
+          properties,
+          required
+        }
+      };
+      const orbitTool = {
+        definition,
+        async execute(args, context) {
+          const approved = await context.requestApproval({
+            type: "command",
+            summary: `Run MCP tool ${serverName}:${mcpTool.name}`,
+            details: {
+              command: `mcp ${serverName} ${mcpTool.name} ${JSON.stringify(args)}`
+            }
+          });
+          if (!approved) {
+            return {
+              success: false,
+              output: `Execution denied by user for MCP tool ${serverName}:${mcpTool.name}`,
+              error: "Approval rejected"
+            };
+          }
+          try {
+            const result = await client.callTool({
+              name: mcpTool.name,
+              arguments: args
+            });
+            let textOutput = "";
+            if (Array.isArray(result.content)) {
+              for (const item of result.content) {
+                if (item.type === "text") {
+                  textOutput += item.text + "\n";
+                } else {
+                  textOutput += JSON.stringify(item) + "\n";
+                }
+              }
+            } else {
+              textOutput = JSON.stringify(result.content);
+            }
+            return {
+              success: !result.isError,
+              output: textOutput.trim(),
+              error: result.isError ? textOutput : void 0
+            };
+          } catch (err) {
+            return {
+              success: false,
+              output: `MCP execution error: ${err.message}`,
+              error: err.message
+            };
+          }
+        }
+      };
+      serverTools.push(orbitTool);
+    }
+    this.connections.set(serverName, {
+      name: serverName,
+      client,
+      transport,
+      tools: serverTools
+    });
+    return serverTools;
+  }
+  async disconnectServer(serverName) {
+    const conn = this.connections.get(serverName);
+    if (conn) {
+      try {
+        await conn.client.close();
+      } catch {
+      }
+      this.connections.delete(serverName);
+    }
+  }
+  async closeAll() {
+    for (const [serverName] of this.connections) {
+      await this.disconnectServer(serverName);
+    }
+  }
+};
+
+// src/approval/approver.ts
+import readline from "readline";
+import pc3 from "picocolors";
+var ApprovalEngine = class {
+  yolo;
+  planMode;
+  constructor(options) {
+    this.yolo = Boolean(options.yolo);
+    this.planMode = Boolean(options.planMode);
+  }
+  isYolo() {
+    return this.yolo;
+  }
+  setYolo(val) {
+    this.yolo = val;
+  }
+  isPlanMode() {
+    return this.planMode;
+  }
+  async requestApproval(req) {
+    if (this.planMode) {
+      console.log(pc3.yellow(`
+[Plan Mode] Tool action skipped (read-only): ${req.summary}`));
+      return false;
+    }
+    if (this.yolo) {
+      console.log(pc3.dim(`\u26A1 [YOLO] Auto-approved: ${req.summary}`));
+      return true;
+    }
+    console.log("\n" + pc3.bold(pc3.yellow("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501 Action Approval Required \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")));
+    console.log(pc3.bold("Action: ") + req.summary);
+    if (req.type === "file_edit" && req.details?.before !== void 0 && req.details?.after !== void 0) {
+      const diffOutput = req.details.diff || formatTerminalDiff(
+        req.details.path || "file",
+        req.details.before,
+        req.details.after
+      );
+      console.log("\n" + diffOutput + "\n");
+    } else if (req.type === "file_write" && req.details?.after !== void 0) {
+      const preview = formatNewFilePreview(req.details.path || "file", req.details.after);
+      console.log("\n" + preview + "\n");
+    } else if (req.type === "command" && req.details?.command) {
+      console.log(pc3.cyan(`$ ${pc3.bold(req.details.command)}
+`));
+    }
+    const answer = await this.promptUser(
+      pc3.bold(pc3.yellow("Approve this action?")) + " [y/N / (a)ll-yolo]: "
+    );
+    const clean = answer.trim().toLowerCase();
+    if (clean === "a" || clean === "all" || clean === "yolo") {
+      this.yolo = true;
+      console.log(pc3.yellow("\u26A1 YOLO mode enabled for remainder of session.\n"));
+      return true;
+    }
+    if (clean === "y" || clean === "yes") {
+      console.log(pc3.green("\u2713 Approved.\n"));
+      return true;
+    }
+    console.log(pc3.red("\u2717 Denied by user.\n"));
+    return false;
+  }
+  promptUser(question) {
+    if (!process.stdin.isTTY) {
+      return Promise.resolve("no");
+    }
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+};
+
+// src/config/projectInstructions.ts
+import fs7 from "fs";
+import path8 from "path";
+var INSTRUCTION_FILES = [
+  "LANTERN.md",
+  "CODELANTERN.md",
+  ".codelantern/instructions.md",
+  ".lantern.md",
+  "GEMINI.md",
+  "ORBIT.md"
+];
+function loadProjectInstructions(workspaceDir) {
+  for (const filename of INSTRUCTION_FILES) {
+    const filePath = path8.join(workspaceDir, filename);
+    if (fs7.existsSync(filePath)) {
+      try {
+        const stat = fs7.statSync(filePath);
+        if (stat.isFile() && stat.size <= 200 * 1024) {
+          const content = fs7.readFileSync(filePath, "utf8").trim();
+          if (content.length > 0) {
+            return {
+              found: true,
+              filePath,
+              content
+            };
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return { found: false };
+}
+
+// src/session/sessionManager.ts
+import fs8 from "fs";
+import path9 from "path";
+import crypto2 from "crypto";
+function getSessionsDir() {
+  const dir = path9.join(getLanternHomeDir(), "sessions");
+  if (!fs8.existsSync(dir)) {
+    try {
+      fs8.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+  }
+  return dir;
+}
+function generateSessionId() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14);
+  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 ${path9.basename(workspace) || "workspace"}`,
+    createdAt: now,
+    updatedAt: now,
+    workspace: path9.resolve(workspace),
+    model,
+    turns: [],
+    totalUsage: {
+      promptTokens: 0,
+      candidatesTokens: 0,
+      totalTokens: 0
+    }
+  };
+}
+function saveSession(session) {
+  const sessionsDir = getSessionsDir();
+  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") {
+      return sanitizeSecrets(val);
+    }
+    return val;
+  }, 2);
+  try {
+    fs8.writeFileSync(filePath, serialized, { encoding: "utf8" });
+  } catch (err) {
+    console.error(`Warning: Failed to save session to ${filePath}: ${err.message}`);
+  }
+}
+function loadSession(sessionId) {
+  const sessionsDir = getSessionsDir();
+  const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.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 = fs8.readFileSync(path9.join(sessionsDir, match), "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  try {
+    const raw = fs8.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listSessions() {
+  const sessionsDir = getSessionsDir();
+  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 = fs8.readFileSync(path9.join(sessionsDir, file), "utf8");
+      const data = JSON.parse(raw);
+      sessions.push({
+        id: data.id,
+        title: data.title || "Untitled Session",
+        updatedAt: data.updatedAt || data.createdAt,
+        turnCount: data.turns?.length || 0,
+        workspace: data.workspace || "",
+        model: data.model || ""
+      });
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+}
+function deleteSession(sessionId) {
+  const sessionsDir = getSessionsDir();
+  const normalizedId = sessionId.endsWith(".json") ? sessionId : `${sessionId}.json`;
+  const filePath = path9.join(sessionsDir, normalizedId);
+  if (fs8.existsSync(filePath)) {
+    fs8.unlinkSync(filePath);
+    return true;
+  }
+  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) {
+    fs8.unlinkSync(path9.join(sessionsDir, match));
+    return true;
+  }
+  return false;
+}
+function exportSessionMarkdown(session) {
+  const lines = [
+    `# Code Lantern Session: ${session.title}`,
+    `**Session ID:** \`${session.id}\`  `,
+    `**Model:** \`${session.model}\`  `,
+    `**Workspace:** \`${session.workspace}\`  `,
+    `**Created:** ${session.createdAt}  `,
+    `**Updated:** ${session.updatedAt}  `,
+    `**Total Tokens:** ${session.totalUsage.totalTokens}  `,
+    "",
+    "---",
+    ""
+  ];
+  for (const turn of session.turns) {
+    const roleHeading = turn.role === "user" ? "### \u{1F464} User" : turn.role === "model" ? "### \u{1F3EE} Code Lantern" : "### \u{1F6E0}\uFE0F Tool";
+    lines.push(roleHeading);
+    lines.push(`*${turn.timestamp}*`);
+    lines.push("");
+    if (turn.text) {
+      lines.push(turn.text);
+      lines.push("");
+    }
+    if (turn.toolCalls && turn.toolCalls.length > 0) {
+      lines.push("**Tool Calls:**");
+      for (const call of turn.toolCalls) {
+        lines.push(`- \`${call.name}\`: \`${JSON.stringify(call.args)}\``);
+      }
+      lines.push("");
+    }
+    if (turn.toolResults && turn.toolResults.length > 0) {
+      lines.push("**Tool Results:**");
+      for (const res of turn.toolResults) {
+        const preview = typeof res.result === "string" ? res.result.slice(0, 200) : JSON.stringify(res.result).slice(0, 200);
+        lines.push(`- \`${res.name}\`: ${preview}...`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/session/compactor.ts
+function shouldCompact(turns, threshold = 30) {
+  return turns.length > threshold;
+}
+function compactTurns(turns, retainRecentCount = 10) {
+  if (turns.length <= retainRecentCount + 2) {
+    return turns;
+  }
+  const toCompact = turns.slice(0, turns.length - retainRecentCount);
+  const toKeep = turns.slice(turns.length - retainRecentCount);
+  const summaryPoints = [];
+  for (const turn of toCompact) {
+    if (turn.role === "user" && turn.text) {
+      summaryPoints.push(`- User asked: "${turn.text.slice(0, 150).replace(/\n/g, " ")}"`);
+    } else if (turn.role === "model") {
+      if (turn.toolCalls && turn.toolCalls.length > 0) {
+        const toolNames = turn.toolCalls.map((t) => t.name).join(", ");
+        summaryPoints.push(`- Orbit executed tools: ${toolNames}`);
+      }
+      if (turn.text) {
+        summaryPoints.push(`- Orbit responded: "${turn.text.slice(0, 120).replace(/\n/g, " ")}..."`);
+      }
+    }
+  }
+  const compactedTurn = {
+    role: "user",
+    text: `[SYSTEM: Earlier conversation context compacted (${toCompact.length} turns)]:
+${summaryPoints.join("\n")}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const ackTurn = {
+    role: "model",
+    text: "Understood. I retain full awareness of these previous tasks and will continue from here.",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return [compactedTurn, ackTurn, ...toKeep];
+}
+
+// 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
+import pc4 from "picocolors";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var TerminalSpinner = class {
+  timer = null;
+  frameIdx = 0;
+  message = "";
+  isTTY = Boolean(process.stdout.isTTY);
+  isRunning = false;
+  start(message) {
+    this.message = message;
+    this.isRunning = true;
+    if (!this.isTTY) {
+      console.log(`[Lantern] ${message}`);
+      return this;
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    process.stdout.write("\x1B[?25l");
+    this.timer = setInterval(() => {
+      this.render();
+    }, 80);
+    this.render();
+    return this;
+  }
+  update(message) {
+    this.message = message;
+    if (!this.isTTY) {
+      console.log(`[Lantern] ${message}`);
+    } else if (this.isRunning) {
+      this.render();
+    }
+    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.yellow(SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length]);
+    this.frameIdx++;
+    process.stdout.write(`\r\x1B[2K${frame} ${pc4.dim(this.message)}`);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+    if (this.isTTY) {
+      process.stdout.write("\r\x1B[2K");
+      process.stdout.write("\x1B[?25h");
+    }
+    return this;
+  }
+  succeed(message) {
+    this.stop();
+    console.log(`${pc4.green("\u2713")} ${message}`);
+    return this;
+  }
+  fail(message) {
+    this.stop();
+    console.log(`${pc4.red("\u2717")} ${message}`);
+    return this;
+  }
+  info(message) {
+    this.stop();
+    console.log(`${pc4.cyan("\u2139")} ${message}`);
+    return this;
+  }
+};
+
+// src/agent/lanternAgent.ts
+var LanternAgent = class {
+  providerRegistry;
+  tools;
+  mcpManager;
+  skillManager;
+  approvalEngine;
+  spinner;
+  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();
+      this.tools.registerTools(mcpTools);
+    } catch {
+    }
+  }
+  async shutdown() {
+    await this.mcpManager.closeAll();
+  }
+  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: ${path11.resolve(workspace)}`,
+      `Environment OS: ${process.platform} (${process.arch})`,
+      "",
+      "CORE OPERATING PRINCIPLES:",
+      "1. Be direct, pragmatic, and helpful. Prioritize working, robust code over verbosity.",
+      "2. Inspect files before proposing edits to understand real project conventions and existing code.",
+      "3. Always use the provided tools to read, search, edit, create files, or run commands.",
+      "4. When editing files with edit_file, ensure the target string matches exactly, including indentation.",
+      "5. Safety boundaries: Never attempt to read secret files (.env, keys) or escape the workspace.",
+      "6. Never run destructive commands that wipe unrelated data, partitions, or system drives.",
+      "7. Never push code, make commits, or publish artifacts unless explicitly instructed by the user."
+    ];
+    if (planMode) {
+      basePrompt.push(
+        "",
+        "PLAN MODE IS ACTIVE (READ-ONLY):",
+        "- Your objective is to thoroughly inspect the codebase and produce a detailed, actionable implementation plan.",
+        "- You may inspect files and search code using read_file, file_search, grep_search, and project_tree.",
+        "- Do NOT attempt to write files, edit files, or run mutating commands.",
+        "- Structure your plan clearly: Overview, Architecture & Files Impacted, Step-by-Step Implementation, and Verification Strategy."
+      );
+    }
+    if (projectInstructions.found && projectInstructions.content) {
+      basePrompt.push(
+        "",
+        `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 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",
+      text: userPrompt,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    session.turns.push(userTurn);
+    let step = 0;
+    const maxSteps = context.maxSteps || 25;
+    let totalToolsExecuted = 0;
+    let finalAssistantText = "";
+    const sessionUsage = {
+      promptTokens: 0,
+      candidatesTokens: 0,
+      totalTokens: 0
+    };
+    const aggregatedTiming = {
+      totalMs: 0,
+      toolExecutionMs: {}
+    };
+    while (step < maxSteps) {
+      step++;
+      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 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();
+              }
+              currentStepText += chunk;
+              if (!context.jsonOutput) {
+                process.stdout.write(chunk);
+              }
+            },
+            onToolCalls: (calls) => {
+              currentToolCalls = calls;
+            },
+            onUsage: (usage) => {
+              sessionUsage.promptTokens = usage.promptTokens;
+              sessionUsage.candidatesTokens = usage.candidatesTokens;
+              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 (!streamResult.toolCalls || streamResult.toolCalls.length === 0) {
+          session.turns.push({
+            role: "model",
+            text: currentStepText,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          break;
+        }
+        session.turns.push({
+          role: "model",
+          text: currentStepText || void 0,
+          toolCalls: streamResult.toolCalls,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const toolResults = [];
+        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, 90)}`));
+          }
+          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 > 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: sanitizeSecrets(trimmedOutput)
+            });
+          } else {
+            if (!context.jsonOutput) {
+              console.log(pc5.red(`\u2717 Error: ${executionResult.error || executionResult.output}`));
+            }
+            toolResults.push({
+              callId: call.id,
+              name: call.name,
+              result: { error: executionResult.error || executionResult.output },
+              error: executionResult.error
+            });
+          }
+        }
+        session.turns.push({
+          role: "tool",
+          toolResults,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (step >= maxSteps) {
+          const limitMsg = `
+[Reached maximum configured tool steps (${maxSteps}). Code Lantern paused to avoid infinite loops.]`;
+          console.log(pc5.yellow(limitMsg));
+          finalAssistantText += limitMsg;
+          break;
+        }
+      } catch (err) {
+        this.spinner.stop();
+        throw err;
+      }
+    }
+    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;
+    saveSession(session);
+    return {
+      reply: finalAssistantText,
+      toolCount: totalToolsExecuted,
+      usage: sessionUsage,
+      timing: aggregatedTiming
+    };
+  }
+};
+
+// src/provider/attachment.ts
+import fs10 from "fs";
+import path12 from "path";
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".ts": "text/plain",
+  ".js": "text/plain",
+  ".py": "text/plain",
+  ".sh": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css"
+};
+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 = path12.resolve(filePath);
+  if (!fs10.existsSync(resolved)) {
+    throw new Error(`Attached file does not exist: ${filePath}`);
+  }
+  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 = path12.extname(resolved).toLowerCase();
+  const mimeType = MIME_MAP[ext] || "application/octet-stream";
+  const name = path12.basename(resolved);
+  if (BINARY_IMAGE_EXTS.has(ext)) {
+    const buffer = fs10.readFileSync(resolved);
+    return {
+      path: resolved,
+      name,
+      mimeType,
+      size: stat.size,
+      base64Data: buffer.toString("base64")
+    };
+  }
+  const textContent = fs10.readFileSync(resolved, "utf8");
+  return {
+    path: resolved,
+    name,
+    mimeType: mimeType.startsWith("text/") ? mimeType : "text/plain",
+    size: stat.size,
+    textContent
+  };
+}
+function loadAttachments(filePaths) {
+  if (!filePaths || filePaths.length === 0) return [];
+  return filePaths.map((p) => loadAttachment(p));
+}
+
+export {
+  TimeoutError,
+  FirstTokenTimeoutError,
+  CancelledError,
+  MissingApiKeyError,
+  RateLimitError,
+  AuthenticationError,
+  ModelNotFoundError,
+  LanternProviderError,
+  formatErrorMessage,
+  createLinkedAbortController,
+  wrapStreamWithFirstTokenTimeout,
+  DEFAULT_CONFIG,
+  ALLOWED_CONFIG_KEYS,
+  validateConfigValue,
+  getLanternHomeDir,
+  getConfigFilePath,
+  loadConfig,
+  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,
+  addMcpServer,
+  removeMcpServer,
+  toggleMcpServer,
+  McpManager,
+  ApprovalEngine,
+  loadProjectInstructions,
+  getSessionsDir,
+  generateSessionId,
+  createNewSession,
+  saveSession,
+  loadSession,
+  listSessions,
+  deleteSession,
+  exportSessionMarkdown,
+  shouldCompact,
+  compactTurns,
+  SkillManager,
+  LanternAgent,
+  loadAttachment,
+  loadAttachments
+};
+//# sourceMappingURL=chunk-PELESOCI.js.map