@robzilla1738/agentswarm 0.2.0

package/dist/journal.js

@@ -0,0 +1,152 @@
+"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.Journal = void 0;
+exports.eventsFile = eventsFile;
+exports.readEvents = readEvents;
+exports.lastSeq = lastSeq;
+exports.readNewEvents = readNewEvents;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Append-only event journal. events.jsonl is the single source of truth for a
+ * run: the executor writes it, the terminal renderer and the hub (web UI) read
+ * and tail it. Tolerant of a torn final line after a crash.
+ */
+class Journal {
+    file;
+    seq;
+    chain = Promise.resolve();
+    onEvent;
+    constructor(runDirPath, startSeq) {
+        this.file = path.join(runDirPath, "events.jsonl");
+        this.seq = startSeq ?? lastSeq(runDirPath) + 1;
+    }
+    append(type, payload = {}) {
+        const ev = { seq: this.seq++, t: Date.now(), type, ...payload };
+        const line = JSON.stringify(ev) + "\n";
+        this.chain = this.chain
+            .then(() => fs.promises.appendFile(this.file, line, "utf8"))
+            .catch(() => {
+            /* never break the run on journal IO; next append retries the chain */
+        });
+        try {
+            this.onEvent?.(ev);
+        }
+        catch {
+            /* renderer errors must not kill the run */
+        }
+        return ev;
+    }
+    flush() {
+        return this.chain;
+    }
+}
+exports.Journal = Journal;
+function eventsFile(runDirPath) {
+    return path.join(runDirPath, "events.jsonl");
+}
+function readEvents(runDirPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(eventsFile(runDirPath), "utf8");
+    }
+    catch {
+        return [];
+    }
+    return parseLines(raw).events;
+}
+function lastSeq(runDirPath) {
+    const evs = readEvents(runDirPath);
+    return evs.length ? evs[evs.length - 1].seq : 0;
+}
+/** Incremental read for tailing; handles partially written lines. */
+function readNewEvents(file, state) {
+    let stat;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        return [];
+    }
+    if (stat.size < state.offset) {
+        // Truncated/rewritten (should not happen) — start over.
+        state.offset = 0;
+        state.carry = "";
+    }
+    if (stat.size === state.offset)
+        return [];
+    const fd = fs.openSync(file, "r");
+    try {
+        const len = stat.size - state.offset;
+        const buf = Buffer.alloc(Math.min(len, 8 * 1024 * 1024));
+        let read = 0;
+        const out = [];
+        while (read < len) {
+            const n = fs.readSync(fd, buf, 0, Math.min(buf.length, len - read), state.offset + read);
+            if (n <= 0)
+                break;
+            read += n;
+            const text = state.carry + buf.toString("utf8", 0, n);
+            const parsed = parseLines(text, true);
+            state.carry = parsed.carry;
+            out.push(...parsed.events);
+        }
+        state.offset += read;
+        return out;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function parseLines(text, keepCarry = false) {
+    const events = [];
+    const lines = text.split("\n");
+    const carry = keepCarry ? lines.pop() ?? "" : "";
+    for (const line of lines) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const ev = JSON.parse(s);
+            if (ev && typeof ev.type === "string")
+                events.push(ev);
+        }
+        catch {
+            /* torn line — skip */
+        }
+    }
+    return { events, carry };
+}

package/dist/prompts.js

@@ -0,0 +1,232 @@
+"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.SYNTH_KICKOFF = exports.VERIFIER_KICKOFF = exports.STEP_LIMIT_FINAL = exports.NUDGE_USE_TOOLS = exports.WORKER_KICKOFF = void 0;
+exports.conductorSystem = conductorSystem;
+exports.conductorInitialUpdate = conductorInitialUpdate;
+exports.conductorUpdate = conductorUpdate;
+exports.taskTable = taskTable;
+exports.reportBlock = reportBlock;
+exports.workerSystem = workerSystem;
+exports.forcedFinal = forcedFinal;
+exports.verifierSystem = verifierSystem;
+exports.synthSystem = synthSystem;
+exports.compactorPrompt = compactorPrompt;
+exports.budgetLine = budgetLine;
+const os = __importStar(require("os"));
+const util_1 = require("./util");
+// ============================================================ conductor
+function conductorSystem(meta) {
+    const o = meta.options;
+    return `You are the Conductor of an agent swarm — the lead intelligence that decomposes a mission into tasks and orchestrates many parallel worker agents to accomplish it. You never do the work yourself; you direct the swarm.
+
+MISSION
+${meta.mission}
+
+ENVIRONMENT
+- Working directory: ${meta.cwd}${meta.sandbox ? " (isolated sandbox created for this run)" : " (the operator's real directory — be purposeful)"}
+- OS: ${os.platform()} ${os.release()} · Node available · agents run shell with the operator's permissions
+- Date: ${new Date(meta.createdAt).toISOString().slice(0, 10)}
+
+HOW THE SWARM WORKS
+- spawn_tasks creates worker agents. Each worker is autonomous, with shell / file / web tools in the working directory, and runs up to ${o.maxStepsPerTask} tool steps.
+- Up to ${o.maxWorkers} tasks run in parallel. A task starts the moment all its deps are done.
+- Workers share NOTHING except: (1) what you write in their objective/context, (2) the final reports of their deps, (3) the shared blackboard digest. There is no other communication.
+- Task ids are assigned sequentially in the order you spawn them (you are told the next id). deps may reference any earlier-created task, including earlier tasks in the same spawn_tasks call.
+- When tasks settle you are woken with their reports and the swarm state; you then spawn more tasks, wait, or finish.
+
+DOCTRINE
+1. PARALLELIZE AGGRESSIVELY. Independent work = separate simultaneous tasks. Prefer 3–6 parallel scouts over one serial mega-task: wide first, then a consolidation task with deps.
+2. Make every task self-contained: crisp objective, explicit success criteria ("Done when …"), and every fact/path/URL the worker needs inlined in context. Workers know nothing you don't tell them.
+3. Invent the right specialist role per task (researcher, coder, analyst, data-wrangler, reviewer, writer, …). One concern per task, roughly 5–25 tool steps of work. Bigger → split it. Trivial → batch it.
+4. Software missions: scaffold first (one task), then parallel tasks on DISJOINT files/modules — never two writers on the same file — then an integration + test task that deps on all of them with verify:true.
+5. Research missions: parallel scouts with distinct angles and sources, then a consolidation/analysis task that deps on the scouts.
+6. Set verify:true on tasks whose failure would poison the mission (builds, integrations, data pipelines, final deliverables). A verification agent will adversarially check them and can fail them back for retry.
+7. React to evidence. Failed/blocked task → diagnose from its report and spawn a corrected or alternative approach (never re-run a failed approach verbatim). Surprising findings → adapt the plan.
+8. Watch the budget shown in every update. As it tightens, cut scope to what the mission truly needs — always deliver value before the cap, never run out mid-flight.
+9. Operator messages override everything. Adjust the plan immediately when one appears.
+10. finish only when the mission's success criteria are demonstrably met, or budget/feasibility forces it. Your finish notes steer the synthesizer that writes the final report.
+
+RULES
+- Respond ONLY by calling your tools (spawn_tasks / wait / finish). Plain-text replies are ignored.
+- Never spawn a task whose deps are not yet all created.
+- Keep the total task count within budget (max ${o.maxTasks} per run); make every task earn its place.`;
+}
+function conductorInitialUpdate(meta, nextId) {
+    return `The swarm is live. No tasks exist yet. Next task id: T${nextId}.
+
+Decompose the mission and spawn the first wave now. Remember: maximize useful parallelism; self-contained objectives with success criteria; inline all context workers need.`;
+}
+function conductorUpdate(p) {
+    const sections = [];
+    if (p.operatorNotes?.length) {
+        sections.push(`⚑ OPERATOR MESSAGES (these override the current plan):\n${p.operatorNotes.map((n) => `- ${n}`).join("\n")}`);
+    }
+    if (p.reports?.length)
+        sections.push(`NEW REPORTS\n${p.reports.join("\n\n")}`);
+    if (p.blackboard)
+        sections.push(`BLACKBOARD (shared notes digest)\n${p.blackboard}`);
+    sections.push(`SWARM STATE\n${p.taskTable}`);
+    sections.push(p.budgetLine);
+    if (p.extra)
+        sections.push(p.extra);
+    sections.push(`Next task id: T${p.nextId}. Decide now: spawn_tasks, wait, or finish.`);
+    return sections.join("\n\n");
+}
+function taskTable(tasks) {
+    if (!tasks.length)
+        return "(no tasks yet)";
+    return tasks
+        .map((t) => {
+        const deps = t.deps.length ? ` deps:[${t.deps.join(",")}]` : "";
+        const extra = t.status === "failed" && t.error ? ` — ${(0, util_1.clip)(t.error, 80)}` : "";
+        return `${t.id} [${t.status}${t.attempt > 1 ? ` a${t.attempt}` : ""}] (${t.role})${deps} ${(0, util_1.clip)(t.title, 70)}${extra}`;
+    })
+        .join("\n");
+}
+function reportBlock(t) {
+    const head = `── ${t.id} (${t.role}) "${(0, util_1.clip)(t.title, 60)}" → ${t.status.toUpperCase()}${t.attempt > 1 ? ` (attempt ${t.attempt})` : ""}`;
+    const body = t.report ? (0, util_1.clip)(t.report, 1600) : t.error ? `error: ${(0, util_1.clip)(t.error, 400)}` : "(no report)";
+    const arts = t.artifacts.length ? `\nartifacts: ${t.artifacts.join(", ")}` : "";
+    const fb = t.feedback ? `\nverifier: ${(0, util_1.clip)(t.feedback, 300)}` : "";
+    return `${head}\n${body}${arts}${fb}`;
+}
+// ============================================================ workers
+const ROLE_HINTS = {
+    researcher: "Research craft: triangulate across independent sources; prefer primary docs over blog spam; capture exact figures, dates, URLs. Search several distinct phrasings before concluding something is unfindable.",
+    coder: "Engineering craft: read existing code before changing it; match its conventions; build/run/test after every meaningful change and include the command + result in your report. Leave the tree compiling.",
+    analyst: "Analysis craft: quantify wherever possible; state assumptions explicitly; separate observation from interpretation; sanity-check numbers twice.",
+    writer: "Writing craft: structure before prose; concrete over abstract; cut filler. Match the audience and purpose given in the objective.",
+    reviewer: "Review craft: be adversarial; try to break it; check edge cases and the unhappy path; verify claims against the actual files, not the description.",
+    "data-wrangler": "Data craft: validate schema and row counts at every step; spot-check samples; never silently drop rows — report anomalies.",
+};
+function workerSystem(opts) {
+    const { meta, task } = opts;
+    const roleHint = ROLE_HINTS[opts.role.toLowerCase()] ?? "";
+    const retry = task.attempt > 1 && task.feedback
+        ? `\nPREVIOUS ATTEMPT FAILED VERIFICATION — fix exactly this:\n${task.feedback}\n`
+        : task.attempt > 1 && task.error
+            ? `\nPREVIOUS ATTEMPT FAILED: ${task.error}\nTake a different approach.\n`
+            : "";
+    return `You are ${opts.agentId}, a ${opts.role} agent in a swarm pursuing this mission:
+${meta.mission}
+
+YOUR TASK — ${task.id} (attempt ${task.attempt})
+${task.title}
+Objective: ${task.objective}
+${task.context ? `Context from the conductor:\n${task.context}\n` : ""}${retry}
+CONTEXT FROM THE SWARM
+${opts.depReports || "(no dependency reports)"}
+${opts.blackboard ? `Blackboard digest:\n${opts.blackboard}` : ""}
+${opts.operatorNotes.length ? `Operator notes:\n${opts.operatorNotes.map((n) => `- ${n}`).join("\n")}` : ""}
+Working directory: ${meta.cwd}
+${opts.dirListing ? `Top of the working directory:\n${opts.dirListing}` : ""}
+
+OPERATING PROTOCOL
+- You are fully autonomous. Never ask questions; decide and act.
+- Plan briefly, then act in small verified steps: after changing anything, prove it worked (run it, read it back, test it).
+- Evidence over assumption: read before you edit; check outputs; cite concrete paths, commands and numbers.
+- Be token-lean: targeted reads (line ranges, grep via shell) over wholesale dumps; don't re-read unchanged files.
+- Post durable discoveries other agents will need to the blackboard with note(...) — facts only, used sparingly.
+- Save deliverable files with save_artifact so the operator sees them.
+- Genuinely impossible / missing prerequisite → report(status:"blocked", …) early instead of thrashing.
+- You have at most ${opts.maxSteps} tool steps. Budget them.
+- ALWAYS end by calling report(...). The conductor sees ONLY that report — it is the entire value of your work. Specific beats vague: what you did, what you verified, key findings, exact paths.
+${roleHint ? "\n" + roleHint : ""}`;
+}
+exports.WORKER_KICKOFF = "Begin now. Work the task to completion, then call report(...).";
+exports.NUDGE_USE_TOOLS = "Reminder: act via tool calls only. Continue the work; when complete (or truly blocked), call report(...). Do not reply with plain text.";
+exports.STEP_LIMIT_FINAL = "You have hit the step limit. Call report(...) RIGHT NOW with your best honest account: what you completed, what you verified, what remains.";
+function forcedFinal(reason) {
+    return `${reason} Stop working and call your terminal tool RIGHT NOW with your best honest account: what you completed, what you verified, what remains.`;
+}
+// ============================================================ verifier
+function verifierSystem(meta, task) {
+    return `You are an adversarial verification agent. A worker claims it completed this task — your job is to try to falsify that claim with evidence.
+
+MISSION (for context): ${(0, util_1.clip)(meta.mission, 400)}
+
+TASK ${task.id}: ${task.title}
+Objective (with success criteria): ${task.objective}
+${task.context ? `Context: ${(0, util_1.clip)(task.context, 600)}` : ""}
+Worker's report:
+${(0, util_1.clip)(task.report ?? "", 2400)}
+${task.artifacts.length ? `Claimed artifacts: ${task.artifacts.join(", ")}` : ""}
+
+Working directory: ${meta.cwd}
+
+PROTOCOL
+- Do NOT trust the report. Verify concretely with tools: read the files it claims to have written, run the build/tests/commands, fetch the URLs, check the numbers.
+- Check: objective met? success criteria satisfied? deliverables exist and are non-trivial (not stubs/placeholders)?
+- Spot-check depth over exhaustive breadth; ~5-12 tool steps.
+- Then call verdict(pass, feedback). On fail, feedback must be actionable: exactly what is wrong and where. On pass, one line citing the evidence you checked.`;
+}
+exports.VERIFIER_KICKOFF = "Verify now, then call verdict(...).";
+// ============================================================ synthesizer
+function synthSystem(opts) {
+    return `You are the synthesis agent for a completed agent-swarm run. Compose the definitive final deliverable for the operator.
+
+MISSION
+${opts.meta.mission}
+
+RUN OUTCOME: ${opts.reason}
+Conductor's closing notes: ${opts.finishNotes || "(none)"}
+
+ALL TASK REPORTS
+${opts.reports}
+
+${opts.blackboard ? `BLACKBOARD\n${opts.blackboard}\n` : ""}${opts.artifactList ? `ARTIFACTS ON DISK\n${opts.artifactList}\n` : ""}
+Working directory: ${opts.meta.cwd}
+
+PROTOCOL
+- You may read files (read_file / list_dir) to confirm specifics before writing — verify key claims you repeat.
+- Then call submit_final with:
+  • report_markdown — the deliverable document. Structure: # title; **Outcome** first (did the mission succeed, headline results); then What was built/found with evidence and exact paths; How to use/run it (if applicable); Open issues & recommended next steps. Write for the operator: complete, concrete, zero filler.
+  • summary — ≤8 sentences for the console.
+- The report stands alone: a reader who saw nothing else must understand what happened and where everything is.`;
+}
+exports.SYNTH_KICKOFF = "Compose and submit the final deliverable now via submit_final(...).";
+// ============================================================ compaction
+function compactorPrompt(serialized) {
+    return `Compress this agent conversation segment into a dense progress summary the agent can rely on to continue working. Preserve: decisions made, files created/modified (exact paths), commands run and their outcomes, key findings/numbers/URLs, errors hit and how they were resolved, current state of the work, and anything still pending. Omit pleasantries and dead ends unless they prevent repeating a mistake. Output the summary only.
+
+SEGMENT
+${serialized}`;
+}
+// ============================================================ misc
+function budgetLine(spent, cap) {
+    const pct = cap > 0 ? Math.round((spent.total / cap) * 100) : 0;
+    return `BUDGET: ${(0, util_1.fmtTokens)(spent.total)} of ${(0, util_1.fmtTokens)(cap)} tokens used (${pct}%) · est. cost so far $${spent.cost.toFixed(2)}`;
+}

package/dist/providers.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_IDS = exports.PROVIDERS = void 0;
+exports.isProviderId = isProviderId;
+exports.mapEffort = mapEffort;
+exports.PROVIDERS = {
+    deepseek: {
+        id: "deepseek",
+        label: "DeepSeek",
+        baseUrl: "https://api.deepseek.com",
+        keyRequired: true,
+        keyEnv: "DEEPSEEK_API_KEY",
+        keyUrl: "https://platform.deepseek.com",
+        deepseekThinking: true,
+        efforts: ["high", "max"],
+        maxTokensParam: "max_tokens",
+        defaultModel: "deepseek-v4-flash",
+        knownModels: ["deepseek-v4-flash", "deepseek-v4-pro"],
+        note: "Cheapest frontier-grade swarm workers; prompt caching makes long runs very cheap.",
+    },
+    openai: {
+        id: "openai",
+        label: "OpenAI",
+        baseUrl: "https://api.openai.com/v1",
+        keyRequired: true,
+        keyEnv: "OPENAI_API_KEY",
+        keyUrl: "https://platform.openai.com/api-keys",
+        deepseekThinking: false,
+        efforts: ["low", "medium", "high"],
+        maxTokensParam: "max_completion_tokens",
+        defaultModel: "gpt-5.1-mini",
+        knownModels: ["gpt-5.1", "gpt-5.1-mini", "gpt-4.1", "gpt-4.1-mini"],
+    },
+    anthropic: {
+        id: "anthropic",
+        label: "Anthropic",
+        baseUrl: "https://api.anthropic.com/v1",
+        keyRequired: true,
+        keyEnv: "ANTHROPIC_API_KEY",
+        keyUrl: "https://console.anthropic.com/settings/keys",
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "claude-sonnet-4-6",
+        knownModels: ["claude-opus-4-8", "claude-sonnet-4-6", "claude-haiku-4-5"],
+        note: "Uses Anthropic's OpenAI-compatible endpoint.",
+    },
+    xai: {
+        id: "xai",
+        label: "xAI (Grok)",
+        baseUrl: "https://api.x.ai/v1",
+        keyRequired: true,
+        keyEnv: "XAI_API_KEY",
+        keyUrl: "https://console.x.ai",
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "grok-4-fast",
+        knownModels: ["grok-4", "grok-4-fast", "grok-3-mini"],
+    },
+    minimax: {
+        id: "minimax",
+        label: "MiniMax",
+        baseUrl: "https://api.minimax.io/v1",
+        keyRequired: true,
+        keyEnv: "MINIMAX_API_KEY",
+        keyUrl: "https://platform.minimax.io",
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "MiniMax-M2.1",
+        knownModels: ["MiniMax-M2.1", "MiniMax-M2"],
+        note: "Coding-plan / token-plan keys work here.",
+    },
+    openrouter: {
+        id: "openrouter",
+        label: "OpenRouter",
+        baseUrl: "https://openrouter.ai/api/v1",
+        keyRequired: true,
+        keyEnv: "OPENROUTER_API_KEY",
+        keyUrl: "https://openrouter.ai/keys",
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "deepseek/deepseek-chat",
+        knownModels: ["openrouter/auto", "deepseek/deepseek-chat", "anthropic/claude-sonnet-4.6", "openai/gpt-5.1-mini"],
+        note: "One key, every model. Use the full vendor/model id.",
+    },
+    ollama: {
+        id: "ollama",
+        label: "Ollama (local)",
+        baseUrl: "http://localhost:11434/v1",
+        keyRequired: false,
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "qwen3",
+        knownModels: ["qwen3", "llama3.3", "deepseek-r1", "gpt-oss:20b"],
+        local: true,
+        note: "Free + private. The models list shows what you have pulled.",
+    },
+    lmstudio: {
+        id: "lmstudio",
+        label: "LM Studio (local)",
+        baseUrl: "http://localhost:1234/v1",
+        keyRequired: false,
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "",
+        knownModels: [],
+        local: true,
+        note: "Start the LM Studio server, then pick a loaded model.",
+    },
+    custom: {
+        id: "custom",
+        label: "Custom endpoint",
+        baseUrl: "http://localhost:8000/v1",
+        keyRequired: false,
+        deepseekThinking: false,
+        efforts: [],
+        maxTokensParam: "max_tokens",
+        defaultModel: "",
+        knownModels: [],
+        note: "Any OpenAI-compatible /chat/completions server (vLLM, llama.cpp, …).",
+    },
+};
+exports.PROVIDER_IDS = Object.keys(exports.PROVIDERS);
+function isProviderId(v) {
+    return typeof v === "string" && v in exports.PROVIDERS;
+}
+/**
+ * Map the configured effort onto what the provider's API accepts.
+ * Returns undefined when the provider has no effort knob (omit the field —
+ * unknown body params are hard errors on several APIs).
+ */
+function mapEffort(effort, p) {
+    if (!effort || p.efforts.length === 0)
+        return undefined;
+    if (p.efforts.includes(effort))
+        return effort;
+    const ladder = ["low", "medium", "high", "max"];
+    const want = ladder.indexOf(effort);
+    // Nearest supported value, preferring the strongest at or below the ask.
+    const supported = [...p.efforts].sort((a, b) => ladder.indexOf(a) - ladder.indexOf(b));
+    for (let i = supported.length - 1; i >= 0; i--) {
+        if (ladder.indexOf(supported[i]) <= want)
+            return supported[i];
+    }
+    return supported[0];
+}