@tractorscorch/clank 1.5.10 → 1.6.0

package/dist/index.js

@@ -841,6 +841,12 @@ var init_agent = __esm({
       autoApprove = { low: true, medium: false, high: false };
       /** Tools the user has approved "always" for this session */
       alwaysApproved = /* @__PURE__ */ new Set();
+      /** Background task registry (if available) */
+      taskRegistry = null;
+      /** Function to spawn background tasks (main agent only) */
+      spawnTaskFn = void 0;
+      /** Session key for this engine (used to consume completed tasks) */
+      sessionKey = "";
       constructor(opts) {
         super();
         this.setMaxListeners(30);
@@ -850,6 +856,9 @@ var init_agent = __esm({
         this.resolvedProvider = opts.provider;
         if (opts.autoApprove) this.autoApprove = opts.autoApprove;
         if (opts.systemPrompt) this.systemPrompt = opts.systemPrompt;
+        if (opts.taskRegistry) this.taskRegistry = opts.taskRegistry;
+        if (opts.spawnTask) this.spawnTaskFn = opts.spawnTask;
+        if (opts.sessionKey) this.sessionKey = opts.sessionKey;
         this.contextEngine = new ContextEngine({
           contextWindow: opts.provider.provider.contextWindow(),
           isLocal: opts.provider.isLocal
@@ -892,6 +901,24 @@ var init_agent = __esm({
         }
         this.abortController = new AbortController();
         const signal = this.abortController.signal;
+        if (this.taskRegistry && this.sessionKey) {
+          const completed = this.taskRegistry.consumeCompleted(this.sessionKey);
+          if (completed.length > 0) {
+            const results = completed.map((t) => {
+              if (t.status === "completed") {
+                return `[Task Complete] "${t.label}" (agent: ${t.agentId}):
+${t.result}`;
+              }
+              return `[Task ${t.status === "failed" ? "Failed" : "Timed Out"}] "${t.label}" (agent: ${t.agentId}): ${t.error || "unknown error"}`;
+            }).join("\n\n");
+            this.contextEngine.ingest({
+              role: "user",
+              content: `[System] Background tasks completed:
+
+${results}`
+            });
+          }
+        }
         this.contextEngine.ingest({ role: "user", content: text });
         if (shouldPersist(text)) {
           const memory = extractMemory(text);
@@ -1047,7 +1074,9 @@ var init_agent = __esm({
                 allowExternal: true,
                 autoApprove: this.autoApprove,
                 agentId: this.identity.id,
-                signal
+                signal,
+                taskRegistry: this.taskRegistry ?? void 0,
+                spawnTask: this.spawnTaskFn
               };
               const validation = tool.validate(tc.arguments, toolCtx);
               if (!validation.ok) {
@@ -2299,8 +2328,8 @@ var init_web_search = __esm({
       async execute(args, ctx) {
         const query = args.query;
         const count = Math.min(Number(args.count) || 5, 20);
-        const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-        const config = await loadConfig3();
+        const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+        const config = await loadConfig2();
         const apiKey = config.tools.webSearch?.apiKey;
         if (!apiKey) {
           return "Error: Brave Search API key not configured. Run `clank setup --section search` or tell me to set it up.";
@@ -3446,6 +3475,19 @@ function createProvider(modelId, config, opts) {
       const p = new GoogleProvider({ apiKey: config.google.apiKey, model });
       return { provider: p, providerName: "google", modelId, isLocal: false };
     }
+    case "openrouter": {
+      const orConfig = config.openrouter ?? config["openrouter"];
+      if (!orConfig?.apiKey) {
+        throw new Error(`OpenRouter API key required for model ${modelId}`);
+      }
+      const p = new OpenAIProvider({
+        apiKey: orConfig.apiKey,
+        baseUrl: orConfig.baseUrl || "https://openrouter.ai/api/v1",
+        model,
+        maxResponseTokens: opts?.maxResponseTokens
+      });
+      return { provider: p, providerName: "openrouter", modelId, isLocal: false };
+    }
     case "lmstudio":
     case "llamacpp":
     case "vllm":
@@ -3585,7 +3627,7 @@ var init_model_tool = __esm({
           properties: {
             action: { type: "string", description: "'list', 'detect', 'set-default', or 'add-provider'" },
             model: { type: "string", description: "Model ID for set-default (e.g., 'ollama/qwen3.5')" },
-            provider: { type: "string", description: "Provider name for add-provider ('anthropic', 'openai', 'google')" },
+            provider: { type: "string", description: "Provider name for add-provider ('anthropic', 'openai', 'google', 'openrouter')" },
             apiKey: { type: "string", description: "API key for add-provider" }
           },
           required: ["action"]
@@ -3633,7 +3675,11 @@ var init_model_tool = __esm({
         if (action === "add-provider") {
           if (!args.provider || !args.apiKey) return "Error: provider and apiKey are required";
           const provider = args.provider;
-          config.models.providers[provider] = { apiKey: args.apiKey };
+          const entry = { apiKey: args.apiKey };
+          if (provider === "openrouter") {
+            entry.baseUrl = "https://openrouter.ai/api/v1";
+          }
+          config.models.providers[provider] = entry;
           await saveConfig(config);
           return `Provider ${provider} added with API key`;
         }
@@ -4521,6 +4567,131 @@ var init_file_share_tool = __esm({
   }
 });
 
+// src/tools/self-config/task-tool.ts
+var taskTool;
+var init_task_tool = __esm({
+  "src/tools/self-config/task-tool.ts"() {
+    "use strict";
+    init_esm_shims();
+    taskTool = {
+      definition: {
+        name: "spawn_task",
+        description: "Spawn a background task on a sub-agent, check task status, or list tasks. Use 'spawn' to start a task that runs independently while you continue chatting. Use 'status' to check a specific task. Use 'list' to see all tasks.",
+        parameters: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              description: "Action: 'spawn' to start a task, 'status' to check one, 'list' to see all"
+            },
+            agentId: {
+              type: "string",
+              description: "Agent ID to run the task (required for spawn). Use 'default' for the default agent."
+            },
+            prompt: {
+              type: "string",
+              description: "The instruction for the sub-agent (required for spawn)"
+            },
+            label: {
+              type: "string",
+              description: "Human-readable task name (optional for spawn)"
+            },
+            taskId: {
+              type: "string",
+              description: "Task ID to check (required for status)"
+            },
+            timeoutMs: {
+              type: "number",
+              description: "Timeout in ms (optional, default 300000 = 5 minutes)"
+            }
+          },
+          required: ["action"]
+        }
+      },
+      safetyLevel: ((args) => {
+        return args.action === "spawn" ? "medium" : "low";
+      }),
+      readOnly: false,
+      validate(args, _ctx) {
+        const action = args.action;
+        if (!["spawn", "status", "list"].includes(action)) {
+          return { ok: false, error: "action must be 'spawn', 'status', or 'list'" };
+        }
+        if (action === "spawn") {
+          if (!args.agentId || typeof args.agentId !== "string") {
+            return { ok: false, error: "agentId is required for spawn" };
+          }
+          if (!args.prompt || typeof args.prompt !== "string") {
+            return { ok: false, error: "prompt is required for spawn" };
+          }
+        }
+        if (action === "status" && (!args.taskId || typeof args.taskId !== "string")) {
+          return { ok: false, error: "taskId is required for status" };
+        }
+        return { ok: true };
+      },
+      async execute(args, ctx) {
+        const action = args.action;
+        switch (action) {
+          case "spawn": {
+            if (!ctx.spawnTask) {
+              return "Error: spawn_task is only available to the main agent. Sub-agents cannot spawn tasks.";
+            }
+            const agentId = args.agentId;
+            const prompt = args.prompt;
+            const label = args.label || prompt.slice(0, 60);
+            const timeoutMs = args.timeoutMs || 3e5;
+            try {
+              const taskId = await ctx.spawnTask({ agentId, prompt, label, timeoutMs });
+              return `Task spawned successfully.
+Task ID: ${taskId}
+Agent: ${agentId}
+Label: ${label}
+Timeout: ${Math.round(timeoutMs / 1e3)}s
+
+The task is running in the background. Results will be delivered when the task completes.`;
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              return `Error spawning task: ${msg}`;
+            }
+          }
+          case "status": {
+            if (!ctx.taskRegistry) return "Error: Task registry not available.";
+            const task = ctx.taskRegistry.get(args.taskId);
+            if (!task) return `No task found with ID: ${args.taskId}`;
+            const elapsed = Math.round((Date.now() - task.startedAt) / 1e3);
+            const lines = [
+              `Task: ${task.label}`,
+              `ID: ${task.id}`,
+              `Agent: ${task.agentId}`,
+              `Model: ${task.model}`,
+              `Status: ${task.status}`,
+              `Elapsed: ${elapsed}s`
+            ];
+            if (task.result) lines.push(`Result: ${task.result.slice(0, 500)}`);
+            if (task.error) lines.push(`Error: ${task.error}`);
+            return lines.join("\n");
+          }
+          case "list": {
+            if (!ctx.taskRegistry) return "Error: Task registry not available.";
+            const tasks = ctx.taskRegistry.list();
+            if (tasks.length === 0) return "No background tasks.";
+            return tasks.map((t) => {
+              const elapsed = Math.round(((t.completedAt || Date.now()) - t.startedAt) / 1e3);
+              return `\u2022 [${t.status}] ${t.label} (agent: ${t.agentId}, ${elapsed}s)`;
+            }).join("\n");
+          }
+          default:
+            return `Unknown action: ${action}`;
+        }
+      },
+      formatConfirmation(args) {
+        return `Spawn background task on agent "${args.agentId}": ${args.prompt?.slice(0, 80)}`;
+      }
+    };
+  }
+});
+
 // src/tools/self-config/index.ts
 function registerSelfConfigTools(registry) {
   registry.register(configTool);
@@ -4535,6 +4706,7 @@ function registerSelfConfigTools(registry) {
   registry.register(sttTool);
   registry.register(voiceListTool);
   registry.register(fileShareTool);
+  registry.register(taskTool);
 }
 var init_self_config = __esm({
   "src/tools/self-config/index.ts"() {
@@ -4550,6 +4722,7 @@ var init_self_config = __esm({
     init_message_tool();
     init_voice_tool();
     init_file_share_tool();
+    init_task_tool();
     init_config_tool();
     init_channel_tool();
     init_agent_tool();
@@ -4560,6 +4733,7 @@ var init_self_config = __esm({
     init_message_tool();
     init_voice_tool();
     init_file_share_tool();
+    init_task_tool();
   }
 });
 
@@ -5190,6 +5364,112 @@ var init_memory2 = __esm({
   }
 });
 
+// src/tasks/registry.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var TaskRegistry;
+var init_registry2 = __esm({
+  "src/tasks/registry.ts"() {
+    "use strict";
+    init_esm_shims();
+    TaskRegistry = class {
+      tasks = /* @__PURE__ */ new Map();
+      cleanupTimer = null;
+      /** Start the cleanup interval */
+      start() {
+        this.cleanupTimer = setInterval(() => this.cleanup(30 * 6e4), 10 * 6e4);
+      }
+      /** Stop the cleanup interval */
+      stop() {
+        if (this.cleanupTimer) {
+          clearInterval(this.cleanupTimer);
+          this.cleanupTimer = null;
+        }
+      }
+      /** Create a new running task */
+      create(opts) {
+        const entry = {
+          id: randomUUID4(),
+          label: opts.label,
+          agentId: opts.agentId,
+          model: opts.model,
+          status: "running",
+          prompt: opts.prompt,
+          startedAt: Date.now(),
+          timeoutMs: opts.timeoutMs,
+          spawnedBy: opts.spawnedBy,
+          delivered: false
+        };
+        this.tasks.set(entry.id, entry);
+        return entry;
+      }
+      /** Update a task's fields */
+      update(id, patch) {
+        const task = this.tasks.get(id);
+        if (task) {
+          Object.assign(task, patch);
+        }
+      }
+      /** Get a specific task */
+      get(id) {
+        return this.tasks.get(id);
+      }
+      /** List all tasks, optionally filtered by status */
+      list(filter) {
+        let results = Array.from(this.tasks.values());
+        if (filter?.status) {
+          results = results.filter((t) => t.status === filter.status);
+        }
+        if (filter?.spawnedBy) {
+          results = results.filter((t) => t.spawnedBy === filter.spawnedBy);
+        }
+        return results.sort((a, b) => b.startedAt - a.startedAt);
+      }
+      /**
+       * Get completed tasks for a session that haven't been delivered yet.
+       * Marks them as delivered so they aren't injected twice.
+       */
+      consumeCompleted(spawnedBy) {
+        const ready = [];
+        for (const task of this.tasks.values()) {
+          if (task.spawnedBy === spawnedBy && task.status !== "running" && !task.delivered) {
+            task.delivered = true;
+            ready.push(task);
+          }
+        }
+        return ready;
+      }
+      /** Remove completed tasks older than maxAgeMs */
+      cleanup(maxAgeMs) {
+        const now = Date.now();
+        for (const [id, task] of this.tasks) {
+          if (task.status !== "running" && task.completedAt && now - task.completedAt > maxAgeMs) {
+            this.tasks.delete(id);
+          }
+        }
+      }
+      /** Cancel all running tasks */
+      cancelAll() {
+        for (const task of this.tasks.values()) {
+          if (task.status === "running") {
+            task.status = "timeout";
+            task.completedAt = Date.now();
+            task.error = "Gateway shutting down";
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/tasks/index.ts
+var init_tasks = __esm({
+  "src/tasks/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_registry2();
+  }
+});
+
 // src/routing/resolve-route.ts
 function resolveRoute(context, bindings, agents2, defaultAgentId) {
   const scored = bindings.map((b) => ({
@@ -5498,8 +5778,8 @@ var init_telegram = __esm({
                 }
                 const audioBuffer = Buffer.from(await res.arrayBuffer());
                 const { STTEngine: STTEngine2 } = await Promise.resolve().then(() => (init_voice(), voice_exports));
-                const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-                const config = await loadConfig3();
+                const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+                const config = await loadConfig2();
                 const stt = new STTEngine2(config);
                 if (!stt.isAvailable()) {
                   await ctx.api.sendMessage(chatId, "Voice messages require speech-to-text. Set up Whisper: /help");
@@ -5668,6 +5948,7 @@ You can read this file with the read_file tool.`
               "/new \u2014 Start a new session",
               "/reset \u2014 Clear current session",
               "/model \u2014 Show current model",
+              "/tasks \u2014 Show background tasks",
               "/think \u2014 Toggle thinking display"
             ].join("\n");
           case "status": {
@@ -5711,6 +5992,14 @@ You can read this file with the read_file tool.`
             const model = this.config?.agents?.defaults?.model?.primary || "unknown";
             return `Current model: \`${model}\``;
           }
+          case "tasks": {
+            const tasks = this.gateway?.getTaskRegistry()?.list() || [];
+            if (tasks.length === 0) return "No background tasks.";
+            return "*Background Tasks:*\n" + tasks.map((t) => {
+              const elapsed = Math.round(((t.completedAt || Date.now()) - t.startedAt) / 1e3);
+              return `\u2022 *${t.label.slice(0, 40)}* (${t.agentId}) \u2014 ${t.status} (${elapsed}s)`;
+            }).join("\n");
+          }
           case "think":
             return "Thinking display toggled. (Note: thinking visibility is per-client in the TUI/Web UI)";
           default:
@@ -6042,6 +6331,7 @@ var init_server = __esm({
     init_memory2();
     init_config2();
     init_cron();
+    init_tasks();
     init_routing();
     init_telegram();
     init_discord();
@@ -6060,6 +6350,7 @@ var init_server = __esm({
       cronScheduler;
       configWatcher;
       pluginLoader;
+      taskRegistry;
       adapters = [];
       running = false;
       /** Rate limiting: track message timestamps per session */
@@ -6076,6 +6367,11 @@ var init_server = __esm({
         this.cronScheduler = new CronScheduler(join14(getConfigDir(), "cron"));
         this.configWatcher = new ConfigWatcher();
         this.pluginLoader = new PluginLoader();
+        this.taskRegistry = new TaskRegistry();
+      }
+      /** Get the task registry (for adapters to list tasks) */
+      getTaskRegistry() {
+        return this.taskRegistry;
       }
       /** Start the gateway server */
       async start() {
@@ -6090,6 +6386,7 @@ var init_server = __esm({
         await this.sessionStore.init();
         await this.memoryManager.init();
         await this.cronScheduler.init();
+        this.taskRegistry.start();
         const plugins = await this.pluginLoader.loadAll();
         for (const tool of this.pluginLoader.getTools()) {
           this.toolRegistry.register(tool);
@@ -6243,6 +6540,8 @@ var init_server = __esm({
       async stop() {
         this.running = false;
         this.cronScheduler.stop();
+        this.taskRegistry.cancelAll();
+        this.taskRegistry.stop();
         this.configWatcher.stop();
         for (const adapter of this.adapters) {
           try {
@@ -6272,7 +6571,7 @@ var init_server = __esm({
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({
             status: "ok",
-            version: "1.5.10",
+            version: "1.6.0",
             uptime: process.uptime(),
             clients: this.clients.size,
             agents: this.engines.size
@@ -6384,7 +6683,7 @@ var init_server = __esm({
         const hello = {
           type: "hello",
           protocol: PROTOCOL_VERSION,
-          version: "1.5.10",
+          version: "1.6.0",
           agents: this.config.agents.list.map((a) => ({
             id: a.id,
             name: a.name || a.id,
@@ -6461,6 +6760,34 @@ var init_server = __esm({
               } : null);
               break;
             }
+            // === Tasks ===
+            case "task.list":
+              this.sendResponse(client, frame.id, true, this.taskRegistry.list().map((t) => ({
+                id: t.id,
+                label: t.label,
+                agentId: t.agentId,
+                model: t.model,
+                status: t.status,
+                startedAt: t.startedAt,
+                completedAt: t.completedAt
+              })));
+              break;
+            case "task.status": {
+              const task = this.taskRegistry.get(frame.params?.taskId);
+              this.sendResponse(client, frame.id, true, task ? {
+                id: task.id,
+                label: task.label,
+                agentId: task.agentId,
+                model: task.model,
+                status: task.status,
+                prompt: task.prompt,
+                result: task.result,
+                error: task.error,
+                startedAt: task.startedAt,
+                completedAt: task.completedAt
+              } : null);
+              break;
+            }
             // === Config ===
             case "config.get": {
               const { redactConfig: redactConfig2 } = await Promise.resolve().then(() => (init_redact(), redact_exports));
@@ -6474,8 +6801,8 @@ var init_server = __esm({
               break;
             }
             case "config.set": {
-              const { loadConfig: loadConfig3, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-              const cfg = await loadConfig3();
+              const { loadConfig: loadConfig2, saveConfig: saveConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+              const cfg = await loadConfig2();
               const key = frame.params?.key;
               const value = frame.params?.value;
               const BLOCKED_KEYS = ["__proto__", "constructor", "prototype"];
@@ -6629,13 +6956,53 @@ var init_server = __esm({
         const memoryBudget = resolved.isLocal ? 1500 : 4e3;
         const memoryBlock = await this.memoryManager.buildMemoryBlock("", identity.workspace, memoryBudget);
         const fullPrompt = memoryBlock ? systemPrompt + "\n\n---\n\n" + memoryBlock : systemPrompt;
+        const isMainAgent = !sessionKey.startsWith("task:") && (agentId === (this.config.agents.list[0]?.id || "default") || agentId === "default");
+        const spawnTaskFn = isMainAgent ? async (opts) => {
+          const subAgentConfig = this.config.agents.list.find((a) => a.id === opts.agentId);
+          const subModel = subAgentConfig?.model?.primary || this.config.agents.defaults.model.primary;
+          const task = this.taskRegistry.create({
+            agentId: opts.agentId,
+            model: subModel,
+            prompt: opts.prompt,
+            label: opts.label,
+            timeoutMs: opts.timeoutMs,
+            spawnedBy: sessionKey
+          });
+          const subSessionKey = `task:${task.id}`;
+          const subEngine = await this.getOrCreateEngine(subSessionKey, opts.agentId, "task");
+          const timeout = setTimeout(() => {
+            subEngine.cancel();
+            this.taskRegistry.update(task.id, { status: "timeout", completedAt: Date.now(), error: "Task timed out" });
+            subEngine.destroy();
+            this.engines.delete(subSessionKey);
+          }, opts.timeoutMs);
+          subEngine.sendMessage(opts.prompt).then((result) => {
+            clearTimeout(timeout);
+            this.taskRegistry.update(task.id, { status: "completed", result, completedAt: Date.now() });
+            subEngine.destroy();
+            this.engines.delete(subSessionKey);
+          }).catch((err) => {
+            clearTimeout(timeout);
+            this.taskRegistry.update(task.id, {
+              status: "failed",
+              error: err instanceof Error ? err.message : String(err),
+              completedAt: Date.now()
+            });
+            subEngine.destroy();
+            this.engines.delete(subSessionKey);
+          });
+          return task.id;
+        } : void 0;
         engine = new AgentEngine({
           identity,
           toolRegistry: this.toolRegistry,
           sessionStore: this.sessionStore,
           provider: resolved,
           autoApprove: this.config.tools.autoApprove,
-          systemPrompt: fullPrompt
+          systemPrompt: fullPrompt,
+          taskRegistry: this.taskRegistry,
+          spawnTask: spawnTaskFn,
+          sessionKey
         });
         await engine.loadSession(sessionKey, channel);
         this.engines.set(sessionKey, engine);
@@ -7115,7 +7482,12 @@ function ask(rl, question) {
 }
 async function runSetup(opts) {
   await ensureConfigDir();
-  const config = defaultConfig();
+  let config;
+  try {
+    config = await loadConfig();
+  } catch {
+    config = defaultConfig();
+  }
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     console.log("");
@@ -7163,41 +7535,78 @@ async function runSetup(opts) {
       console.log(dim4("  Install Ollama (recommended) or configure a cloud provider."));
     }
     console.log("");
-    const addCloud = await ask(rl, cyan2("  Add a cloud provider as fallback? [y/N] "));
+    const existingProviders = [];
+    const providers = config.models.providers;
+    for (const name of ["anthropic", "openai", "google", "openrouter"]) {
+      if (providers[name]?.apiKey) existingProviders.push(name);
+    }
+    if (existingProviders.length > 0) {
+      console.log(dim4(`  Existing cloud providers: ${existingProviders.join(", ")}`));
+    }
+    const addCloud = await ask(rl, cyan2("  Add cloud providers? [y/N] "));
     if (addCloud.toLowerCase() === "y") {
-      console.log(dim4("    1. Anthropic (Claude)"));
-      console.log(dim4("    2. OpenAI (GPT)"));
-      console.log(dim4("    3. Google (Gemini)"));
-      const provider = await ask(rl, cyan2("    Which provider? [1]: "));
-      switch (provider || "1") {
-        case "1": {
-          const key = await ask(rl, cyan2("    Anthropic API key: "));
-          if (key.trim()) {
-            config.models.providers.anthropic = { apiKey: key.trim() };
-            config.agents.defaults.model.fallbacks = ["anthropic/claude-sonnet-4-6"];
-            console.log(green4("    Anthropic configured as fallback"));
+      const fallbacks = config.agents.defaults.model.fallbacks || [];
+      let picking = true;
+      while (picking) {
+        console.log("");
+        console.log("    1. Anthropic (Claude)");
+        console.log("    2. OpenAI (GPT-4o, Codex)");
+        console.log("    3. Google (Gemini)");
+        console.log("    4. OpenRouter (many models via one key)");
+        console.log("    5. Done");
+        const choice = await ask(rl, cyan2("    Which provider? "));
+        const providerSetup = async (name, defaultModel, keyName) => {
+          const existing = providers[name]?.apiKey;
+          if (existing) {
+            const keep = await ask(rl, cyan2(`    ${keyName} already configured. Keep existing? [Y/n] `));
+            if (keep.toLowerCase() !== "n") {
+              console.log(green4(`    Kept existing ${name} config`));
+              if (!fallbacks.includes(defaultModel)) fallbacks.push(defaultModel);
+              return;
+            }
           }
-          break;
-        }
-        case "2": {
-          const key = await ask(rl, cyan2("    OpenAI API key: "));
+          const key = await ask(rl, cyan2(`    ${keyName} API key: `));
           if (key.trim()) {
-            config.models.providers.openai = { apiKey: key.trim() };
-            config.agents.defaults.model.fallbacks = ["openai/gpt-4o"];
-            console.log(green4("    OpenAI configured as fallback"));
+            const entry = { apiKey: key.trim() };
+            if (name === "openrouter") entry.baseUrl = "https://openrouter.ai/api/v1";
+            config.models.providers[name] = entry;
+            if (!fallbacks.includes(defaultModel)) fallbacks.push(defaultModel);
+            console.log(green4(`    ${name} configured`));
           }
-          break;
-        }
-        case "3": {
-          const key = await ask(rl, cyan2("    Google AI API key: "));
-          if (key.trim()) {
-            config.models.providers.google = { apiKey: key.trim() };
-            config.agents.defaults.model.fallbacks = ["google/gemini-2.0-flash"];
-            console.log(green4("    Google configured as fallback"));
+        };
+        switch (choice) {
+          case "1":
+            await providerSetup("anthropic", "anthropic/claude-sonnet-4-6", "Anthropic");
+            break;
+          case "2":
+            await providerSetup("openai", "openai/gpt-4o", "OpenAI");
+            break;
+          case "3":
+            await providerSetup("google", "google/gemini-2.0-flash", "Google");
+            break;
+          case "4": {
+            await providerSetup("openrouter", "openrouter/anthropic/claude-sonnet-4-6", "OpenRouter");
+            if (providers.openrouter?.apiKey) {
+              const orModel = await ask(rl, cyan2("    Default OpenRouter model (e.g., meta-llama/llama-3.1-70b): "));
+              if (orModel.trim()) {
+                const fullModel = `openrouter/${orModel.trim()}`;
+                const idx = fallbacks.indexOf("openrouter/anthropic/claude-sonnet-4-6");
+                if (idx >= 0) fallbacks[idx] = fullModel;
+                else fallbacks.push(fullModel);
+              }
+            }
+            break;
           }
-          break;
+          case "5":
+          case "":
+            picking = false;
+            break;
+          default:
+            console.log(dim4("    Invalid choice"));
+            break;
         }
       }
+      config.agents.defaults.model.fallbacks = fallbacks;
     }
     console.log("");
     console.log(dim4("  Gateway settings:"));
@@ -7780,7 +8189,7 @@ async function runTui(opts) {
   ws.on("open", () => {
     ws.send(JSON.stringify({
       type: "connect",
-      params: { auth: { token }, mode: "tui", version: "1.5.10" }
+      params: { auth: { token }, mode: "tui", version: "1.6.0" }
     }));
   });
   ws.on("message", (data) => {
@@ -8209,7 +8618,7 @@ import { fileURLToPath as fileURLToPath5 } from "url";
 import { dirname as dirname5, join as join19 } from "path";
 var __filename3 = fileURLToPath5(import.meta.url);
 var __dirname3 = dirname5(__filename3);
-var version = "1.5.10";
+var version = "1.6.0";
 try {
   const pkg = JSON.parse(readFileSync(join19(__dirname3, "..", "package.json"), "utf-8"));
   version = pkg.version;
@@ -8292,8 +8701,8 @@ program.command("tui").description("Launch the terminal UI (connects to gateway)
   await runTui2(opts);
 });
 program.command("dashboard").description("Open the Web UI in your browser").option("--no-open", "Don't auto-open browser").action(async (opts) => {
-  const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-  const config = await loadConfig3();
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+  const config = await loadConfig2();
   const port = config.gateway.port || 18789;
   const token = config.gateway.auth.token || "";
   const url = `http://127.0.0.1:${port}/#token=${token}`;
@@ -8358,8 +8767,8 @@ cron.command("remove <id>").description("Remove a cron job").action(async (id) =
   console.log(removed ? `  Job ${id.slice(0, 8)} removed` : `  Job not found`);
 });
 program.command("channels").description("Show channel adapter status").action(async () => {
-  const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-  const config = await loadConfig3();
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+  const config = await loadConfig2();
   const channels = config.channels || {};
   console.log("  Channels:");
   for (const [name, cfg] of Object.entries(channels)) {