swarmdo 1.58.24 → 1.58.31

package/.claude/helpers/statusline.cjs

@@ -642,7 +642,11 @@ function renderRateLimitSlot() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
-  let ver = '1.58.9';
+  // #1951: an explicit SWARMDO_VERSION override (set by the CLI wrapper) wins over
+  // every probe below, so the header can't silently revert to a stale baked default
+  // when a global/npx install layout hides package.json.
+  if (process.env.SWARMDO_VERSION) return process.env.SWARMDO_VERSION;
+  let ver = '1.58.24';
   try {
     const home = os.homedir();
     const pkgPaths = [
@@ -862,6 +866,10 @@ function generateJSON() {
   return Object.assign({}, d, {
     user: Object.assign({ name: git.name, gitBranch: git.gitBranch }, d.user || {}),
     git: { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
+    // #2195: surface the baked maxAgents denominator in the swarm object so the
+    // delegation contract (and its smoke) always sees swarm.maxAgents, even though
+    // 'hooks statusline --json' reports only the live activeSwarms/activeAgents.
+    swarm: Object.assign({ maxAgents: CONFIG.maxAgents }, d.swarm || {}),
     lastUpdated: new Date().toISOString(),
   });
 }

package/README.md

@@ -298,6 +298,7 @@ The recent release train added a full day-to-day operations layer around the swa
 | `swarmdo testreport` | **JUnit/TAP → failure digest** — turn raw test-result files into the exact failing test names + `file:line` + assertion messages, instead of scanning hundreds of log lines. The front-half of the test→fix loop: feed the failures straight into `repair`. Reads a file, a directory, or stdin; `--ci` exits 1 on any failure, `--format json`. Also an MCP tool (`testreport`). Deterministic |
 | `swarmdo integrations` (alias `integrate`) | **Use swarmdo from Codex CLI, GitHub Copilot CLI, and pi** — one command wires AGENTS.md + each CLI's MCP config (idempotent, dry-run first, never touches your Claude Code setup) |
 | OpenRouter model pool | **Let swarms pick from any models you configure** — declare tier-mapped OpenRouter models in `swarmdo.config.json`; the router Thompson-samples among them per task and the execution layer dispatches the winner |
+| `route serve` (run Claude Code on any model) | **A local Anthropic-compatible proxy** — `swarmdo route serve` + `ANTHROPIC_BASE_URL=http://127.0.0.1:3456` points Claude Code *itself* at your OpenRouter pool: full SSE streaming, tier routing, and per-model learned priors that favor what works for you. Run Claude Code on Llama/DeepSeek/Gemini/Qwen/etc. — no vendored proxy, no extra process |
 | `swarmdo changelog` (alias `notes`) | **Release notes from conventional commits** — `--out NOTES.md` feeds `gh release create --notes-file`; `--contributors` appends a credited contributor roll |
 | `swarmdo mcp doctor` | **MCP config diagnosis** — missing binaries, bad URLs, malformed entries across `.mcp.json` + `~/.claude.json` |
 | `swarmdo config lint` | **Static config validation** — the pure shape layer for `swarmdo.config.json`, the `.claude/settings*.json` hooks block, `.mcp.json`, **`.claude/agents/*.md` subagents** (missing `name`/`description`, a `name` duplicated across files — CC silently loads only one — a bad `model`, malformed frontmatter), and **custom slash commands + skills** (malformed YAML that makes CC load empty metadata, a bad `effort`, an inline `` !`cmd` `` bash-injection that's inert or not covered by `allowed-tools`). `--strict` gates CI |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmdo",
-  "version": "1.58.24",
+  "version": "1.58.31",
   "description": "Swarmdo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@swarmdo/cli/.claude/helpers/statusline.cjs

@@ -642,7 +642,11 @@ function renderRateLimitSlot() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
-  let ver = '1.58.9';
+  // #1951: an explicit SWARMDO_VERSION override (set by the CLI wrapper) wins over
+  // every probe below, so the header can't silently revert to a stale baked default
+  // when a global/npx install layout hides package.json.
+  if (process.env.SWARMDO_VERSION) return process.env.SWARMDO_VERSION;
+  let ver = '1.58.24';
   try {
     const home = os.homedir();
     const pkgPaths = [
@@ -862,6 +866,10 @@ function generateJSON() {
   return Object.assign({}, d, {
     user: Object.assign({ name: git.name, gitBranch: git.gitBranch }, d.user || {}),
     git: { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
+    // #2195: surface the baked maxAgents denominator in the swarm object so the
+    // delegation contract (and its smoke) always sees swarm.maxAgents, even though
+    // 'hooks statusline --json' reports only the live activeSwarms/activeAgents.
+    swarm: Object.assign({ maxAgents: CONFIG.maxAgents }, d.swarm || {}),
     lastUpdated: new Date().toISOString(),
   });
 }

package/v3/@swarmdo/cli/dist/src/commands/route.js

@@ -736,6 +736,67 @@ const coverageRouteCommand = {
 // ============================================================================
 // Main Route Command
 // ============================================================================
+const serveCommand = {
+    name: 'serve',
+    description: 'Start a local Anthropic-compatible model-router proxy (point Claude Code at it via ANTHROPIC_BASE_URL)',
+    options: [
+        { name: 'port', short: 'p', description: 'Port to listen on', type: 'number', default: 3456 },
+        { name: 'host', description: 'Host to bind', type: 'string', default: '127.0.0.1' },
+    ],
+    examples: [
+        { command: 'swarmdo route serve', description: 'Start the router proxy on 127.0.0.1:3456' },
+        { command: 'ANTHROPIC_BASE_URL=http://127.0.0.1:3456 claude', description: 'Point Claude Code at the proxy' },
+    ],
+    action: async (ctx) => {
+        const { loadOpenRouterConfig } = await import('../providers/openrouter-config.js');
+        const { startProxy, loadPriors, savePriors, recordOutcome } = await import('../route-serve/proxy.js');
+        const { config, warnings } = loadOpenRouterConfig(process.cwd());
+        for (const w of warnings)
+            output.printWarning(w);
+        if (!config.enabled || config.models.length === 0) {
+            output.printError('OpenRouter pool is not configured.');
+            output.writeln(output.dim('  Add an `openrouter` block to swarmdo.config.json — e.g.'));
+            output.writeln(output.dim('  {"openrouter":{"enabled":true,"models":[{"id":"meta-llama/llama-3.3-70b-instruct","tier":"sonnet"}]}}'));
+            return { success: false, exitCode: 1, message: 'openrouter pool not configured' };
+        }
+        const apiKey = process.env[config.apiKeyEnv];
+        if (!apiKey) {
+            output.printError(`Missing API key — set ${config.apiKeyEnv} in the environment.`);
+            return { success: false, exitCode: 1, message: `missing ${config.apiKeyEnv}` };
+        }
+        const port = Number(ctx.flags.port ?? 3456);
+        const host = String(ctx.flags.host ?? '127.0.0.1');
+        const cwd = process.cwd();
+        const priors = loadPriors(cwd); // learned per-slug Beta priors from prior runs
+        let saveTimer = null;
+        const scheduleSave = () => {
+            if (saveTimer)
+                return;
+            saveTimer = setTimeout(() => { saveTimer = null; savePriors(priors, cwd); }, 2000);
+        };
+        const { server, url } = await startProxy({
+            cfg: config,
+            apiKey,
+            port,
+            host,
+            priors,
+            onOutcome: (model, success) => { Object.assign(priors, recordOutcome(priors, model, success)); scheduleSave(); },
+            log: (m) => output.writeln(output.dim(`  ${m}`)),
+        });
+        const tiers = [...new Set(config.models.map((m) => m.tier).filter(Boolean))].join('/');
+        output.printSuccess(`swarmdo route serve — listening on ${url}`);
+        output.writeln(`  pool: ${config.models.length} model(s)${tiers ? ` · tiers ${tiers}` : ''}`);
+        output.writeln(output.bold(`  ANTHROPIC_BASE_URL=${url} claude`));
+        output.writeln(output.dim('  Ctrl-C to stop.'));
+        // Run until interrupted (SIGINT/SIGTERM), then close the listener cleanly.
+        await new Promise((resolve) => {
+            const stop = () => { savePriors(priors, cwd); server.close(() => resolve()); };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        return { success: true };
+    },
+};
 export const routeCommand = {
     name: 'route',
     description: 'Intelligent task-to-agent routing using Q-Learning',
@@ -748,6 +809,7 @@ export const routeCommand = {
         exportCommand,
         importCommand,
         coverageRouteCommand,
+        serveCommand,
     ],
     options: [
         {

package/v3/@swarmdo/cli/dist/src/init/statusline-generator.js

@@ -703,6 +703,10 @@ function renderRateLimitSlot() {
 // misses, the displayed version is meaningful (matches what the user
 // installed), not a stale hard-coded string.
 function getPkgVersion() {
+  // #1951: an explicit SWARMDO_VERSION override (set by the CLI wrapper) wins over
+  // every probe below, so the header can't silently revert to a stale baked default
+  // when a global/npx install layout hides package.json.
+  if (process.env.SWARMDO_VERSION) return process.env.SWARMDO_VERSION;
   let ver = '${BAKED_CLI_VERSION}';
   try {
     const home = os.homedir();
@@ -923,6 +927,10 @@ function generateJSON() {
   return Object.assign({}, d, {
     user: Object.assign({ name: git.name, gitBranch: git.gitBranch }, d.user || {}),
     git: { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
+    // #2195: surface the baked maxAgents denominator in the swarm object so the
+    // delegation contract (and its smoke) always sees swarm.maxAgents, even though
+    // 'hooks statusline --json' reports only the live activeSwarms/activeAgents.
+    swarm: Object.assign({ maxAgents: CONFIG.maxAgents }, d.swarm || {}),
     lastUpdated: new Date().toISOString(),
   });
 }

package/v3/@swarmdo/cli/dist/src/route-serve/proxy.d.ts

@@ -0,0 +1,168 @@
+/**
+ * route-serve/proxy.ts — a lightweight, Anthropic-compatible model-router proxy.
+ *
+ * `swarmdo route serve` starts this on 127.0.0.1:PORT. Point Claude Code (or any
+ * Anthropic client) at it with `ANTHROPIC_BASE_URL=http://127.0.0.1:PORT` and it
+ * routes each `/v1/messages` request to an OpenRouter model chosen from the
+ * user's configured pool (swarmdo.config.json `openrouter`), translating the
+ * Anthropic <-> OpenAI-compatible request/response shapes.
+ *
+ * Deliberately built on swarmdo's existing pieces — no vendored proxy, no new
+ * deps beyond Node's own `http`:
+ *   - model selection: resolveOpenRouterModel() with Thompson-sampled `priors`
+ *     (== learned routing) from providers/openrouter-config.
+ *   - resilience: computeBackoffMs / isRetryableError / sleep from resilience/backoff.
+ *
+ * The only new surface is the HTTP serving layer + request/response translation,
+ * both kept PURE and fixture-tested (see __tests__/route-serve-proxy.test.ts).
+ *
+ * INCREMENT 1: non-streaming (forwards `stream:false` upstream and returns a
+ * single Anthropic message). Incremental SSE streaming is increment 2; until
+ * then a client that asked for stream still gets a correct, complete response
+ * (buffered), just not token-by-token.
+ */
+import { type Server, type ServerResponse } from 'node:http';
+import type { OpenRouterConfig, RoutingTier } from '../providers/openrouter-config.js';
+export interface AnthropicContentBlock {
+    type: string;
+    text?: string;
+    [k: string]: unknown;
+}
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicRequest {
+    model?: string;
+    messages: AnthropicMessage[];
+    system?: string | AnthropicContentBlock[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stream?: boolean;
+}
+export interface OpenAIChatRequest {
+    model: string;
+    messages: Array<{
+        role: 'system' | 'user' | 'assistant';
+        content: string;
+    }>;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stream?: boolean;
+}
+export interface OpenAIChatResponse {
+    id?: string;
+    choices?: Array<{
+        message?: {
+            content?: string;
+        };
+        finish_reason?: string;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    };
+}
+/** Claude Code sends model ids like 'claude-3-5-haiku…', 'claude-sonnet-4…',
+ *  'claude-opus-4…'. Map by family; unknown → 'sonnet' (the safe middle tier). */
+export declare function tierForRequest(body: Pick<AnthropicRequest, 'model'>): RoutingTier;
+export declare function flattenContent(content: AnthropicMessage['content']): string;
+export declare function anthropicToOpenAI(body: AnthropicRequest, model: string): OpenAIChatRequest;
+export declare function openAIToAnthropic(resp: OpenAIChatResponse, model: string): Record<string, unknown>;
+export interface Priors {
+    [modelId: string]: {
+        alpha: number;
+        beta: number;
+    };
+}
+export declare function selectModelForRequest(body: AnthropicRequest, cfg: OpenRouterConfig, priors?: Priors): {
+    model: string;
+    source: string;
+    tier: RoutingTier;
+} | null;
+/** Pure: fold one outcome into a Beta prior (success → α+1, failure → β+1). */
+export declare function betaUpdate(prior: {
+    alpha: number;
+    beta: number;
+} | undefined, success: boolean): {
+    alpha: number;
+    beta: number;
+};
+/** Pure: fold one outcome for `model` into a priors map, returning a new map. */
+export declare function recordOutcome(priors: Priors, model: string, success: boolean): Priors;
+export declare function loadPriors(cwd?: string): Priors;
+export declare function savePriors(priors: Priors, cwd?: string): void;
+export interface ForwardDeps {
+    cfg: OpenRouterConfig;
+    apiKey: string;
+    fetchImpl?: typeof fetch;
+    maxRetries?: number;
+}
+export declare function forwardChat(openaiReq: OpenAIChatRequest, deps: ForwardDeps): Promise<OpenAIChatResponse>;
+export interface ProxyOptions {
+    cfg: OpenRouterConfig;
+    apiKey: string;
+    port?: number;
+    host?: string;
+    priors?: Priors;
+    /** injectable for tests; defaults to global fetch */
+    fetchImpl?: typeof fetch;
+    /** retry budget per upstream call (default 2) */
+    maxRetries?: number;
+    /** called after each request with the chosen model + whether it succeeded — drives learned priors */
+    onOutcome?: (model: string, success: boolean) => void;
+    log?: (msg: string) => void;
+}
+/** Orchestrate one /v1/messages request. Returns an HTTP status + Anthropic-shaped body. */
+export declare function handleMessages(body: AnthropicRequest, opts: ProxyOptions): Promise<{
+    status: number;
+    json: unknown;
+}>;
+export interface SSEEvent {
+    event: string;
+    data: unknown;
+}
+/** Serialize one Anthropic SSE event to the wire format (`event:`/`data:` + blank line). */
+export declare function serializeSSE(e: SSEEvent): string;
+export interface OpenAIStreamChunk {
+    id?: string;
+    choices?: Array<{
+        delta?: {
+            content?: string;
+            role?: string;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        completion_tokens?: number;
+        prompt_tokens?: number;
+    };
+}
+/** Pure: the opening events for an Anthropic streamed message. */
+export declare function messageStartEvents(model: string, inputTokens?: number, id?: string): SSEEvent[];
+/** Pure: one text delta event. */
+export declare function textDeltaEvent(text: string): SSEEvent;
+/** Pure: the closing events, mapping the OpenAI finish_reason to an Anthropic stop_reason. */
+export declare function messageStopEvents(finishReason: string | null | undefined, outputTokens: number): SSEEvent[];
+/** Pure: a full OpenAI streaming-chunk list -> the ordered Anthropic SSE events. */
+export declare function translateOpenAIStream(chunks: OpenAIStreamChunk[], model: string): SSEEvent[];
+/** Pure: pull complete `data:` JSON chunks out of an accumulating SSE buffer, keeping the incomplete tail. */
+export declare function parseSSEBuffer(buffer: string): {
+    chunks: OpenAIStreamChunk[];
+    done: boolean;
+    rest: string;
+};
+/** Forward with `stream:true` and yield decoded OpenAI stream chunks. */
+export declare function forwardChatStream(openaiReq: OpenAIChatRequest, deps: ForwardDeps): AsyncGenerator<OpenAIStreamChunk>;
+/** Handle a streaming /v1/messages request by writing Anthropic SSE to `res`. */
+export declare function handleStreamingMessages(body: AnthropicRequest, opts: ProxyOptions, res: ServerResponse): Promise<void>;
+export declare function createProxyServer(opts: ProxyOptions): Server;
+/** Start the proxy; resolves with the bound port + base URL to set ANTHROPIC_BASE_URL to. */
+export declare function startProxy(opts: ProxyOptions): Promise<{
+    server: Server;
+    port: number;
+    url: string;
+}>;
+//# sourceMappingURL=proxy.d.ts.map

package/v3/@swarmdo/cli/dist/src/route-serve/proxy.js

@@ -0,0 +1,411 @@
+/**
+ * route-serve/proxy.ts — a lightweight, Anthropic-compatible model-router proxy.
+ *
+ * `swarmdo route serve` starts this on 127.0.0.1:PORT. Point Claude Code (or any
+ * Anthropic client) at it with `ANTHROPIC_BASE_URL=http://127.0.0.1:PORT` and it
+ * routes each `/v1/messages` request to an OpenRouter model chosen from the
+ * user's configured pool (swarmdo.config.json `openrouter`), translating the
+ * Anthropic <-> OpenAI-compatible request/response shapes.
+ *
+ * Deliberately built on swarmdo's existing pieces — no vendored proxy, no new
+ * deps beyond Node's own `http`:
+ *   - model selection: resolveOpenRouterModel() with Thompson-sampled `priors`
+ *     (== learned routing) from providers/openrouter-config.
+ *   - resilience: computeBackoffMs / isRetryableError / sleep from resilience/backoff.
+ *
+ * The only new surface is the HTTP serving layer + request/response translation,
+ * both kept PURE and fixture-tested (see __tests__/route-serve-proxy.test.ts).
+ *
+ * INCREMENT 1: non-streaming (forwards `stream:false` upstream and returns a
+ * single Anthropic message). Incremental SSE streaming is increment 2; until
+ * then a client that asked for stream still gets a correct, complete response
+ * (buffered), just not token-by-token.
+ */
+import { createServer } from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveOpenRouterModel } from '../providers/openrouter-config.js';
+import { computeBackoffMs, isRetryableError, sleep } from '../resilience/backoff.js';
+// ── Pure: map an Anthropic model hint to one of our pool tiers ────────────────
+/** Claude Code sends model ids like 'claude-3-5-haiku…', 'claude-sonnet-4…',
+ *  'claude-opus-4…'. Map by family; unknown → 'sonnet' (the safe middle tier). */
+export function tierForRequest(body) {
+    const m = (body.model || '').toLowerCase();
+    if (m.includes('haiku'))
+        return 'haiku';
+    if (m.includes('opus'))
+        return 'opus';
+    return 'sonnet';
+}
+// ── Pure: flatten Anthropic content (string | text blocks) to a plain string ──
+export function flattenContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('\n');
+}
+// ── Pure: Anthropic /v1/messages request -> OpenAI /v1/chat/completions ────────
+export function anthropicToOpenAI(body, model) {
+    const messages = [];
+    const system = typeof body.system === 'string'
+        ? body.system
+        : Array.isArray(body.system)
+            ? body.system.filter((b) => b?.text).map((b) => b.text).join('\n')
+            : '';
+    if (system)
+        messages.push({ role: 'system', content: system });
+    for (const m of body.messages || []) {
+        messages.push({ role: m.role, content: flattenContent(m.content) });
+    }
+    return {
+        model,
+        messages,
+        max_tokens: body.max_tokens,
+        temperature: body.temperature,
+        top_p: body.top_p,
+        stream: false,
+    };
+}
+// ── Pure: OpenAI chat response -> Anthropic /v1/messages response ─────────────
+const STOP_MAP = {
+    stop: 'end_turn',
+    length: 'max_tokens',
+    tool_calls: 'tool_use',
+    content_filter: 'end_turn',
+};
+export function openAIToAnthropic(resp, model) {
+    const choice = resp?.choices?.[0] ?? {};
+    const text = choice?.message?.content ?? '';
+    const usage = resp?.usage ?? {};
+    return {
+        id: resp?.id ? `msg_${resp.id}` : `msg_${model}`,
+        type: 'message',
+        role: 'assistant',
+        model,
+        content: [{ type: 'text', text: typeof text === 'string' ? text : '' }],
+        stop_reason: STOP_MAP[choice?.finish_reason ?? 'stop'] ?? 'end_turn',
+        stop_sequence: null,
+        usage: {
+            input_tokens: usage?.prompt_tokens ?? 0,
+            output_tokens: usage?.completion_tokens ?? 0,
+        },
+    };
+}
+export function selectModelForRequest(body, cfg, priors) {
+    const tier = tierForRequest(body);
+    const picked = resolveOpenRouterModel({ requested: body.model, tier, cfg, priors });
+    return picked ? { ...picked, tier } : null;
+}
+// ── Learned routing (increment 3): per-slug Beta priors ───────────────────────
+// resolveOpenRouterModel Thompson-samples over these, so models that succeed
+// more get picked more. Mirrors the α=successes / β=failures scheme in
+// swarmvector/model-router.ts, but keyed by OpenRouter slug (the pool's unit)
+// rather than by tier. Persisted to .swarm/route-serve-priors.json so learning
+// survives restarts.
+/** Pure: fold one outcome into a Beta prior (success → α+1, failure → β+1). */
+export function betaUpdate(prior, success) {
+    const p = prior ?? { alpha: 1, beta: 1 };
+    return success ? { alpha: p.alpha + 1, beta: p.beta } : { alpha: p.alpha, beta: p.beta + 1 };
+}
+/** Pure: fold one outcome for `model` into a priors map, returning a new map. */
+export function recordOutcome(priors, model, success) {
+    return { ...priors, [model]: betaUpdate(priors[model], success) };
+}
+const PRIORS_REL = path.join('.swarm', 'route-serve-priors.json');
+export function loadPriors(cwd = process.cwd()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(cwd, PRIORS_REL), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function savePriors(priors, cwd = process.cwd()) {
+    try {
+        fs.mkdirSync(path.join(cwd, '.swarm'), { recursive: true });
+        fs.writeFileSync(path.join(cwd, PRIORS_REL), JSON.stringify(priors, null, 2));
+    }
+    catch {
+        /* best-effort — learning is an optimization, never a hard dependency */
+    }
+}
+export async function forwardChat(openaiReq, deps) {
+    const doFetch = deps.fetchImpl ?? fetch;
+    const url = `${deps.cfg.baseUrl.replace(/\/$/, '')}/v1/chat/completions`;
+    const maxRetries = deps.maxRetries ?? 2;
+    let lastErr = '';
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        if (attempt > 0)
+            await sleep(computeBackoffMs(attempt - 1));
+        try {
+            const res = await doFetch(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${deps.apiKey}`,
+                    'HTTP-Referer': 'https://swarmdo.com',
+                    'X-Title': 'swarmdo route serve',
+                },
+                body: JSON.stringify(openaiReq),
+            });
+            if (res.ok)
+                return (await res.json());
+            lastErr = `${res.status} ${await res.text().catch(() => '')}`.trim();
+            // 4xx (except 429) is not worth retrying — the request itself is bad.
+            if (res.status < 500 && res.status !== 429)
+                break;
+        }
+        catch (e) {
+            lastErr = e.message;
+            if (!isRetryableError(lastErr))
+                break;
+        }
+    }
+    throw new Error(`OpenRouter forward failed after ${maxRetries + 1} attempt(s): ${lastErr}`);
+}
+/** Orchestrate one /v1/messages request. Returns an HTTP status + Anthropic-shaped body. */
+export async function handleMessages(body, opts) {
+    const sel = selectModelForRequest(body, opts.cfg, opts.priors);
+    if (!sel) {
+        return {
+            status: 503,
+            json: {
+                type: 'error',
+                error: {
+                    type: 'api_error',
+                    message: 'no OpenRouter model configured for this request — set `openrouter.enabled` + a model pool in swarmdo.config.json',
+                },
+            },
+        };
+    }
+    try {
+        const openaiReq = anthropicToOpenAI(body, sel.model);
+        const resp = await forwardChat(openaiReq, {
+            cfg: opts.cfg,
+            apiKey: opts.apiKey,
+            fetchImpl: opts.fetchImpl,
+            maxRetries: opts.maxRetries,
+        });
+        opts.onOutcome?.(sel.model, true);
+        opts.log?.(`routed ${body.model ?? '(default)'} → ${sel.model} [${sel.tier}] (${sel.source})`);
+        return { status: 200, json: openAIToAnthropic(resp, sel.model) };
+    }
+    catch (e) {
+        opts.onOutcome?.(sel.model, false);
+        return { status: 502, json: { type: 'error', error: { type: 'api_error', message: e.message } } };
+    }
+}
+/** Serialize one Anthropic SSE event to the wire format (`event:`/`data:` + blank line). */
+export function serializeSSE(e) {
+    return `event: ${e.event}\ndata: ${JSON.stringify(e.data)}\n\n`;
+}
+/** Pure: the opening events for an Anthropic streamed message. */
+export function messageStartEvents(model, inputTokens = 0, id = `msg_${model}`) {
+    return [
+        {
+            event: 'message_start',
+            data: {
+                type: 'message_start',
+                message: {
+                    id, type: 'message', role: 'assistant', model, content: [],
+                    stop_reason: null, stop_sequence: null,
+                    usage: { input_tokens: inputTokens, output_tokens: 0 },
+                },
+            },
+        },
+        { event: 'content_block_start', data: { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } } },
+    ];
+}
+/** Pure: one text delta event. */
+export function textDeltaEvent(text) {
+    return { event: 'content_block_delta', data: { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text } } };
+}
+/** Pure: the closing events, mapping the OpenAI finish_reason to an Anthropic stop_reason. */
+export function messageStopEvents(finishReason, outputTokens) {
+    const stop_reason = STOP_MAP[finishReason ?? 'stop'] ?? 'end_turn';
+    return [
+        { event: 'content_block_stop', data: { type: 'content_block_stop', index: 0 } },
+        { event: 'message_delta', data: { type: 'message_delta', delta: { stop_reason, stop_sequence: null }, usage: { output_tokens: outputTokens } } },
+        { event: 'message_stop', data: { type: 'message_stop' } },
+    ];
+}
+/** Pure: a full OpenAI streaming-chunk list -> the ordered Anthropic SSE events. */
+export function translateOpenAIStream(chunks, model) {
+    const events = [...messageStartEvents(model, chunks[0]?.usage?.prompt_tokens ?? 0)];
+    let finish = 'stop';
+    let outputTokens = 0;
+    for (const c of chunks) {
+        const choice = c.choices?.[0];
+        const text = choice?.delta?.content;
+        if (typeof text === 'string' && text.length)
+            events.push(textDeltaEvent(text));
+        if (choice?.finish_reason)
+            finish = choice.finish_reason;
+        if (c.usage?.completion_tokens != null)
+            outputTokens = c.usage.completion_tokens;
+    }
+    events.push(...messageStopEvents(finish, outputTokens));
+    return events;
+}
+/** Pure: pull complete `data:` JSON chunks out of an accumulating SSE buffer, keeping the incomplete tail. */
+export function parseSSEBuffer(buffer) {
+    const chunks = [];
+    let done = false;
+    const lines = buffer.split('\n');
+    const rest = lines.pop() ?? ''; // possibly-incomplete final line
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t.startsWith('data:'))
+            continue;
+        const payload = t.slice(5).trim();
+        if (payload === '[DONE]') {
+            done = true;
+            continue;
+        }
+        if (!payload)
+            continue;
+        try {
+            chunks.push(JSON.parse(payload));
+        }
+        catch { /* incomplete/keepalive — skip */ }
+    }
+    return { chunks, done, rest };
+}
+/** Forward with `stream:true` and yield decoded OpenAI stream chunks. */
+export async function* forwardChatStream(openaiReq, deps) {
+    const doFetch = deps.fetchImpl ?? fetch;
+    const url = `${deps.cfg.baseUrl.replace(/\/$/, '')}/v1/chat/completions`;
+    const res = await doFetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${deps.apiKey}`,
+            'HTTP-Referer': 'https://swarmdo.com',
+            'X-Title': 'swarmdo route serve',
+        },
+        body: JSON.stringify({ ...openaiReq, stream: true }),
+    });
+    if (!res.ok || !res.body) {
+        const detail = res.text ? await res.text().catch(() => '') : '';
+        throw new Error(`OpenRouter stream failed: ${res.status} ${detail}`.trim());
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const parsed = parseSSEBuffer(buffer);
+        buffer = parsed.rest;
+        for (const c of parsed.chunks)
+            yield c;
+        if (parsed.done)
+            return;
+    }
+}
+/** Handle a streaming /v1/messages request by writing Anthropic SSE to `res`. */
+export async function handleStreamingMessages(body, opts, res) {
+    const sel = selectModelForRequest(body, opts.cfg, opts.priors);
+    if (!sel) {
+        const json = { type: 'error', error: { type: 'api_error', message: 'no OpenRouter model configured for this request' } };
+        const buf = Buffer.from(JSON.stringify(json));
+        res.writeHead(503, { 'content-type': 'application/json', 'content-length': String(buf.length) });
+        res.end(buf);
+        return;
+    }
+    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
+    const write = (e) => { res.write(serializeSSE(e)); };
+    try {
+        const openaiReq = anthropicToOpenAI(body, sel.model);
+        let started = false;
+        let finish = 'stop';
+        let outputTokens = 0;
+        for await (const chunk of forwardChatStream(openaiReq, { cfg: opts.cfg, apiKey: opts.apiKey, fetchImpl: opts.fetchImpl })) {
+            if (!started) {
+                for (const e of messageStartEvents(sel.model, chunk.usage?.prompt_tokens ?? 0))
+                    write(e);
+                started = true;
+            }
+            const text = chunk.choices?.[0]?.delta?.content;
+            if (typeof text === 'string' && text.length)
+                write(textDeltaEvent(text));
+            if (chunk.choices?.[0]?.finish_reason)
+                finish = chunk.choices[0].finish_reason;
+            if (chunk.usage?.completion_tokens != null)
+                outputTokens = chunk.usage.completion_tokens;
+        }
+        if (!started)
+            for (const e of messageStartEvents(sel.model))
+                write(e);
+        for (const e of messageStopEvents(finish, outputTokens))
+            write(e);
+        opts.onOutcome?.(sel.model, true);
+        opts.log?.(`streamed ${body.model ?? '(default)'} → ${sel.model} [${sel.tier}] (${sel.source})`);
+    }
+    catch (e) {
+        opts.onOutcome?.(sel.model, false);
+        write({ event: 'error', data: { type: 'error', error: { type: 'api_error', message: e.message } } });
+    }
+    finally {
+        res.end();
+    }
+}
+function readBody(req, limitBytes = 20 * 1024 * 1024) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', (c) => {
+            data += c;
+            if (data.length > limitBytes)
+                reject(new Error('request body too large'));
+        });
+        req.on('end', () => resolve(data));
+        req.on('error', reject);
+    });
+}
+export function createProxyServer(opts) {
+    return createServer(async (req, res) => {
+        const send = (status, json) => {
+            const buf = Buffer.from(JSON.stringify(json));
+            res.writeHead(status, { 'content-type': 'application/json', 'content-length': String(buf.length) });
+            res.end(buf);
+        };
+        try {
+            if (req.method === 'GET' && (req.url === '/health' || req.url === '/')) {
+                return send(200, { ok: true, service: 'swarmdo route serve', pool: opts.cfg.models.length });
+            }
+            if (req.method === 'POST' && req.url?.startsWith('/v1/messages')) {
+                const body = JSON.parse(await readBody(req));
+                if (body.stream)
+                    return void (await handleStreamingMessages(body, opts, res));
+                const { status, json } = await handleMessages(body, opts);
+                return send(status, json);
+            }
+            send(404, { type: 'error', error: { type: 'not_found_error', message: `no route for ${req.method} ${req.url}` } });
+        }
+        catch (e) {
+            send(400, { type: 'error', error: { type: 'invalid_request_error', message: e.message } });
+        }
+    });
+}
+/** Start the proxy; resolves with the bound port + base URL to set ANTHROPIC_BASE_URL to. */
+export function startProxy(opts) {
+    const host = opts.host ?? '127.0.0.1';
+    const wantPort = opts.port ?? 3456;
+    const server = createProxyServer(opts);
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(wantPort, host, () => {
+            const addr = server.address();
+            const port = typeof addr === 'object' && addr ? addr.port : wantPort;
+            resolve({ server, port, url: `http://${host}:${port}` });
+        });
+    });
+}
+//# sourceMappingURL=proxy.js.map

package/v3/@swarmdo/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmdo/cli",
-  "version": "1.58.24",
+  "version": "1.58.31",
   "type": "module",
   "description": "Swarmdo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",