@mcoda/mswarm 0.1.0

package/dist/runtime.js

@@ -0,0 +1,842 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+const DEFAULT_GATEWAY_BASE_URL = "http://127.0.0.1:8080";
+const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+const DEFAULT_LISTEN_HOST = "127.0.0.1";
+const DEFAULT_LISTEN_PORT = 18083;
+const DEFAULT_HEARTBEAT_INTERVAL_SECONDS = 30;
+const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
+const DEFAULT_MCODA_BIN = "mcoda";
+const DEFAULT_MCODA_LIST_ARGS = ["agent", "list", "--json", "--refresh-health"];
+const DEFAULT_COMMAND_MAX_BUFFER = 16 * 1024 * 1024;
+function optionalText(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parsePositiveInteger(value, fallback) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : Number.NaN;
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return Math.floor(parsed);
+}
+function parseBoolean(value, fallback) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value !== "string")
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "1" || normalized === "true" || normalized === "yes")
+        return true;
+    if (normalized === "0" || normalized === "false" || normalized === "no")
+        return false;
+    return fallback;
+}
+function parseList(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => optionalText(entry)).filter((entry) => Boolean(entry));
+    }
+    if (typeof value !== "string") {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function parseArgs(value, fallback) {
+    const parsed = parseList(value);
+    return parsed.length > 0 ? parsed : fallback;
+}
+function parseDiscoveryMode(value) {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+    return normalized === "ollama" ? "ollama" : "mcoda";
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/g, "");
+}
+function defaultStatePath() {
+    return join(homedir(), ".mswarm", "self-hosted-node", "config.json");
+}
+function defaultRuntimeTokenPath() {
+    return join(homedir(), ".mswarm", "self-hosted-node", "node.key");
+}
+function isVisionModel(modelName, family) {
+    const normalized = `${modelName} ${family || ""}`.toLowerCase();
+    return normalized.includes("llava") || normalized.includes("vision") || normalized.includes("bakllava");
+}
+function isEmbeddingModel(modelName, family) {
+    const normalized = `${modelName} ${family || ""}`.toLowerCase();
+    return (normalized.includes("embed") ||
+        normalized.includes("embedding") ||
+        normalized.includes("nomic-bert") ||
+        normalized.includes("bert"));
+}
+function isEmbeddingUsage(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.toLowerCase();
+    return normalized.includes("embedding") || normalized.includes("embed") || normalized.includes("vector");
+}
+function optionalNumber(...values) {
+    for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return null;
+}
+function optionalBoolean(...values) {
+    for (const value of values) {
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return null;
+}
+function normalizeCapabilities(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value
+        .map((entry) => optionalText(entry))
+        .filter((entry) => Boolean(entry))));
+}
+function normalizeHealthStatus(value) {
+    const normalized = optionalText(value)?.toLowerCase();
+    if (normalized === "healthy")
+        return "healthy";
+    if (normalized === "degraded")
+        return "degraded";
+    if (normalized === "unreachable" || normalized === "unhealthy" || normalized === "offline") {
+        return "unreachable";
+    }
+    if (normalized === "blocked")
+        return "blocked";
+    return "unknown";
+}
+function isMswarmManagedCloudAgent(agent) {
+    const config = agent.config && typeof agent.config === "object" ? agent.config : {};
+    const mswarmCloud = config.mswarmCloud;
+    return Boolean(mswarmCloud &&
+        typeof mswarmCloud === "object" &&
+        mswarmCloud.managed === true);
+}
+function isModelExposed(modelName, family, config) {
+    if (config.modelBlocklist.includes(modelName)) {
+        return false;
+    }
+    if (isEmbeddingModel(modelName, family)) {
+        return false;
+    }
+    if (config.modelAllowlist.length > 0) {
+        return config.modelAllowlist.includes(modelName);
+    }
+    return config.exposeAllModels;
+}
+function isAgentExposed(agentSlug, defaultModel, bestUsage, config) {
+    const identities = [agentSlug, defaultModel].filter((value) => Boolean(value));
+    if (identities.some((identity) => config.modelBlocklist.includes(identity))) {
+        return false;
+    }
+    if (isEmbeddingUsage(bestUsage) || identities.some((identity) => isEmbeddingModel(identity))) {
+        return false;
+    }
+    if (config.modelAllowlist.length > 0) {
+        return identities.some((identity) => config.modelAllowlist.includes(identity));
+    }
+    return config.exposeAllModels;
+}
+async function fetchJson(fetchImpl, url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(`request_failed:${response.status}:${text.slice(0, 200)}`);
+        }
+        return (await response.json());
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function readSelfHostedNodeState(statePath) {
+    try {
+        const content = await readFile(statePath, "utf8");
+        const parsed = JSON.parse(content);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+export async function writeSelfHostedNodeState(statePath, state) {
+    await mkdir(dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+export async function readSelfHostedRuntimeToken(tokenPath) {
+    try {
+        const content = await readFile(tokenPath, "utf8");
+        const trimmed = content.trim();
+        return trimmed || null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeSelfHostedRuntimeToken(tokenPath, runtimeToken) {
+    await mkdir(dirname(tokenPath), { recursive: true });
+    await writeFile(tokenPath, `${runtimeToken.trim()}\n`, { encoding: "utf8", mode: 0o600 });
+}
+export async function readSelfHostedNodeConfig(env = process.env) {
+    const statePath = optionalText(env.MSWARM_SELF_HOSTED_NODE_STATE_PATH) || defaultStatePath();
+    const runtimeTokenPath = optionalText(env.MSWARM_SELF_HOSTED_NODE_KEY_PATH) || defaultRuntimeTokenPath();
+    const state = await readSelfHostedNodeState(statePath);
+    const persistedRuntimeToken = await readSelfHostedRuntimeToken(runtimeTokenPath);
+    const nodeId = optionalText(env.MSWARM_SELF_HOSTED_NODE_ID) || state.node_id || "";
+    if (!nodeId) {
+        throw new Error("MSWARM_SELF_HOSTED_NODE_ID is required");
+    }
+    const gatewayBaseUrl = optionalText(env.MSWARM_GATEWAY_BASE_URL) || state.gateway_base_url || DEFAULT_GATEWAY_BASE_URL;
+    const ollamaBaseUrl = optionalText(env.MSWARM_SELF_HOSTED_OLLAMA_BASE_URL) ||
+        state.ollama_base_url ||
+        optionalText(env.OLLAMA_HOST) ||
+        DEFAULT_OLLAMA_BASE_URL;
+    return {
+        gatewayBaseUrl: trimTrailingSlash(gatewayBaseUrl),
+        nodeId,
+        enrollmentToken: optionalText(env.MSWARM_SELF_HOSTED_ENROLLMENT_TOKEN),
+        runtimeToken: optionalText(env.MSWARM_SELF_HOSTED_RUNTIME_TOKEN) || persistedRuntimeToken || state.runtime_token || null,
+        discoveryMode: parseDiscoveryMode(env.MSWARM_SELF_HOSTED_DISCOVERY_MODE),
+        mcodaBin: optionalText(env.MSWARM_SELF_HOSTED_MCODA_BIN) || DEFAULT_MCODA_BIN,
+        mcodaListArgs: parseArgs(env.MSWARM_SELF_HOSTED_MCODA_LIST_ARGS, DEFAULT_MCODA_LIST_ARGS),
+        ollamaBaseUrl: trimTrailingSlash(ollamaBaseUrl),
+        statePath,
+        runtimeTokenPath,
+        invocationSigningSecret: optionalText(env.MSWARM_SELF_HOSTED_INVOCATION_SIGNING_SECRET) ||
+            optionalText(env.MSWARM_SELF_HOSTED_RELAY_SIGNING_SECRET),
+        listenHost: optionalText(env.MSWARM_SELF_HOSTED_LISTEN_HOST) || DEFAULT_LISTEN_HOST,
+        listenPort: parsePositiveInteger(env.MSWARM_SELF_HOSTED_LISTEN_PORT, DEFAULT_LISTEN_PORT),
+        nodeVersion: optionalText(env.MSWARM_SELF_HOSTED_NODE_VERSION) || "0.1.0",
+        heartbeatIntervalSeconds: parsePositiveInteger(env.MSWARM_SELF_HOSTED_HEARTBEAT_INTERVAL_SECONDS, state.heartbeat_interval_seconds || DEFAULT_HEARTBEAT_INTERVAL_SECONDS),
+        requestTimeoutMs: parsePositiveInteger(env.MSWARM_SELF_HOSTED_REQUEST_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS),
+        exposeAllModels: parseBoolean(env.MSWARM_SELF_HOSTED_EXPOSE_ALL_MODELS, false),
+        modelAllowlist: parseList(env.MSWARM_SELF_HOSTED_MODEL_ALLOWLIST),
+        modelBlocklist: parseList(env.MSWARM_SELF_HOSTED_MODEL_BLOCKLIST)
+    };
+}
+export function mapOllamaModelToSelfHostedModel(model, config) {
+    const name = optionalText(model.name);
+    if (!name) {
+        return null;
+    }
+    const family = optionalText(model.details?.family);
+    const parameterSize = optionalText(model.details?.parameter_size);
+    const quantizationLevel = optionalText(model.details?.quantization_level);
+    const embeddingOnly = isEmbeddingModel(name, family);
+    return {
+        name,
+        provider: "ollama",
+        adapter: "ollama",
+        model_id: name,
+        digest: optionalText(model.digest),
+        family,
+        parameter_size: parameterSize,
+        quantization_level: quantizationLevel,
+        supports_tools: false,
+        supports_vision: isVisionModel(name, family),
+        openai_compatible: false,
+        exposed: isModelExposed(name, family, config),
+        best_usage: embeddingOnly
+            ? "embedding"
+            : family === "codellama" || name.toLowerCase().includes("code")
+                ? "code_writer"
+                : "general_chat",
+        rating: 5,
+        reasoning_rating: 4,
+        max_complexity: 3,
+        health_status: "healthy",
+        metadata_quality: model.details ? "discovered" : "unknown"
+    };
+}
+export function mapMcodaAgentToSelfHostedModel(agent, config) {
+    if (isMswarmManagedCloudAgent(agent)) {
+        return null;
+    }
+    const slug = optionalText(agent.slug);
+    if (!slug) {
+        return null;
+    }
+    const adapter = optionalText(agent.adapter) || "unknown";
+    const defaultModel = optionalText(agent.defaultModel) ||
+        optionalText(agent.default_model) ||
+        optionalText(agent.models?.find((model) => model.isDefault === true || model.is_default === true)?.modelName) ||
+        optionalText(agent.models?.find((model) => model.isDefault === true || model.is_default === true)?.model_name) ||
+        null;
+    const bestUsage = optionalText(agent.bestUsage) || optionalText(agent.best_usage) || "general_chat";
+    const healthStatus = normalizeHealthStatus(agent.health?.status);
+    const capabilities = normalizeCapabilities(agent.capabilities);
+    return {
+        name: slug,
+        provider: "mcoda",
+        adapter,
+        source_agent_id: optionalText(agent.id),
+        source_agent_slug: slug,
+        model_id: defaultModel || slug,
+        display_name: slug,
+        context_window: optionalNumber(agent.contextWindow, agent.context_window),
+        max_output_tokens: optionalNumber(agent.maxOutputTokens, agent.max_output_tokens),
+        supports_tools: optionalBoolean(agent.supportsTools, agent.supports_tools) === true,
+        supports_vision: capabilities.some((capability) => capability.toLowerCase().includes("vision")) ||
+            capabilities.some((capability) => capability.toLowerCase().includes("visual")),
+        openai_compatible: optionalBoolean(agent.openaiCompatible, agent.openai_compatible) === true,
+        exposed: healthStatus !== "blocked" &&
+            isAgentExposed(slug, defaultModel, bestUsage, config),
+        best_usage: bestUsage,
+        capabilities,
+        cost_per_million: optionalNumber(agent.costPerMillion, agent.cost_per_million),
+        rating: optionalNumber(agent.rating),
+        reasoning_rating: optionalNumber(agent.reasoningRating, agent.reasoning_rating),
+        max_complexity: optionalNumber(agent.maxComplexity, agent.max_complexity),
+        health_status: healthStatus,
+        metadata_quality: "discovered"
+    };
+}
+function parseMcodaAgentListOutput(stdout) {
+    const parsed = JSON.parse(stdout);
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed && typeof parsed === "object") {
+        const record = parsed;
+        if (Array.isArray(record.agents)) {
+            return record.agents;
+        }
+    }
+    throw new Error("mcoda agent list returned unsupported JSON");
+}
+async function defaultCommandRunner(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill("SIGTERM");
+            reject(new Error(`command timed out after ${options.timeoutMs}ms: ${command}`));
+        }, options.timeoutMs);
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ stdout, stderr });
+        };
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+            if (stdout.length > options.maxBuffer) {
+                child.kill("SIGTERM");
+                finish(new Error(`command stdout exceeded ${options.maxBuffer} bytes: ${command}`));
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+            if (stderr.length > options.maxBuffer) {
+                child.kill("SIGTERM");
+                finish(new Error(`command stderr exceeded ${options.maxBuffer} bytes: ${command}`));
+            }
+        });
+        child.on("error", finish);
+        child.on("close", (code) => {
+            if (code && code !== 0) {
+                finish(new Error(`command failed (${code}): ${command} ${args.join(" ")} ${stderr}`.trim()));
+                return;
+            }
+            finish();
+        });
+        if (options.input) {
+            child.stdin.write(options.input);
+        }
+        child.stdin.end();
+    });
+}
+export class McodaAgentInventoryClient {
+    command;
+    args;
+    timeoutMs;
+    runner;
+    constructor(input) {
+        this.command = input.command || DEFAULT_MCODA_BIN;
+        this.args = input.args?.length ? input.args : DEFAULT_MCODA_LIST_ARGS;
+        this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
+        this.runner = input.runner || defaultCommandRunner;
+    }
+    async listAgents(config) {
+        let stdout;
+        try {
+            stdout = (await this.runner(this.command, this.args, {
+                timeoutMs: this.timeoutMs,
+                maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+            })).stdout;
+        }
+        catch (error) {
+            if (!this.args.includes("--refresh-health")) {
+                throw error;
+            }
+            stdout = (await this.runner(this.command, ["agent", "list", "--json"], {
+                timeoutMs: this.timeoutMs,
+                maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+            })).stdout;
+        }
+        return parseMcodaAgentListOutput(stdout)
+            .map((agent) => mapMcodaAgentToSelfHostedModel(agent, config))
+            .filter((model) => Boolean(model));
+    }
+}
+export class OllamaClient {
+    baseUrl;
+    fetchImpl;
+    timeoutMs;
+    constructor(input) {
+        this.baseUrl = trimTrailingSlash(input.baseUrl);
+        this.fetchImpl = input.fetchImpl || fetch;
+        this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
+    }
+    async getVersion() {
+        const response = await fetchJson(this.fetchImpl, `${this.baseUrl}/api/version`, { method: "GET" }, this.timeoutMs);
+        return optionalText(response.version);
+    }
+    async listModels(config) {
+        const response = await fetchJson(this.fetchImpl, `${this.baseUrl}/api/tags`, { method: "GET" }, this.timeoutMs);
+        return (response.models || [])
+            .map((model) => mapOllamaModelToSelfHostedModel(model, config))
+            .filter((model) => Boolean(model));
+    }
+    async chat(input) {
+        const response = await fetchJson(this.fetchImpl, `${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: input.model,
+                messages: input.messages.map((message) => ({
+                    role: message.role,
+                    content: openAIMessageContentToText(message.content)
+                })),
+                stream: false,
+                ...(input.options && Object.keys(input.options).length > 0 ? { options: input.options } : {})
+            })
+        }, this.timeoutMs);
+        return {
+            content: typeof response.message?.content === "string" ? response.message.content : "",
+            promptTokens: typeof response.prompt_eval_count === "number" ? response.prompt_eval_count : null,
+            completionTokens: typeof response.eval_count === "number" ? response.eval_count : null,
+            raw: response
+        };
+    }
+}
+function openAIMessageContentToText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : ""))
+        .filter(Boolean)
+        .join("\n");
+}
+function messagesToPrompt(messages) {
+    return messages
+        .map((message) => {
+        const role = message.role || "user";
+        const content = openAIMessageContentToText(message.content).trim();
+        return content ? `${role}: ${content}` : "";
+    })
+        .filter(Boolean)
+        .join("\n\n")
+        .trim();
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+function buildOpenAIChatCompletion(input) {
+    const promptTokens = positiveInteger(input.promptTokens);
+    const completionTokens = positiveInteger(input.completionTokens);
+    const totalTokens = promptTokens !== null && completionTokens !== null ? promptTokens + completionTokens : null;
+    return {
+        id: `chatcmpl-${input.requestId}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: input.model,
+        choices: [
+            {
+                index: 0,
+                message: { role: "assistant", content: input.content },
+                finish_reason: "stop"
+            }
+        ],
+        usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: totalTokens,
+            cost_cents: 0
+        },
+        metadata: input.metadata
+    };
+}
+export class McodaLocalAgentExecutor {
+    command;
+    timeoutMs;
+    runner;
+    constructor(input) {
+        this.command = input.command || DEFAULT_MCODA_BIN;
+        this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
+        this.runner = input.runner || defaultCommandRunner;
+    }
+    async invoke(agentSlug, prompt) {
+        const stdout = (await this.runner(this.command, ["agent-run", agentSlug, "--json", "--stdin"], {
+            timeoutMs: this.timeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER,
+            input: prompt
+        })).stdout;
+        const parsed = JSON.parse(stdout);
+        if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.responses)) {
+            throw new Error("mcoda agent-run returned unsupported JSON");
+        }
+        const response = parsed.responses[0] || {};
+        const output = optionalText(response.output);
+        if (!output) {
+            throw new Error("mcoda agent-run response did not include output");
+        }
+        return {
+            output,
+            adapter: optionalText(response.adapter) || undefined,
+            model: optionalText(response.model) || undefined,
+            metadata: response.metadata && typeof response.metadata === "object" ? response.metadata : undefined
+        };
+    }
+}
+export class MswarmSelfHostedNodeClient {
+    gatewayBaseUrl;
+    fetchImpl;
+    timeoutMs;
+    constructor(input) {
+        this.gatewayBaseUrl = trimTrailingSlash(input.gatewayBaseUrl);
+        this.fetchImpl = input.fetchImpl || fetch;
+        this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
+    }
+    async enroll(nodeId, enrollmentToken) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/enroll`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ node_id: nodeId, enrollment_token: enrollmentToken })
+        }, this.timeoutMs);
+    }
+    async heartbeat(runtimeToken, payload) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/heartbeat`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${runtimeToken}`
+            },
+            body: JSON.stringify(payload)
+        }, this.timeoutMs);
+    }
+    async pushModels(runtimeToken, payload) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/models`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${runtimeToken}`
+            },
+            body: JSON.stringify(payload)
+        }, this.timeoutMs);
+    }
+}
+export class SelfHostedNodeRuntime {
+    config;
+    gateway;
+    mcoda;
+    mcodaExecutor;
+    ollama;
+    constructor(config, deps) {
+        this.config = config;
+        this.gateway =
+            deps?.gateway ||
+                new MswarmSelfHostedNodeClient({
+                    gatewayBaseUrl: config.gatewayBaseUrl,
+                    fetchImpl: deps?.fetchImpl,
+                    timeoutMs: config.requestTimeoutMs
+                });
+        this.mcoda =
+            deps?.mcoda ||
+                new McodaAgentInventoryClient({
+                    command: config.mcodaBin,
+                    args: config.mcodaListArgs,
+                    timeoutMs: config.requestTimeoutMs
+                });
+        this.mcodaExecutor =
+            deps?.mcodaExecutor ||
+                new McodaLocalAgentExecutor({
+                    command: config.mcodaBin,
+                    timeoutMs: config.requestTimeoutMs
+                });
+        this.ollama =
+            deps?.ollama ||
+                new OllamaClient({
+                    baseUrl: config.ollamaBaseUrl,
+                    fetchImpl: deps?.fetchImpl,
+                    timeoutMs: config.requestTimeoutMs
+                });
+    }
+    async discoverModels() {
+        if (this.config.discoveryMode === "ollama") {
+            const [version, models] = await Promise.all([
+                this.ollama.getVersion(),
+                this.ollama.listModels(this.config)
+            ]);
+            return { source: "ollama", status: "online", models, version, failureCount: 0 };
+        }
+        const models = await this.mcoda.listAgents(this.config);
+        return { source: "mcoda", status: "online", models, version: null, failureCount: 0 };
+    }
+    async ensureEnrolled() {
+        const currentState = await readSelfHostedNodeState(this.config.statePath);
+        const persistedRuntimeToken = await readSelfHostedRuntimeToken(this.config.runtimeTokenPath);
+        const existingRuntimeToken = this.config.runtimeToken || persistedRuntimeToken || currentState.runtime_token;
+        if (existingRuntimeToken) {
+            return { runtimeToken: existingRuntimeToken, state: currentState, enrolled: false };
+        }
+        if (!this.config.enrollmentToken) {
+            throw new Error("No runtime token is stored and MSWARM_SELF_HOSTED_ENROLLMENT_TOKEN is missing");
+        }
+        const response = await this.gateway.enroll(this.config.nodeId, this.config.enrollmentToken);
+        const runtimeToken = optionalText(response.runtime_token);
+        if (!runtimeToken) {
+            throw new Error("Enrollment response did not include runtime_token");
+        }
+        const nextState = {
+            ...currentState,
+            node_id: this.config.nodeId,
+            runtime_token: undefined,
+            config_version: response.config_version,
+            heartbeat_interval_seconds: response.heartbeat_interval_seconds || this.config.heartbeatIntervalSeconds,
+            heartbeat_timeout_seconds: response.heartbeat_timeout_seconds,
+            enrolled_at: currentState.enrolled_at || new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            gateway_base_url: this.config.gatewayBaseUrl,
+            ollama_base_url: this.config.ollamaBaseUrl
+        };
+        await writeSelfHostedNodeState(this.config.statePath, nextState);
+        await writeSelfHostedRuntimeToken(this.config.runtimeTokenPath, runtimeToken);
+        return { runtimeToken, state: nextState, enrolled: true };
+    }
+    async executeJob(job) {
+        const startedAt = Date.now();
+        if (job.node_id !== this.config.nodeId) {
+            return {
+                job_id: job.job_id,
+                request_id: job.request_id,
+                status: "failed",
+                error: { code: "validation_failed", message: "job node_id does not match this node" }
+            };
+        }
+        if (job.openai_request.stream) {
+            return {
+                job_id: job.job_id,
+                request_id: job.request_id,
+                status: "failed",
+                error: { code: "validation_failed", message: "streaming relay jobs are not supported by this node yet" }
+            };
+        }
+        try {
+            if (job.provider === "ollama") {
+                const options = {};
+                if (job.openai_request.temperature !== undefined)
+                    options.temperature = job.openai_request.temperature;
+                if (job.openai_request.top_p !== undefined)
+                    options.top_p = job.openai_request.top_p;
+                if (job.openai_request.max_tokens !== undefined)
+                    options.num_predict = job.openai_request.max_tokens;
+                if (job.openai_request.stop !== undefined)
+                    options.stop = job.openai_request.stop;
+                const result = await this.ollama.chat({
+                    model: job.model || job.openai_request.model,
+                    messages: job.openai_request.messages,
+                    options
+                });
+                return {
+                    job_id: job.job_id,
+                    request_id: job.request_id,
+                    status: "success",
+                    openai_response: buildOpenAIChatCompletion({
+                        requestId: job.request_id,
+                        model: job.openai_request.model,
+                        content: result.content,
+                        promptTokens: result.promptTokens,
+                        completionTokens: result.completionTokens,
+                        metadata: { provider: "ollama", raw: result.raw }
+                    }),
+                    timing: { local_latency_ms: Date.now() - startedAt }
+                };
+            }
+            const agentSlug = optionalText(job.source_agent_slug) || optionalText(job.model) || optionalText(job.agent_slug);
+            if (!agentSlug) {
+                throw new Error("mcoda source agent slug is required");
+            }
+            const prompt = messagesToPrompt(job.openai_request.messages);
+            if (!prompt) {
+                throw new Error("mcoda invocation prompt is empty");
+            }
+            const response = await this.mcodaExecutor.invoke(agentSlug, prompt);
+            const metadata = response.metadata || {};
+            const promptTokens = positiveInteger(metadata.tokensPrompt ?? metadata.tokens_prompt);
+            const completionTokens = positiveInteger(metadata.tokensCompletion ?? metadata.tokens_completion);
+            return {
+                job_id: job.job_id,
+                request_id: job.request_id,
+                status: "success",
+                openai_response: buildOpenAIChatCompletion({
+                    requestId: job.request_id,
+                    model: job.openai_request.model,
+                    content: response.output,
+                    promptTokens,
+                    completionTokens,
+                    metadata: {
+                        provider: "mcoda",
+                        adapter: response.adapter,
+                        local_model: response.model,
+                        mcoda_metadata: metadata
+                    }
+                }),
+                timing: { local_latency_ms: Date.now() - startedAt }
+            };
+        }
+        catch (error) {
+            return {
+                job_id: job.job_id,
+                request_id: job.request_id,
+                status: "failed",
+                error: {
+                    code: "upstream_error",
+                    message: error instanceof Error ? error.message : String(error)
+                },
+                timing: { local_latency_ms: Date.now() - startedAt }
+            };
+        }
+    }
+    async runOnce() {
+        const enrollment = await this.ensureEnrolled();
+        let status = "online";
+        let version = null;
+        let models = [];
+        let discoverySource = this.config.discoveryMode;
+        let recentFailureCount = 0;
+        const startedAt = Date.now();
+        try {
+            const discovery = await this.discoverModels();
+            status = discovery.status;
+            version = discovery.version;
+            models = discovery.models;
+            discoverySource = discovery.source;
+            recentFailureCount = discovery.failureCount;
+        }
+        catch (error) {
+            status = "degraded";
+            recentFailureCount = 1;
+            models = [];
+            version = null;
+        }
+        const heartbeatPayload = {
+            node_id: this.config.nodeId,
+            node_version: this.config.nodeVersion,
+            config_version: enrollment.state.config_version ?? null,
+            status,
+            discovery: {
+                source: discoverySource,
+                mcoda_status: discoverySource === "mcoda" && status === "online" ? "ok" : status === "degraded" ? "error" : null
+            },
+            ollama: discoverySource === "ollama"
+                ? {
+                    status: status === "online" ? "ok" : "error",
+                    version
+                }
+                : {
+                    status: null,
+                    version: null
+                },
+            capacity: {
+                active_jobs: 0,
+                queued_jobs: 0
+            },
+            health: {
+                avg_latency_ms: Date.now() - startedAt,
+                recent_failure_count: recentFailureCount,
+                last_success_at: status === "online" ? new Date().toISOString() : null
+            },
+            models
+        };
+        const heartbeatResponse = await this.gateway.heartbeat(enrollment.runtimeToken, heartbeatPayload);
+        return {
+            enrolled: enrollment.enrolled,
+            status,
+            model_count: models.length,
+            discovery_source: discoverySource,
+            mcoda_agent_count: discoverySource === "mcoda" ? models.length : undefined,
+            ollama_version: version,
+            heartbeat_response: heartbeatResponse
+        };
+    }
+    async pushModelsOnly() {
+        const enrollment = await this.ensureEnrolled();
+        const discovery = await this.discoverModels();
+        const models = discovery.models;
+        const response = await this.gateway.pushModels(enrollment.runtimeToken, {
+            node_id: this.config.nodeId,
+            models
+        });
+        return { count: models.length, response };
+    }
+    startDaemon() {
+        let stopped = false;
+        let timer = null;
+        const schedule = () => {
+            if (stopped)
+                return;
+            timer = setTimeout(() => {
+                void this.runOnce()
+                    .catch(() => undefined)
+                    .finally(schedule);
+            }, this.config.heartbeatIntervalSeconds * 1000);
+        };
+        void this.runOnce()
+            .catch(() => undefined)
+            .finally(schedule);
+        return {
+            stop: () => {
+                stopped = true;
+                if (timer) {
+                    clearTimeout(timer);
+                }
+            }
+        };
+    }
+}
+//# sourceMappingURL=runtime.js.map