swarmlancer-cli 0.3.0 → 0.4.0

package/dist/app.d.ts

@@ -1,4 +1 @@
-/**
- * Main entry point for interactive TUI mode.
- */
 export declare function runInteractive(): Promise<void>;

package/dist/app.js

@@ -1,7 +1,8 @@
 import { ProcessTerminal, TUI, Container } from "@mariozechner/pi-tui";
 import { getConfig, getAgents, getAgent, saveAgent, deleteAgent, createAgent, migrateLegacyAgent, } from "./config.js";
 import { login } from "./login.js";
-import { initInference, getAvailableModels, setAgentInstructions, getAuthenticatedProviders } from "./inference.js";
+import { setActiveModel, setAgentInstructions } from "./inference.js";
+import { resolveModel, getAvailableModels, isProviderAuthenticated, saveProviderKey, PROVIDERS, } from "./providers.js";
 import { startAgent, stopAgent, sendToServer } from "./agent.js";
 import { colors } from "./theme.js";
 import { BannerComponent } from "./screens/banner.js";
@@ -20,19 +21,12 @@ import { MessageScreen } from "./screens/message.js";
 import { screenProfiles } from "./screening.js";
 let terminal;
 let tui;
-let detectedModel;
-/**
- * Switch the active screen by replacing the TUI's child + focus.
- */
 function setScreen(component) {
     tui.clear();
     tui.addChild(component);
     tui.setFocus(component);
     tui.requestRender(true);
 }
-/**
- * Show a temporary message and wait for any key.
- */
 function showMessage(title, lines, style = "info") {
     return new Promise((resolve) => {
         const screen = new MessageScreen(tui, title, lines, style);
@@ -40,15 +34,11 @@ function showMessage(title, lines, style = "info") {
         setScreen(screen);
     });
 }
-/**
- * Run the setup wizard: check auth, model, agents.
- */
+// ── Setup ─────────────────────────────────────────────────
 async function runSetup() {
-    // Migrate legacy single-agent setup
     migrateLegacyAgent();
     const banner = new BannerComponent();
     const wizard = new SetupWizardScreen(tui);
-    // Show banner + wizard together
     const wrapper = new Container();
     wrapper.addChild(banner);
     wrapper.addChild(wizard);
@@ -72,45 +62,43 @@ async function runSetup() {
             wizard.setStep(0, "failed", err instanceof Error ? err.message : "login failed");
         }
     }
-    // Step 2: Model
-    wizard.setStep(1, "running", "detecting pi credentials...");
-    try {
-        const { model } = await initInference();
-        detectedModel = model;
-        wizard.setStep(1, "done", `${model.provider}/${model.id}`);
-    }
-    catch (err) {
-        wizard.setStep(1, "failed", err instanceof Error ? err.message : "no models found");
-    }
-    // Step 3: Agents
-    wizard.setStep(2, "running");
+    // Step 2: Agents
+    wizard.setStep(1, "running");
     const agents = getAgents();
     if (agents.length > 0) {
-        wizard.setStep(2, "done", `${agents.length} agent${agents.length === 1 ? "" : "s"}`);
+        wizard.setStep(1, "done", `${agents.length} agent${agents.length === 1 ? "" : "s"}`);
     }
     else {
-        wizard.setStep(2, "skipped", "no agents yet");
+        wizard.setStep(1, "skipped", "no agents yet");
         const shouldCreate = await wizard.askConfirm("You have no agents. Create one now?");
         if (shouldCreate) {
             const name = await askName("New Agent Name", "Give your first agent a name.");
             if (name) {
                 createAgent(name);
-                wizard.setStep(2, "done", "1 agent created");
+                wizard.setStep(1, "done", "1 agent created");
             }
             else {
-                wizard.setStep(2, "skipped", "skipped");
+                wizard.setStep(1, "skipped", "skipped");
             }
-            // Re-show the wizard
             tui.clear();
             tui.addChild(wrapper);
             tui.setFocus(wizard);
             tui.requestRender(true);
         }
     }
-    // Short pause then go to dashboard
+    // Step 3: Providers
+    wizard.setStep(2, "running");
+    const models = getAvailableModels();
+    if (models.length > 0) {
+        const providers = [...new Set(models.map((m) => m.provider))];
+        wizard.setStep(2, "done", providers.join(", "));
+    }
+    else {
+        wizard.setStep(2, "skipped", "no API keys — add in Swarm → Providers");
+    }
     await new Promise((r) => setTimeout(r, 800));
 }
-// ── Sub-screens that return promises ──────────────────────
+// ── Sub-screens ───────────────────────────────────────────
 function askName(title, subtitle, current = "") {
     return new Promise((resolve) => {
         const screen = new NameEditorScreen(tui, current, title, subtitle);
@@ -123,14 +111,9 @@ function editInstructions(agent) {
     return new Promise((resolve) => {
         const screen = new AgentEditorScreen(tui, agent.instructions);
         screen.onSave = async (newContent) => {
-            try {
-                agent.instructions = newContent;
-                saveAgent(agent);
-                await showMessage("Saved", ["Agent instructions updated."], "success");
-            }
-            catch (err) {
-                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
-            }
+            agent.instructions = newContent;
+            saveAgent(agent);
+            await showMessage("Saved", ["Agent instructions updated."], "success");
             resolve();
         };
         screen.onCancel = () => resolve();
@@ -141,14 +124,9 @@ function editLimits(agent) {
     return new Promise((resolve) => {
         const screen = new SettingsScreen(tui, agent.limits);
         screen.onSave = async (newLimits) => {
-            try {
-                agent.limits = newLimits;
-                saveAgent(agent);
-                await showMessage("Saved", ["Agent limits updated."], "success");
-            }
-            catch (err) {
-                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
-            }
+            agent.limits = newLimits;
+            saveAgent(agent);
+            await showMessage("Saved", ["Agent limits updated."], "success");
             resolve();
         };
         screen.onCancel = () => resolve();
@@ -159,14 +137,9 @@ function editDiscovery(agent) {
     return new Promise((resolve) => {
         const screen = new DiscoverySettingsScreen(tui, agent.discovery);
         screen.onSave = async (newSettings) => {
-            try {
-                agent.discovery = newSettings;
-                saveAgent(agent);
-                await showMessage("Saved", ["Discovery settings updated."], "success");
-            }
-            catch (err) {
-                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
-            }
+            agent.discovery = newSettings;
+            saveAgent(agent);
+            await showMessage("Saved", ["Discovery settings updated."], "success");
             resolve();
         };
         screen.onCancel = () => resolve();
@@ -175,28 +148,21 @@ function editDiscovery(agent) {
 }
 function editModel(agent) {
     return new Promise(async (resolve) => {
-        try {
-            await initInference();
-            const models = await getAvailableModels();
-            if (models.length === 0) {
-                await showMessage("No models", ["No models available.", "Select a provider to authenticate."], "error");
-                resolve();
-                return;
-            }
-            const screen = new ModelPickerScreen(tui, models);
-            screen.onSelect = async (model) => {
-                agent.modelPattern = model.id;
-                saveAgent(agent);
-                await showMessage("Model selected", [`${model.provider}/${model.id}`], "success");
-                resolve();
-            };
-            screen.onCancel = () => resolve();
-            setScreen(screen);
-        }
-        catch (err) {
-            await showMessage("Error", [err instanceof Error ? err.message : "Failed to load models"], "error");
+        const models = getAvailableModels();
+        if (models.length === 0) {
+            await showMessage("No models", ["No provider API keys configured.", "Add one in Swarm → Providers."], "error");
             resolve();
+            return;
         }
+        const screen = new ModelPickerScreen(tui, models);
+        screen.onSelect = async (model) => {
+            agent.modelPattern = `${model.provider}/${model.id}`;
+            saveAgent(agent);
+            await showMessage("Model selected", [`${model.provider}/${model.id}`], "success");
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
     });
 }
 function askSessionGoal() {
@@ -212,9 +178,8 @@ function pickAgent() {
     if (agents.length === 0) {
         return showMessage("No agents", ["Create an agent first."], "error").then(() => null);
     }
-    if (agents.length === 1) {
+    if (agents.length === 1)
         return Promise.resolve(agents[0]);
-    }
     return new Promise((resolve) => {
         const screen = new AgentPickerScreen(tui, agents);
         screen.onSelect = (agent) => resolve(agent);
@@ -222,7 +187,25 @@ function pickAgent() {
         setScreen(screen);
     });
 }
-// ── Agent config sub-menu ─────────────────────────────────
+// ── Provider login ────────────────────────────────────────
+async function handleProviderLogin(providerId) {
+    const provider = PROVIDERS.find((p) => p.id === providerId);
+    if (!provider)
+        return;
+    if (!provider.keyBased) {
+        await showMessage("Coming soon", [`${provider.label} is not yet supported.`], "info");
+        return;
+    }
+    if (isProviderAuthenticated(provider.id)) {
+        await showMessage("Already configured", [`${provider.label} is already logged in.`, "", "To change the API key, re-enter it below."], "info");
+    }
+    const key = await askName(`${provider.label}`, "Paste your API key:");
+    if (key) {
+        saveProviderKey(provider.id, key);
+        await showMessage("Saved", [`${provider.label} API key saved.`], "success");
+    }
+}
+// ── Agent config ──────────────────────────────────────────
 async function runAgentConfig(agentId) {
     while (true) {
         const agent = getAgent(agentId);
@@ -259,27 +242,23 @@ async function runAgentConfig(agentId) {
                 deleteAgent(agent.id);
                 return;
             }
-            case "back":
-                return;
+            case "back": return;
         }
     }
 }
-// ── Running the agent ─────────────────────────────────────
+// ── Running agent ─────────────────────────────────────────
 async function fetchCandidates(discovery) {
     const config = getConfig();
     const params = new URLSearchParams();
     if (discovery.onlineOnly)
         params.set("onlineOnly", "true");
     params.set("notContactedInDays", String(discovery.recontactAfterDays));
-    if (discovery.includeKeywords.length > 0) {
+    if (discovery.includeKeywords.length > 0)
         params.set("keywords", discovery.includeKeywords.join(","));
-    }
-    if (discovery.excludeKeywords.length > 0) {
+    if (discovery.excludeKeywords.length > 0)
         params.set("excludeKeywords", discovery.excludeKeywords.join(","));
-    }
-    if (discovery.excludeUsers.length > 0) {
+    if (discovery.excludeUsers.length > 0)
         params.set("excludeUsers", discovery.excludeUsers.join(","));
-    }
     params.set("limit", String(discovery.maxScreenPerSession));
     const res = await fetch(`${config.serverUrl}/api/discover?${params}`, {
         headers: { Authorization: `Bearer ${config.token}` },
@@ -293,73 +272,65 @@ async function runAgentSession() {
     const agent = await pickAgent();
     if (!agent)
         return;
-    let activeModel;
-    try {
-        const { model } = await initInference(agent.modelPattern);
-        activeModel = model;
-    }
-    catch (err) {
-        await showMessage("Model error", [err instanceof Error ? err.message : "Failed to initialize model"], "error");
+    // Resolve model
+    const resolved = resolveModel(agent.modelPattern);
+    if (!resolved) {
+        await showMessage("No model", ["No provider API keys configured.", "Add one in Swarm → Providers."], "error");
         return;
     }
+    setActiveModel(resolved.provider, resolved.model);
     setAgentInstructions(agent.instructions);
+    const modelInfo = {
+        provider: resolved.provider,
+        id: resolved.model,
+        name: resolved.model,
+    };
     const sessionGoal = await askSessionGoal();
     const config = getConfig();
     const discovery = agent.discovery;
     const limits = agent.limits;
-    const screen = new AgentRunningScreen(tui, activeModel, config.serverUrl, agent.name, sessionGoal);
+    const screen = new AgentRunningScreen(tui, modelInfo, config.serverUrl, agent.name, sessionGoal);
     const done = new Promise((resolve) => {
-        screen.onStop = () => {
-            stopAgent();
-            resolve();
-        };
+        screen.onStop = () => { stopAgent(); resolve(); };
     });
     setScreen(screen);
     const log = (line) => screen.addLog(line);
     startAgent(limits, agent.id, agent.name, log);
+    // Discovery
     screen.setStatus("discovering candidates...");
     try {
         const candidates = await fetchCandidates(discovery);
         if (candidates.length === 0) {
             log(colors.gray("No candidates match your discovery filters."));
-            log(colors.gray("Waiting for incoming conversations..."));
             screen.setStatus("waiting for conversations...");
         }
         else {
             log(colors.lime(`📡 Found ${candidates.length} candidates, screening...`));
             screen.setStatus(`screening ${candidates.length} profiles...`);
             const results = await screenProfiles(candidates, agent.instructions, sessionGoal, discovery.matchThreshold, discovery.maxScreenPerSession, (screened, total, result) => {
-                const icon = result.score >= discovery.matchThreshold
-                    ? colors.lime("✓")
-                    : colors.gray("⊘");
-                const name = `@${result.profile.githubUsername}`;
+                const icon = result.score >= discovery.matchThreshold ? colors.lime("✓") : colors.gray("⊘");
                 const scoreStr = result.score >= discovery.matchThreshold
-                    ? colors.lime(`${result.score}/10`)
-                    : colors.gray(`${result.score}/10`);
-                log(`  ${icon} ${name} ${scoreStr} — ${colors.gray(result.reason)}`);
+                    ? colors.lime(`${result.score}/10`) : colors.gray(`${result.score}/10`);
+                log(`  ${icon} @${result.profile.githubUsername} ${scoreStr} — ${colors.gray(result.reason)}`);
                 screen.setStatus(`screening ${screened}/${total}...`);
             });
             const matches = results.filter((r) => r.score >= discovery.matchThreshold);
             log("");
             if (matches.length === 0) {
-                log(colors.lime("No strong matches found. Waiting for incoming conversations..."));
+                log(colors.lime("No strong matches. Waiting for incoming conversations..."));
             }
             else {
                 log(colors.lime(`Found ${matches.length} match${matches.length === 1 ? "" : "es"}. Starting conversations...`));
                 log("");
                 for (const match of matches) {
                     if (!match.profile.online) {
-                        log(colors.gray(`  ⊘ @${match.profile.githubUsername} is offline, skipping`));
+                        log(colors.gray(`  ⊘ @${match.profile.githubUsername} offline`));
                         continue;
                     }
-                    log(colors.lime(`  🤝 Reaching out to @${match.profile.githubUsername} (${match.score}/10: ${match.reason})`));
-                    sendToServer({
-                        type: "start_conversation",
-                        withUserId: match.profile.id,
-                    });
-                    if (limits.cooldownSeconds > 0) {
+                    log(colors.lime(`  🤝 @${match.profile.githubUsername} (${match.score}/10: ${match.reason})`));
+                    sendToServer({ type: "start_conversation", withUserId: match.profile.id });
+                    if (limits.cooldownSeconds > 0)
                         await new Promise((r) => setTimeout(r, limits.cooldownSeconds * 1000));
-                    }
                 }
             }
             screen.setStatus(`${matches.length} matches • waiting for conversations...`);
@@ -375,12 +346,8 @@ async function runAgentSession() {
 async function runDashboard() {
     while (true) {
         const agents = getAgents();
-        const authenticatedProviders = await getAuthenticatedProviders();
         const action = await new Promise((resolve) => {
-            const dashboard = new DashboardScreen(tui, {
-                agents,
-                authenticatedProviders,
-            });
+            const dashboard = new DashboardScreen(tui, { agents });
             dashboard.onAction = resolve;
             setScreen(dashboard);
         });
@@ -406,15 +373,7 @@ async function runDashboard() {
                 await runAgentConfig(action.agentId);
                 break;
             case "provider":
-                await showMessage("Provider Login", [
-                    `To authenticate with this provider, run:`,
-                    ``,
-                    `  pi`,
-                    `  /login`,
-                    ``,
-                    `Then select the provider in pi's login flow.`,
-                    `Your credentials are stored locally in ~/.pi/agent/auth.json`,
-                ], "info");
+                await handleProviderLogin(action.providerId);
                 break;
             case "quit":
                 shutdown();
@@ -427,9 +386,6 @@ function shutdown() {
     terminal.clearScreen();
     process.exit(0);
 }
-/**
- * Main entry point for interactive TUI mode.
- */
 export async function runInteractive() {
     terminal = new ProcessTerminal();
     tui = new TUI(terminal, true);

package/dist/index.js

@@ -2,17 +2,16 @@
 import { runInteractive } from "./app.js";
 import { login } from "./login.js";
 import { getConfig, getAgents, migrateLegacyAgent } from "./config.js";
-import { initInference, getAvailableModels, setAgentInstructions } from "./inference.js";
+import { resolveModel, getAvailableModels } from "./providers.js";
+import { setActiveModel, setAgentInstructions } from "./inference.js";
 import { startAgent } from "./agent.js";
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
-    // No args → full TUI interactive mode
     if (!command) {
         await runInteractive();
         return;
     }
-    // Parse flags for direct commands
     const flags = {};
     for (let i = 1; i < args.length; i++) {
         if (args[i].startsWith("--") && args[i + 1]) {
@@ -20,7 +19,6 @@ async function main() {
             i++;
         }
     }
-    // Direct commands for scripting / CI
     switch (command) {
         case "login":
             await login();
@@ -49,16 +47,14 @@ async function main() {
             break;
         }
         case "models": {
-            console.log("Available models (from pi credentials):\n");
-            try {
-                await initInference();
-                const models = await getAvailableModels();
-                for (const m of models)
-                    console.log(`  ${m.provider}/${m.id}`);
-                console.log(`\nUse: swarmlancer start --model <pattern>`);
+            const models = getAvailableModels();
+            if (models.length === 0) {
+                console.log("No models available. Add a provider API key: swarmlancer");
             }
-            catch (err) {
-                console.error(err instanceof Error ? err.message : err);
+            else {
+                console.log("Available models:\n");
+                for (const m of models)
+                    console.log(`  ${m.provider}/${m.id}  (${m.name})`);
             }
             break;
         }
@@ -74,7 +70,6 @@ async function main() {
                 console.error("No agents configured. Run `swarmlancer` to create one.");
                 process.exit(1);
             }
-            // Pick agent by name or use first
             let agent = agents[0];
             if (flags.agent) {
                 const match = agents.find((a) => a.name.toLowerCase().includes(flags.agent.toLowerCase()));
@@ -86,25 +81,19 @@ async function main() {
                 }
                 agent = match;
             }
-            // Init model (agent's model pattern takes priority, then --model flag)
-            const modelPattern = agent.modelPattern || flags.model;
-            try {
-                const { model } = await initInference(modelPattern);
-                setAgentInstructions(agent.instructions);
-                console.log(`Agent:  ${agent.name}`);
-                console.log(`Model:  ${model.provider}/${model.id}`);
-                console.log(`Server: ${config.serverUrl}`);
-            }
-            catch (err) {
-                console.error(err instanceof Error ? err.message : err);
+            const modelPattern = flags.model || agent.modelPattern;
+            const resolved = resolveModel(modelPattern);
+            if (!resolved) {
+                console.error("No model available. Add a provider API key: swarmlancer");
                 process.exit(1);
             }
+            setActiveModel(resolved.provider, resolved.model);
+            setAgentInstructions(agent.instructions);
+            console.log(`Agent:    ${agent.name}`);
+            console.log(`Model:    ${resolved.provider}/${resolved.model}`);
+            console.log(`Server:   ${config.serverUrl}`);
             startAgent(agent.limits, agent.id, agent.name);
-            // Keep running until Ctrl+C
-            process.on("SIGINT", () => {
-                console.log("\nAgent shutting down...");
-                process.exit(0);
-            });
+            process.on("SIGINT", () => { console.log("\nAgent shutting down..."); process.exit(0); });
             break;
         }
         default:
@@ -113,13 +102,13 @@ swarmlancer — let the swarm begin
 
 Usage: swarmlancer [command]
 
-  (no command)                  Interactive TUI — guided setup and menu
+  (no command)                  Interactive TUI
   login                         Sign in with GitHub
   agents                        List configured agents
-  models                        List available LLM models
+  models                        List available models
   start                         Start first agent
   start --agent <name>          Start a specific agent
-  start --model <pattern>       Override model for this session
+  start --model <pattern>       Override model
 `);
     }
 }

package/dist/inference.d.ts

@@ -1,17 +1,9 @@
-import type { Model, Api } from "@mariozechner/pi-ai";
-export declare function initInference(modelPattern?: string): Promise<{
-    model: Model<Api>;
-}>;
-export declare function getAvailableModels(): Model<Api>[];
-/**
- * Return unique provider names that have at least one authenticated model.
- */
-export declare function getAuthenticatedProviders(): Promise<string[]>;
-/**
- * Set the agent instructions that will be prepended to every inference call.
- */
+import { type ProviderId } from "./providers.js";
 export declare function setAgentInstructions(instructions: string): void;
-export declare function runInference(systemPrompt: string, messages: {
+export declare function setActiveModel(provider: ProviderId, model: string): void;
+type Message = {
     role: "user" | "assistant";
     content: string;
-}[]): Promise<string>;
+};
+export declare function runInference(systemPrompt: string, messages: Message[]): Promise<string>;
+export {};

package/dist/inference.js

@@ -1,118 +1,103 @@
-import { AuthStorage, ModelRegistry, createAgentSession, SessionManager, SettingsManager, createExtensionRuntime, } from "@mariozechner/pi-coding-agent";
-let authStorage;
-let modelRegistry;
+import { getProviderKey } from "./providers.js";
+let currentProvider;
 let currentModel;
 let currentAgentInstructions = "";
-export async function initInference(modelPattern) {
-    authStorage = AuthStorage.create(); // reads ~/.pi/agent/auth.json
-    modelRegistry = new ModelRegistry(authStorage);
-    const available = await modelRegistry.getAvailable();
-    if (available.length === 0) {
-        throw new Error("No models available. Run `pi` first and authenticate with a provider (Anthropic, OpenAI, Google, Ollama, etc.)");
-    }
-    if (modelPattern) {
-        const match = available.find((m) => m.id.includes(modelPattern) ||
-            m.name.toLowerCase().includes(modelPattern.toLowerCase()) ||
-            `${m.provider}/${m.id}`.includes(modelPattern));
-        if (!match) {
-            console.error(`  Model "${modelPattern}" not found. Available:`);
-            for (const m of available)
-                console.error(`    ${m.provider}/${m.id}`);
-            process.exit(1);
-        }
-        currentModel = match;
-    }
-    else {
-        // Pick cheapest reasonable model — prefer latest small models
-        const preferences = ["haiku-4", "flash", "gpt-4o-mini", "haiku"];
-        for (const pref of preferences) {
-            const match = available.find((m) => m.id.includes(pref));
-            if (match) {
-                currentModel = match;
-                break;
-            }
-        }
-        if (!currentModel)
-            currentModel = available[0];
-    }
-    return { model: currentModel };
-}
-export function getAvailableModels() {
-    return modelRegistry?.getAvailable() ?? Promise.resolve([]);
-}
-/**
- * Return unique provider names that have at least one authenticated model.
- */
-export async function getAuthenticatedProviders() {
-    try {
-        const models = await getAvailableModels();
-        const providers = new Set(models.map((m) => m.provider.toLowerCase()));
-        return Array.from(providers);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Set the agent instructions that will be prepended to every inference call.
- */
 export function setAgentInstructions(instructions) {
     currentAgentInstructions = instructions;
 }
+export function setActiveModel(provider, model) {
+    currentProvider = provider;
+    currentModel = model;
+}
 export async function runInference(systemPrompt, messages) {
-    if (!currentModel || !authStorage) {
-        throw new Error("Inference not initialized. Call initInference() first.");
+    if (!currentProvider || !currentModel) {
+        throw new Error("No model configured. Add a provider API key and select a model.");
     }
-    // Prepend agent instructions to server-provided system prompt
     const fullSystemPrompt = currentAgentInstructions
         ? `${currentAgentInstructions}\n\n---\n\n${systemPrompt}`
         : systemPrompt;
-    const resourceLoader = {
-        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-        getSkills: () => ({ skills: [], diagnostics: [] }),
-        getPrompts: () => ({ prompts: [], diagnostics: [] }),
-        getThemes: () => ({ themes: [], diagnostics: [] }),
-        getAgentsFiles: () => ({ agentsFiles: [] }),
-        getSystemPrompt: () => fullSystemPrompt,
-        getAppendSystemPrompt: () => [],
-        getPathMetadata: () => new Map(),
-        extendResources: () => { },
-        reload: async () => { },
-    };
-    const { session } = await createAgentSession({
-        model: currentModel,
-        thinkingLevel: "off",
-        tools: [],
-        authStorage,
-        modelRegistry,
-        resourceLoader,
-        sessionManager: SessionManager.inMemory(),
-        settingsManager: SettingsManager.inMemory({
-            compaction: { enabled: false },
-            retry: { enabled: true, maxRetries: 2 },
+    switch (currentProvider) {
+        case "anthropic":
+            return callAnthropic(fullSystemPrompt, messages, currentModel);
+        case "openai":
+            return callOpenAI(fullSystemPrompt, messages, currentModel);
+        case "google":
+            return callGoogle(fullSystemPrompt, messages, currentModel);
+        default:
+            throw new Error(`Provider "${currentProvider}" does not support direct API calls yet.`);
+    }
+}
+// ── Anthropic ─────────────────────────────────────────────
+async function callAnthropic(system, messages, model) {
+    const apiKey = getProviderKey("anthropic");
+    if (!apiKey)
+        throw new Error("Anthropic API key not configured");
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify({
+            model,
+            max_tokens: 2048,
+            system,
+            messages,
         }),
     });
-    // Inject conversation history (all but last message)
-    if (messages.length > 1) {
-        for (const msg of messages.slice(0, -1)) {
-            session.agent.state.messages.push(msg.role === "user"
-                ? { role: "user", content: [{ type: "text", text: msg.content }], timestamp: Date.now() }
-                : {
-                    role: "assistant",
-                    content: [{ type: "text", text: msg.content }],
-                    timestamp: Date.now(),
-                });
-        }
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Anthropic ${res.status}: ${body.slice(0, 200)}`);
     }
-    let responseText = "";
-    session.subscribe((event) => {
-        if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-            responseText += event.assistantMessageEvent.delta;
-        }
+    const data = (await res.json());
+    return data.content?.[0]?.text || "(no response)";
+}
+// ── OpenAI ────────────────────────────────────────────────
+async function callOpenAI(system, messages, model) {
+    const apiKey = getProviderKey("openai");
+    if (!apiKey)
+        throw new Error("OpenAI API key not configured");
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model,
+            messages: [{ role: "system", content: system }, ...messages],
+        }),
     });
-    // Prompt with the last message
-    const lastMessage = messages[messages.length - 1];
-    await session.prompt(lastMessage.content);
-    session.dispose();
-    return responseText || "(no response)";
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`OpenAI ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const data = (await res.json());
+    return data.choices?.[0]?.message?.content || "(no response)";
+}
+// ── Google Gemini ─────────────────────────────────────────
+async function callGoogle(system, messages, model) {
+    const apiKey = getProviderKey("google");
+    if (!apiKey)
+        throw new Error("Google API key not configured");
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+    const contents = messages.map((m) => ({
+        role: m.role === "assistant" ? "model" : "user",
+        parts: [{ text: m.content }],
+    }));
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            systemInstruction: { parts: [{ text: system }] },
+            contents,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Google ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const data = (await res.json());
+    return data.candidates?.[0]?.content?.parts?.[0]?.text || "(no response)";
 }

package/dist/providers.d.ts

@@ -0,0 +1,30 @@
+export type ModelInfo = {
+    provider: string;
+    id: string;
+    name: string;
+};
+export type ProviderId = "anthropic" | "openai" | "google" | "copilot" | "antigravity";
+export type ProviderDef = {
+    id: ProviderId;
+    label: string;
+    keyBased: boolean;
+    models: {
+        id: string;
+        name: string;
+    }[];
+};
+export declare const PROVIDERS: ProviderDef[];
+export declare function getProviderKey(id: ProviderId): string | undefined;
+export declare function saveProviderKey(id: ProviderId, apiKey: string): void;
+export declare function removeProviderKey(id: ProviderId): void;
+export declare function getAuthenticatedProviderIds(): ProviderId[];
+export declare function isProviderAuthenticated(id: ProviderId): boolean;
+export declare function getAvailableModels(): ModelInfo[];
+/**
+ * Resolve a model pattern like "anthropic/claude-haiku-4-20250514" or just "claude-haiku-4-20250514"
+ * into a { provider, model } pair. Falls back to the cheapest available model.
+ */
+export declare function resolveModel(modelPattern?: string): {
+    provider: ProviderId;
+    model: string;
+} | undefined;

package/dist/providers.js

@@ -0,0 +1,119 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".swarmlancer");
+const PROVIDERS_FILE = join(CONFIG_DIR, "providers.json");
+// ── Known providers ───────────────────────────────────────
+export const PROVIDERS = [
+    {
+        id: "anthropic",
+        label: "Anthropic (Claude Pro/Max)",
+        keyBased: true,
+        models: [
+            { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
+            { id: "claude-haiku-4-20250514", name: "Claude Haiku 4" },
+        ],
+    },
+    {
+        id: "openai",
+        label: "ChatGPT Plus/Pro (Codex Subscription)",
+        keyBased: true,
+        models: [
+            { id: "gpt-4o", name: "GPT-4o" },
+            { id: "gpt-4o-mini", name: "GPT-4o Mini" },
+        ],
+    },
+    {
+        id: "google",
+        label: "Google Cloud Code Assist (Gemini CLI)",
+        keyBased: true,
+        models: [
+            { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash" },
+            { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
+        ],
+    },
+    {
+        id: "copilot",
+        label: "GitHub Copilot",
+        keyBased: false,
+        models: [],
+    },
+    {
+        id: "antigravity",
+        label: "Antigravity (Gemini 3, Claude, GPT-OSS)",
+        keyBased: false,
+        models: [],
+    },
+];
+function readAll() {
+    try {
+        if (existsSync(PROVIDERS_FILE)) {
+            return JSON.parse(readFileSync(PROVIDERS_FILE, "utf-8"));
+        }
+    }
+    catch { }
+    return {};
+}
+function writeAll(data) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(PROVIDERS_FILE, JSON.stringify(data, null, 2));
+}
+export function getProviderKey(id) {
+    return readAll()[id]?.apiKey || undefined;
+}
+export function saveProviderKey(id, apiKey) {
+    const all = readAll();
+    all[id] = { apiKey };
+    writeAll(all);
+}
+export function removeProviderKey(id) {
+    const all = readAll();
+    delete all[id];
+    writeAll(all);
+}
+// ── Queries ───────────────────────────────────────────────
+export function getAuthenticatedProviderIds() {
+    const all = readAll();
+    return Object.keys(all).filter((k) => all[k]?.apiKey);
+}
+export function isProviderAuthenticated(id) {
+    return !!getProviderKey(id);
+}
+export function getAvailableModels() {
+    const authed = getAuthenticatedProviderIds();
+    const models = [];
+    for (const p of PROVIDERS) {
+        if (authed.includes(p.id)) {
+            for (const m of p.models) {
+                models.push({ provider: p.id, id: m.id, name: m.name });
+            }
+        }
+    }
+    return models;
+}
+/**
+ * Resolve a model pattern like "anthropic/claude-haiku-4-20250514" or just "claude-haiku-4-20250514"
+ * into a { provider, model } pair. Falls back to the cheapest available model.
+ */
+export function resolveModel(modelPattern) {
+    const models = getAvailableModels();
+    if (models.length === 0)
+        return undefined;
+    if (modelPattern) {
+        // Try "provider/model" format
+        if (modelPattern.includes("/")) {
+            const [prov, mod] = modelPattern.split("/", 2);
+            const match = models.find((m) => m.provider === prov && m.id === mod);
+            if (match)
+                return { provider: match.provider, model: match.id };
+        }
+        // Fuzzy match
+        const match = models.find((m) => m.id.includes(modelPattern) ||
+            m.name.toLowerCase().includes(modelPattern.toLowerCase()));
+        if (match)
+            return { provider: match.provider, model: match.id };
+    }
+    // Default: first available model (cheapest tends to be listed last per provider, but first model overall)
+    const m = models[0];
+    return { provider: m.provider, model: m.id };
+}

package/dist/screens/agent-running.d.ts

@@ -1,6 +1,6 @@
 import { type Component } from "@mariozechner/pi-tui";
 import type { TUI } from "@mariozechner/pi-tui";
-import type { Model, Api } from "@mariozechner/pi-ai";
+import type { ModelInfo } from "../providers.js";
 export declare class AgentRunningScreen implements Component {
     private tui;
     private logLines;
@@ -11,7 +11,7 @@ export declare class AgentRunningScreen implements Component {
     private sessionGoal;
     private statusLine;
     onStop?: () => void;
-    constructor(tui: TUI, model: Model<Api>, serverUrl: string, agentName: string, sessionGoal?: string);
+    constructor(tui: TUI, model: ModelInfo, serverUrl: string, agentName: string, sessionGoal?: string);
     setStatus(status: string): void;
     addLog(line: string): void;
     handleInput(data: string): void;

package/dist/screens/banner.js

@@ -1,10 +1,14 @@
 import { Container, Text, Spacer } from "@mariozechner/pi-tui";
 import { colors } from "../theme.js";
 const BANNER_ART = [
-    ` _______ ________ _______ ______ _______ _____   _______ _______ ______ _______ ______`,
-    ` |     __|  |  |  |   _   |   __ \\   |   |     |_|   _   |    |  |      |    ___|   __ \\`,
-    ` |__     |  |  |  |       |      <       |       |       |       |   ---|    ___|      <`,
-    ` |_______|________|___|___|___|__|__|_|__|_______|___|___|__|____|______|_______|___|__|`,
+    `  █████████        ███`,
+    ` ███░░░░░███     ███░ `,
+    `░███    ░░░    ███░   `,
+    `░░█████████  ███░     `,
+    ` ░░░░░░░░███░░░███    `,
+    ` ███    ░███  ░░░███  `,
+    `░░█████████     ░░░███`,
+    ` ░░░░░░░░░        ░░░ `,
 ];
 export class BannerComponent extends Container {
     constructor() {
@@ -15,10 +19,10 @@ export class BannerComponent extends Container {
         this.clear();
         this.addChild(new Spacer(1));
         for (const line of BANNER_ART) {
-            this.addChild(new Text(colors.limeBold(line), 1, 0));
+            this.addChild(new Text(colors.limeBold(` ${line}`), 1, 0));
         }
         this.addChild(new Spacer(0));
-        this.addChild(new Text(colors.gray(" Let the Swarm Begin"), 1, 0));
+        this.addChild(new Text(colors.gray(" LET THE SWARM BEGIN"), 1, 0));
         this.addChild(new Spacer(1));
     }
     invalidate() {

package/dist/screens/dashboard.d.ts

@@ -16,18 +16,20 @@ export type MenuAction = {
 };
 export interface DashboardData {
     agents: AgentProfile[];
-    authenticatedProviders: string[];
 }
 export declare class DashboardScreen implements Component {
     private tui;
     private banner;
-    private items;
+    private tree;
+    private flat;
     private selectableIndices;
     private cursor;
     private cachedRender?;
     onAction?: (action: MenuAction) => void;
     constructor(tui: TUI, data: DashboardData);
-    private buildItems;
+    private buildTree;
+    private rebuildFlat;
+    private flattenTree;
     handleInput(data: string): void;
     render(width: number): string[];
     invalidate(): void;

package/dist/screens/dashboard.js

@@ -1,64 +1,93 @@
 import { matchesKey, Key, truncateToWidth, } from "@mariozechner/pi-tui";
 import { colors, theme } from "../theme.js";
 import { BannerComponent } from "./banner.js";
-const KNOWN_PROVIDERS = [
-    { id: "anthropic", label: "Anthropic (Claude Pro/Max)", match: ["anthropic"] },
-    { id: "copilot", label: "GitHub Copilot", match: ["copilot", "github"] },
-    { id: "google", label: "Google Cloud Code Assist (Gemini CLI)", match: ["google", "vertex"] },
-    { id: "antigravity", label: "Antigravity (Gemini 3, Claude, GPT-OSS)", match: ["antigravity"] },
-    { id: "openai", label: "ChatGPT Plus/Pro (Codex Subscription)", match: ["openai", "chatgpt"] },
-];
+import { PROVIDERS, isProviderAuthenticated } from "../providers.js";
 export class DashboardScreen {
     tui;
     banner;
-    items;
-    selectableIndices;
+    tree;
+    flat = [];
+    selectableIndices = [];
     cursor = 0;
     cachedRender;
     onAction;
     constructor(tui, data) {
         this.tui = tui;
         this.banner = new BannerComponent();
-        this.items = this.buildItems(data);
-        this.selectableIndices = this.items
-            .map((item, i) => (item.kind === "action" ? i : -1))
-            .filter((i) => i >= 0);
+        this.tree = this.buildTree(data);
+        this.rebuildFlat();
     }
-    buildItems(data) {
-        const items = [];
-        items.push({ kind: "action", text: "Go online", indent: 0, action: { type: "start" } });
-        items.push({ kind: "spacer", text: "", indent: 0 });
-        items.push({ kind: "header", text: "Swarm", indent: 0 });
-        // Manage
-        items.push({ kind: "header", text: "Manage", indent: 1 });
-        items.push({ kind: "action", text: "+ Create", indent: 2, action: { type: "create-agent" } });
+    buildTree(data) {
+        // Manage children
+        const manageChildren = [
+            { label: "+ Create", indent: 0, action: { type: "create-agent" }, expanded: false },
+        ];
         for (const agent of data.agents) {
             const ready = agent.instructions.length > 0;
             const suffix = ready ? " [⚡]" : "";
-            items.push({
-                kind: "action",
-                text: `${agent.name}${suffix}`,
-                indent: 2,
+            manageChildren.push({
+                label: `${agent.name}${suffix}`,
+                indent: 0,
                 action: { type: "edit-agent", agentId: agent.id },
+                expanded: false,
             });
         }
-        // Providers
-        items.push({ kind: "header", text: "Providers", indent: 1 });
-        items.push({ kind: "label", text: "Select provider to login:", indent: 2 });
-        for (const p of KNOWN_PROVIDERS) {
-            const loggedIn = p.match.some((m) => data.authenticatedProviders.some((ap) => ap.includes(m)));
+        // Provider children
+        const providerChildren = [
+            { label: "Select provider to login:", indent: 0, isLabel: true, expanded: false },
+        ];
+        for (const p of PROVIDERS) {
+            const loggedIn = isProviderAuthenticated(p.id);
             const prefix = loggedIn ? "→ " : "  ";
             const suffix = loggedIn ? " ✓ logged in" : "";
-            items.push({
-                kind: "action",
-                text: `${prefix}${p.label}${suffix}`,
-                indent: 3,
+            providerChildren.push({
+                label: `${prefix}${p.label}${suffix}`,
+                indent: 0,
                 action: { type: "provider", providerId: p.id },
+                expanded: false,
             });
         }
-        items.push({ kind: "spacer", text: "", indent: 0 });
-        items.push({ kind: "action", text: "Exit", indent: 0, action: { type: "quit" } });
-        return items;
+        return [
+            { label: "Go online", indent: 0, action: { type: "start" }, expanded: false },
+            {
+                label: "Swarm",
+                indent: 0,
+                expanded: false,
+                children: [
+                    {
+                        label: "Manage",
+                        indent: 0,
+                        expanded: false,
+                        children: manageChildren,
+                    },
+                    {
+                        label: "Providers",
+                        indent: 0,
+                        expanded: false,
+                        children: providerChildren,
+                    },
+                ],
+            },
+            { label: "Exit", indent: 0, action: { type: "quit" }, expanded: false },
+        ];
+    }
+    rebuildFlat() {
+        this.flat = [];
+        this.flattenTree(this.tree, 0);
+        this.selectableIndices = this.flat
+            .map((item, i) => (!item.node.isLabel ? i : -1))
+            .filter((i) => i >= 0);
+        if (this.cursor >= this.selectableIndices.length) {
+            this.cursor = Math.max(0, this.selectableIndices.length - 1);
+        }
+    }
+    flattenTree(nodes, indent) {
+        for (const node of nodes) {
+            this.flat.push({ node, indent });
+            if (node.children && node.expanded) {
+                this.flattenTree(node.children, indent + 1);
+            }
+        }
     }
     handleInput(data) {
         if (matchesKey(data, "q")) {
@@ -80,10 +109,18 @@ export class DashboardScreen {
             return;
         }
         if (matchesKey(data, Key.enter)) {
-            const itemIndex = this.selectableIndices[this.cursor];
-            const item = this.items[itemIndex];
-            if (item.action) {
-                this.onAction?.(item.action);
+            const itemIdx = this.selectableIndices[this.cursor];
+            const item = this.flat[itemIdx];
+            if (item.node.children) {
+                // Branch: toggle expand/collapse
+                item.node.expanded = !item.node.expanded;
+                this.rebuildFlat();
+                this.cachedRender = undefined;
+                this.tui.requestRender();
+            }
+            else if (item.node.action) {
+                // Leaf: trigger action
+                this.onAction?.(item.node.action);
             }
             return;
         }
@@ -92,33 +129,28 @@ export class DashboardScreen {
         if (this.cachedRender)
             return this.cachedRender;
         const lines = this.banner.render(width);
-        const selectedItemIndex = this.selectableIndices[this.cursor];
-        for (let i = 0; i < this.items.length; i++) {
-            const item = this.items[i];
-            const pad = "  ".repeat(item.indent);
-            if (item.kind === "spacer") {
-                lines.push("");
-                continue;
-            }
-            if (item.kind === "header") {
-                lines.push(truncateToWidth(` ${pad}${colors.bold(item.text)}`, width));
-                continue;
-            }
-            if (item.kind === "label") {
-                lines.push(truncateToWidth(` ${pad}${colors.gray(item.text)}`, width));
+        const selectedFlatIdx = this.selectableIndices[this.cursor];
+        for (let i = 0; i < this.flat.length; i++) {
+            const { node, indent } = this.flat[i];
+            const pad = "  ".repeat(indent + 1);
+            const isSelected = i === selectedFlatIdx;
+            if (node.isLabel) {
+                // Non-selectable label
+                lines.push(truncateToWidth(`${pad}  ${colors.gray(node.label)}`, width));
                 continue;
             }
-            // Selectable action
-            const isSelected = i === selectedItemIndex;
+            const isBranch = !!node.children;
+            const arrow = isBranch ? (node.expanded ? " ▾" : " ▸") : "";
+            const label = `${node.label}${arrow}`;
             if (isSelected) {
-                lines.push(truncateToWidth(` ${pad}${theme.accent(`▸ ${item.text}`)}`, width));
+                lines.push(truncateToWidth(`${pad}${theme.accent(`▸ ${label}`)}`, width));
             }
             else {
-                lines.push(truncateToWidth(` ${pad}  ${item.text}`, width));
+                lines.push(truncateToWidth(`${pad}  ${label}`, width));
             }
         }
         lines.push("");
-        lines.push(truncateToWidth(colors.gray(" ↑↓ navigate • enter select • q quit"), width));
+        lines.push(truncateToWidth(colors.gray(" ↑↓ navigate • enter expand/select • q quit"), width));
         this.cachedRender = lines;
         return lines;
     }

package/dist/screens/model-picker.d.ts

@@ -1,13 +1,13 @@
 import { type Component } from "@mariozechner/pi-tui";
 import type { TUI } from "@mariozechner/pi-tui";
-import type { Model, Api } from "@mariozechner/pi-ai";
+import type { ModelInfo } from "../providers.js";
 export declare class ModelPickerScreen implements Component {
     private container;
     private selectList;
     private tui;
-    onSelect?: (model: Model<Api>) => void;
+    onSelect?: (model: ModelInfo) => void;
     onCancel?: () => void;
-    constructor(tui: TUI, models: Model<Api>[]);
+    constructor(tui: TUI, models: ModelInfo[]);
     handleInput(data: string): void;
     render(width: number): string[];
     invalidate(): void;

package/dist/screens/model-picker.js

@@ -14,8 +14,8 @@ export class ModelPickerScreen {
         this.container.addChild(new Text(theme.title(" Pick a model"), 1, 0));
         this.container.addChild(new Spacer(1));
         const items = models.map((m) => ({
-            value: m.id,
-            label: `${m.name}`,
+            value: `${m.provider}/${m.id}`,
+            label: m.name,
             description: `${m.provider}/${m.id}`,
         }));
         this.selectList = new SelectList(items, Math.min(items.length, 15), {
@@ -26,7 +26,7 @@ export class ModelPickerScreen {
             noMatch: (t) => colors.gray(t),
         });
         this.selectList.onSelect = (item) => {
-            const model = models.find((m) => m.id === item.value);
+            const model = models.find((m) => `${m.provider}/${m.id}` === item.value);
             if (model)
                 this.onSelect?.(model);
         };

package/dist/screens/setup-wizard.js

@@ -13,8 +13,8 @@ export class SetupWizardScreen {
         this.tui = tui;
         this.steps = [
             { label: "Authentication", status: "pending" },
-            { label: "Model detection", status: "pending" },
             { label: "Agents", status: "pending" },
+            { label: "Providers", status: "pending" },
         ];
     }
     setStep(index, status, detail) {

package/dist/screens/status-panel.d.ts

@@ -1,8 +1,8 @@
 import { Container } from "@mariozechner/pi-tui";
-import type { Model, Api } from "@mariozechner/pi-ai";
+import type { ModelInfo } from "../providers.js";
 export interface StatusInfo {
     loggedIn: boolean;
-    model: Model<Api> | undefined;
+    model: ModelInfo | undefined;
     agentCount: number;
     serverUrl: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmlancer-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Swarmlancer CLI — let the swarm begin. Connect your AI agent to a network of other agents.",
   "type": "module",
   "main": "dist/index.js",
@@ -41,7 +41,6 @@
     "typescript": "^5.8.0"
   },
   "dependencies": {
-    "@mariozechner/pi-coding-agent": "^0.58.4",
     "@mariozechner/pi-tui": "^0.58.4",
     "open": "^11.0.0",
     "ws": "^8.19.0"