@robzilla1738/agentswarm 0.2.0

package/dist/config.js

@@ -0,0 +1,289 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTABLE_KEYS = exports.SECRET_ENV_KEYS = exports.DEFAULTS = exports.DEFAULT_PRICING = void 0;
+exports.home = home;
+exports.runsDir = runsDir;
+exports.runDir = runDir;
+exports.configPath = configPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.maskKey = maskKey;
+exports.coerceConfigValue = coerceConfigValue;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const providers_1 = require("./providers");
+const util_1 = require("./util");
+exports.DEFAULT_PRICING = {
+    // $ per 1M tokens (June 2026, api-docs.deepseek.com/quick_start/pricing)
+    "deepseek-v4-flash": { inMiss: 0.14, inHit: 0.0028, out: 0.28 },
+    "deepseek-v4-pro": { inMiss: 0.435, inHit: 0.003625, out: 0.87 },
+    // Deprecated aliases (map to v4-flash modes until 2026-07-24)
+    "deepseek-chat": { inMiss: 0.14, inHit: 0.0028, out: 0.28 },
+    "deepseek-reasoner": { inMiss: 0.14, inHit: 0.0028, out: 0.28 },
+    // Approximate list prices for other providers — unknown models cost $0 in
+    // the UI rather than guessing.
+    "gpt-5.1": { inMiss: 1.25, inHit: 0.125, out: 10 },
+    "gpt-5.1-mini": { inMiss: 0.25, inHit: 0.025, out: 2 },
+    "claude-sonnet-4-6": { inMiss: 3, inHit: 0.3, out: 15 },
+    "claude-haiku-4-5": { inMiss: 1, inHit: 0.1, out: 5 },
+    "MiniMax-M2.1": { inMiss: 0.3, inHit: 0.03, out: 1.2 },
+    "MiniMax-M2": { inMiss: 0.3, inHit: 0.03, out: 1.2 },
+};
+exports.DEFAULTS = {
+    provider: "deepseek",
+    providers: {},
+    apiKey: "",
+    baseUrl: providers_1.PROVIDERS.deepseek.baseUrl,
+    model: "deepseek-v4-flash",
+    conductorModel: "deepseek-v4-flash",
+    maxWorkers: 6,
+    maxStepsPerTask: 30,
+    maxTasks: 48,
+    maxTokensPerRun: 12_000_000,
+    verification: "normal",
+    thinking: true,
+    reasoningEffort: "high",
+    safeMode: true,
+    tinyfishApiKey: "",
+    searchBackend: "auto",
+    searchkitCmd: "searchkit",
+    sandboxRuntime: "host",
+    sandboxImage: "node:22-bookworm",
+    e2bApiKey: "",
+    e2bTemplate: "base",
+    modalTokenId: "",
+    modalTokenSecret: "",
+    vercelToken: "",
+    vercelTeamId: "",
+    vercelProjectId: "",
+    requestTimeoutMs: 900_000,
+    idleTimeoutMs: 180_000,
+    contextTokenLimit: 120_000,
+    maxToolResultChars: 12_000,
+    hubPort: 7777,
+    uiPort: 7780,
+    pricing: exports.DEFAULT_PRICING,
+};
+/**
+ * Env vars that must never leak into agent shell commands when they execute
+ * directly on the host: every provider key env plus the search/sandbox
+ * credentials the engine itself understands.
+ */
+exports.SECRET_ENV_KEYS = [
+    ...new Set([
+        ...Object.values(providers_1.PROVIDERS)
+            .map((p) => p.keyEnv)
+            .filter((k) => Boolean(k)),
+        "TINYFISH_API_KEY",
+        "E2B_API_KEY",
+        "MODAL_TOKEN_ID",
+        "MODAL_TOKEN_SECRET",
+        "VERCEL_SANDBOX_TOKEN",
+    ]),
+];
+function home() {
+    return process.env.AGENTSWARM_HOME || path.join(os.homedir(), ".agentswarm");
+}
+function runsDir() {
+    return path.join(home(), "runs");
+}
+function runDir(id) {
+    return path.join(runsDir(), id);
+}
+function configPath() {
+    return path.join(home(), "config.json");
+}
+/**
+ * Migrate a pre-provider config file in place: flat apiKey/baseUrl belonged
+ * to DeepSeek (the only provider that existed).
+ */
+function migrate(file) {
+    const out = { ...file, providers: { ...(file.providers || {}) } };
+    if ((file.apiKey || file.baseUrl) && !out.providers.deepseek) {
+        out.providers.deepseek = {
+            ...(file.apiKey ? { apiKey: file.apiKey } : {}),
+            ...(file.baseUrl && file.baseUrl !== providers_1.PROVIDERS.deepseek.baseUrl ? { baseUrl: file.baseUrl } : {}),
+        };
+    }
+    return out;
+}
+function loadConfig() {
+    const file = migrate((0, util_1.readJson)(configPath(), {}));
+    const provider = (0, providers_1.isProviderId)(file.provider) ? file.provider : "deepseek";
+    const info = providers_1.PROVIDERS[provider];
+    const cred = file.providers?.[provider] || {};
+    const cfg = {
+        ...exports.DEFAULTS,
+        ...file,
+        provider,
+        providers: file.providers || {},
+        pricing: { ...exports.DEFAULT_PRICING, ...(file.pricing || {}) },
+        apiKey: cred.apiKey || "",
+        baseUrl: cred.baseUrl || info.baseUrl,
+    };
+    // Env overrides: provider-specific key env, plus legacy DEEPSEEK_API_KEY.
+    if (info.keyEnv && process.env[info.keyEnv])
+        cfg.apiKey = process.env[info.keyEnv];
+    if (process.env.TINYFISH_API_KEY)
+        cfg.tinyfishApiKey = process.env.TINYFISH_API_KEY;
+    if (process.env.E2B_API_KEY)
+        cfg.e2bApiKey = process.env.E2B_API_KEY;
+    if (process.env.MODAL_TOKEN_ID)
+        cfg.modalTokenId = process.env.MODAL_TOKEN_ID;
+    if (process.env.MODAL_TOKEN_SECRET)
+        cfg.modalTokenSecret = process.env.MODAL_TOKEN_SECRET;
+    if (process.env.VERCEL_SANDBOX_TOKEN)
+        cfg.vercelToken = process.env.VERCEL_SANDBOX_TOKEN;
+    if (process.env.SWARM_HUB_PORT)
+        cfg.hubPort = Number(process.env.SWARM_HUB_PORT) || cfg.hubPort;
+    return cfg;
+}
+function saveConfig(patch) {
+    (0, util_1.ensureDir)(home());
+    const current = migrate((0, util_1.readJson)(configPath(), {}));
+    const next = { ...current, ...patch };
+    // Per-provider creds deep-merge so saving one provider's key keeps the rest.
+    if (patch.providers) {
+        next.providers = { ...(current.providers || {}) };
+        for (const [id, cred] of Object.entries(patch.providers)) {
+            if (!(0, providers_1.isProviderId)(id) || !cred)
+                continue;
+            next.providers[id] = { ...(next.providers[id] || {}), ...cred };
+        }
+    }
+    // Legacy flat fields (CLI `swarm config set apiKey/baseUrl`) target the
+    // active provider rather than a dead top-level slot.
+    const active = (0, providers_1.isProviderId)(next.provider) ? next.provider : "deepseek";
+    for (const k of ["apiKey", "baseUrl"]) {
+        if (patch[k] !== undefined) {
+            next.providers = next.providers || {};
+            next.providers[active] = { ...(next.providers[active] || {}), [k]: patch[k] };
+            delete next[k];
+        }
+    }
+    (0, util_1.writeJson)(configPath(), next, 0o600);
+    try {
+        fs.chmodSync(configPath(), 0o600);
+    }
+    catch {
+        /* best effort */
+    }
+    return loadConfig();
+}
+function maskKey(key) {
+    if (!key)
+        return "";
+    if (key.length <= 9)
+        return key[0] + "…";
+    return key.slice(0, 5) + "…" + key.slice(-4);
+}
+/** Settable via `swarm config set <key> <value>` and the UI settings page. */
+exports.SETTABLE_KEYS = [
+    "provider",
+    "apiKey",
+    "baseUrl",
+    "model",
+    "conductorModel",
+    "maxWorkers",
+    "maxStepsPerTask",
+    "maxTasks",
+    "maxTokensPerRun",
+    "verification",
+    "thinking",
+    "reasoningEffort",
+    "safeMode",
+    "tinyfishApiKey",
+    "searchBackend",
+    "searchkitCmd",
+    "sandboxRuntime",
+    "sandboxImage",
+    "e2bApiKey",
+    "e2bTemplate",
+    "modalTokenId",
+    "modalTokenSecret",
+    "vercelToken",
+    "vercelTeamId",
+    "vercelProjectId",
+    "contextTokenLimit",
+    "hubPort",
+    "uiPort",
+];
+/** Allowed ranges for numeric settings (values are clamped, not rejected). */
+const NUM_RANGES = {
+    maxWorkers: [1, 32],
+    maxStepsPerTask: [3, 200],
+    maxTasks: [1, 1000],
+    maxTokensPerRun: [50_000, 2_000_000_000],
+    contextTokenLimit: [8_000, 900_000],
+    hubPort: [0, 65535],
+    uiPort: [0, 65535],
+};
+const ENUMS = {
+    verification: ["off", "normal", "strict"],
+    reasoningEffort: ["low", "medium", "high", "max"],
+    searchBackend: ["auto", "tinyfish", "ddg"],
+    sandboxRuntime: ["auto", "host", "docker", "e2b", "modal", "vercel"],
+    provider: Object.keys(providers_1.PROVIDERS),
+};
+/**
+ * Validate + normalize one settable config value (from the CLI or the hub's
+ * JSON body). Throws with a human message on invalid input — never lets NaN
+ * or a bad enum reach config.json, where it would poison every later run.
+ */
+function coerceConfigValue(key, raw) {
+    const range = NUM_RANGES[key];
+    if (range) {
+        const n = Number(raw);
+        if (!Number.isFinite(n))
+            throw new Error(`${key} must be a number`);
+        return Math.min(range[1], Math.max(range[0], Math.round(n)));
+    }
+    if (key === "thinking" || key === "safeMode") {
+        if (typeof raw === "boolean")
+            return raw;
+        return raw === "true" || raw === "1" || raw === "on";
+    }
+    const allowed = ENUMS[key];
+    if (allowed) {
+        const v = String(raw);
+        if (!allowed.includes(v))
+            throw new Error(`${key} must be one of: ${allowed.join(" | ")}`);
+        return v;
+    }
+    // Secrets, URLs, model names: strip stray whitespace/newlines from pastes.
+    return String(raw).trim();
+}

package/dist/control.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlReader = void 0;
+exports.controlFile = controlFile;
+exports.appendControl = appendControl;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("./util");
+function controlFile(runDirPath) {
+    return path.join(runDirPath, "control.jsonl");
+}
+function appendControl(runDirPath, msg) {
+    const line = JSON.stringify({ t: Date.now(), ...msg }) + "\n";
+    fs.appendFileSync(controlFile(runDirPath), line, "utf8");
+}
+class ControlReader {
+    file;
+    offset = 0;
+    constructor(runDirPath) {
+        this.file = controlFile(runDirPath);
+        try {
+            this.offset = fs.statSync(this.file).size;
+        }
+        catch {
+            this.offset = 0;
+        }
+    }
+    poll() {
+        let stat;
+        try {
+            stat = fs.statSync(this.file);
+        }
+        catch {
+            return [];
+        }
+        if (stat.size <= this.offset) {
+            if (stat.size < this.offset)
+                this.offset = 0;
+            return [];
+        }
+        const fd = fs.openSync(this.file, "r");
+        try {
+            const len = stat.size - this.offset;
+            const buf = Buffer.alloc(len);
+            fs.readSync(fd, buf, 0, len, this.offset);
+            this.offset = stat.size;
+            const out = [];
+            for (const line of buf.toString("utf8").split("\n")) {
+                const s = line.trim();
+                if (!s)
+                    continue;
+                const msg = (0, util_1.safeJson)(s);
+                if (msg && msg.kind)
+                    out.push(msg);
+            }
+            return out;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+}
+exports.ControlReader = ControlReader;

package/dist/deepseek.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelledError = exports.ApiError = void 0;
+exports.chat = chat;
+exports.isFatalAuthError = isFatalAuthError;
+exports.validateAuth = validateAuth;
+exports.listModels = listModels;
+const providers_1 = require("./providers");
+const util_1 = require("./util");
+function providerOf(cfg) {
+    return providers_1.PROVIDERS[cfg.provider] ?? providers_1.PROVIDERS.deepseek;
+}
+class ApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`API ${status}: ${body.slice(0, 600)}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.ApiError = ApiError;
+class CancelledError extends Error {
+    constructor() {
+        super("cancelled");
+    }
+}
+exports.CancelledError = CancelledError;
+function retryable(e) {
+    if (e instanceof CancelledError)
+        return false;
+    if (e instanceof ApiError)
+        return e.status === 429 || e.status >= 500;
+    // Network hiccups, idle timeouts, broken streams.
+    return true;
+}
+function normalizeUsage(u) {
+    const prompt = u?.prompt_tokens ?? 0;
+    const completion = u?.completion_tokens ?? 0;
+    const hit = u?.prompt_cache_hit_tokens ?? u?.prompt_tokens_details?.cached_tokens ?? 0;
+    const miss = u?.prompt_cache_miss_tokens ?? Math.max(0, prompt - hit);
+    return {
+        promptTokens: prompt,
+        completionTokens: completion,
+        cacheHitTokens: hit,
+        cacheMissTokens: miss,
+    };
+}
+function sanitizeMessages(messages, thinking) {
+    return messages.map((m) => {
+        if (m.role === "assistant") {
+            const out = { role: "assistant", content: m.content ?? "" };
+            if (m.tool_calls?.length) {
+                out.tool_calls = m.tool_calls;
+                // DeepSeek thinking mode REQUIRES reasoning_content on tool-call turns
+                // (400 otherwise). In non-thinking mode the field must be absent.
+                if (thinking)
+                    out.reasoning_content = m.reasoning_content ?? "";
+            }
+            return out;
+        }
+        if (m.role === "tool") {
+            return { role: "tool", content: m.content ?? "", tool_call_id: m.tool_call_id };
+        }
+        return { role: m.role, content: m.content ?? "" };
+    });
+}
+/**
+ * One streaming chat-completions call with retries. Streams deltas (text and
+ * reasoning), accumulates tool calls, captures usage from the final chunk.
+ */
+async function chat(cfg, o) {
+    let lastErr;
+    const attempts = 4;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            return await chatOnce(cfg, o);
+        }
+        catch (e) {
+            lastErr = e;
+            if (!retryable(e) || i === attempts - 1)
+                throw e;
+            const backoff = [1500, 5000, 15000][i] ?? 15000;
+            await (0, util_1.sleep)(backoff + Math.random() * 1000);
+            if (o.signal?.aborted)
+                throw new CancelledError();
+        }
+    }
+    throw lastErr;
+}
+async function chatOnce(cfg, o) {
+    const provider = providerOf(cfg);
+    if (!cfg.apiKey && provider.keyRequired) {
+        throw new ApiError(401, `No ${provider.label} API key configured. Run \`swarm config set apiKey ...\` or open Settings in the UI.`);
+    }
+    if (o.signal?.aborted)
+        throw new CancelledError();
+    // DeepSeek's thinking protocol (the `thinking` body field + reasoning_content
+    // echo) is provider-specific; unknown body params are hard 400s elsewhere.
+    const dsThinking = provider.deepseekThinking;
+    const body = {
+        model: o.model,
+        messages: sanitizeMessages(o.messages, o.thinking && dsThinking),
+        stream: true,
+        stream_options: { include_usage: true },
+        [provider.maxTokensParam]: o.maxTokens ?? 16384,
+    };
+    if (dsThinking)
+        body.thinking = { type: o.thinking ? "enabled" : "disabled" };
+    const effort = o.thinking ? (0, providers_1.mapEffort)(o.reasoningEffort, provider) : undefined;
+    if (effort)
+        body.reasoning_effort = effort;
+    if (o.tools?.length) {
+        body.tools = o.tools.map((t) => ({
+            type: "function",
+            function: { name: t.name, description: t.description, parameters: t.parameters },
+        }));
+        if (o.toolChoice === "none" ||
+            o.toolChoice === "auto" ||
+            o.toolChoice === "required" ||
+            o.toolChoice === undefined) {
+            body.tool_choice = o.toolChoice ?? "auto";
+        }
+        else {
+            body.tool_choice = { type: "function", function: { name: o.toolChoice } };
+        }
+    }
+    const ac = new AbortController();
+    const onOuterAbort = () => ac.abort();
+    o.signal?.addEventListener("abort", onOuterAbort, { once: true });
+    let lastActivity = Date.now();
+    const idleTimer = setInterval(() => {
+        if (Date.now() - lastActivity > cfg.idleTimeoutMs)
+            ac.abort();
+    }, 5000);
+    const hardTimer = setTimeout(() => ac.abort(), cfg.requestTimeoutMs);
+    try {
+        const base = cfg.baseUrl.replace(/\/+$/, "");
+        const headers = { "content-type": "application/json" };
+        if (cfg.apiKey)
+            headers.authorization = `Bearer ${cfg.apiKey}`;
+        if (cfg.provider === "openrouter")
+            headers["x-title"] = "agentswarm";
+        const res = await fetch(`${base}/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: ac.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new ApiError(res.status, text);
+        }
+        if (!res.body)
+            throw new ApiError(0, "empty response body");
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let content = "";
+        let reasoning = "";
+        let finishReason = "stop";
+        let usage = { promptTokens: 0, completionTokens: 0, cacheHitTokens: 0, cacheMissTokens: 0 };
+        const calls = new Map();
+        const handleLine = (line) => {
+            const s = line.trim();
+            if (!s.startsWith("data:"))
+                return;
+            const payload = s.slice(5).trim();
+            if (!payload || payload === "[DONE]")
+                return;
+            let chunk;
+            try {
+                chunk = JSON.parse(payload);
+            }
+            catch {
+                return;
+            }
+            if (chunk.usage)
+                usage = normalizeUsage(chunk.usage);
+            const choice = chunk.choices?.[0];
+            if (!choice)
+                return;
+            if (choice.finish_reason)
+                finishReason = choice.finish_reason;
+            const delta = choice.delta || {};
+            // reasoning_content: DeepSeek / MiniMax. reasoning: OpenRouter / LM Studio.
+            const think = typeof delta.reasoning_content === "string" && delta.reasoning_content
+                ? delta.reasoning_content
+                : typeof delta.reasoning === "string" && delta.reasoning
+                    ? delta.reasoning
+                    : "";
+            if (think) {
+                reasoning += think;
+                o.onDelta?.({ think });
+            }
+            if (typeof delta.content === "string" && delta.content) {
+                content += delta.content;
+                o.onDelta?.({ text: delta.content });
+            }
+            if (Array.isArray(delta.tool_calls)) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    const cur = calls.get(idx) ?? { id: "", name: "", args: "" };
+                    if (tc.id)
+                        cur.id = tc.id;
+                    if (tc.function?.name)
+                        cur.name = tc.function.name;
+                    if (tc.function?.arguments)
+                        cur.args += tc.function.arguments;
+                    calls.set(idx, cur);
+                }
+            }
+        };
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            lastActivity = Date.now();
+            buf += decoder.decode(value, { stream: true });
+            let nl;
+            while ((nl = buf.indexOf("\n")) >= 0) {
+                handleLine(buf.slice(0, nl));
+                buf = buf.slice(nl + 1);
+            }
+        }
+        if (buf)
+            handleLine(buf);
+        const toolCalls = [...calls.entries()]
+            .sort((a, b) => a[0] - b[0])
+            .map(([i, c]) => ({
+            id: c.id || `call_${i}`,
+            type: "function",
+            function: { name: c.name, arguments: c.args || "{}" },
+        }))
+            .filter((c) => c.function.name);
+        if (!usage.promptTokens && !usage.completionTokens) {
+            // Usage chunk missing — estimate so budgets still move.
+            const inChars = o.messages.reduce((n, m) => n + (m.content?.length ?? 0), 0);
+            const outChars = content.length + reasoning.length;
+            usage = {
+                promptTokens: Math.ceil(inChars / 3.5),
+                completionTokens: Math.ceil(outChars / 3.5),
+                cacheHitTokens: 0,
+                cacheMissTokens: Math.ceil(inChars / 3.5),
+            };
+        }
+        return { content, reasoning, toolCalls, finishReason, usage };
+    }
+    catch (e) {
+        if (o.signal?.aborted)
+            throw new CancelledError();
+        throw e;
+    }
+    finally {
+        clearInterval(idleTimer);
+        clearTimeout(hardTimer);
+        o.signal?.removeEventListener("abort", onOuterAbort);
+    }
+}
+function isFatalAuthError(e) {
+    if (e instanceof ApiError)
+        return e.status === 401 || e.status === 403;
+    if (e instanceof Error)
+        return /no \S+ api key/i.test(e.message);
+    return false;
+}
+/**
+ * Cheap auth preflight. Hits /models (no generation cost) and classifies the
+ * result so callers can give the operator an instant, clear error instead of a
+ * phantom run. Returns "ok" on success, "invalid" only on explicit 401/403,
+ * and "unknown" for anything else (never block on transient/unsupported).
+ */
+async function validateAuth(cfg) {
+    const provider = providerOf(cfg);
+    if (!cfg.apiKey && provider.keyRequired) {
+        return { status: "invalid", message: `No ${provider.label} API key configured.` };
+    }
+    try {
+        const base = cfg.baseUrl.replace(/\/+$/, "");
+        const headers = {};
+        if (cfg.apiKey)
+            headers.authorization = `Bearer ${cfg.apiKey}`;
+        const res = await fetch(`${base}/models`, {
+            headers,
+            signal: AbortSignal.timeout(12000),
+        });
+        if (res.ok)
+            return { status: "ok" };
+        const body = await res.text().catch(() => "");
+        if (res.status === 401 || res.status === 403) {
+            return { status: "invalid", message: extractApiMessage(body) || "API key rejected (401)." };
+        }
+        return { status: "unknown", message: `HTTP ${res.status}` };
+    }
+    catch (e) {
+        return { status: "unknown", message: (0, util_1.errMsg)(e) };
+    }
+}
+function extractApiMessage(body) {
+    try {
+        const j = JSON.parse(body);
+        return j?.error?.message || j?.message || "";
+    }
+    catch {
+        return body.slice(0, 200);
+    }
+}
+async function listModels(cfg) {
+    const base = cfg.baseUrl.replace(/\/+$/, "");
+    const headers = {};
+    if (cfg.apiKey)
+        headers.authorization = `Bearer ${cfg.apiKey}`;
+    const res = await fetch(`${base}/models`, {
+        headers,
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok)
+        throw new ApiError(res.status, await res.text().catch(() => ""));
+    const data = await res.json();
+    return (data.data || []).map((m) => m.id).filter(Boolean);
+}