@mcoda/mswarm 0.1.107 → 0.1.109

package/dist/runtime.js

@@ -62,6 +62,7 @@ const DEFAULT_HEARTBEAT_INTERVAL_SECONDS = 30;
 const DEFAULT_SELF_HOSTED_NODE_VERSION = "0.1.70";
 const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
 const DEFAULT_JOB_TIMEOUT_MS = 3600000;
+const DEFAULT_RESULT_POST_TIMEOUT_MS = 5 * 60000;
 const DEFAULT_SERVICE_COMMAND_TIMEOUT_MS = 60000;
 const DEFAULT_CAPABILITY_PROBE_TIMEOUT_MS = 2000;
 const SELF_HOSTED_RUNTIME_PROTOCOL_VERSION = 1;
@@ -74,6 +75,12 @@ const DEFAULT_MCODA_LIST_ARGS = ["agent", "list", "--json", "--refresh-health"];
 const DEFAULT_COMMAND_MAX_BUFFER = 16 * 1024 * 1024;
 const DEFAULT_LOCAL_ARTIFACT_MAX_BYTES = 512 * 1024 * 1024;
 const DEFAULT_JOB_POLL_WAIT_MS = 2000;
+const RESERVED_JOB_POLL_WAIT_MS = 250;
+const MAX_POLL_EXCLUDED_AGENT_SLUGS = 64;
+const MAX_RELAY_AGENT_SLUG_LENGTH = 255;
+const DEFAULT_RESERVED_PRIORITY_MAX = -1;
+const MIN_RELAY_PRIORITY = -100;
+const MAX_RELAY_PRIORITY = 100;
 const JOB_POLL_RETRY_BASE_MS = 1000;
 const JOB_POLL_RETRY_MAX_MS = 60000;
 /**
@@ -284,6 +291,33 @@ const LOCAL_RUNNER_RESPONSE_FORMAT_ALIASES = {
 function optionalText(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function relayJobAgentAliases(job) {
+    const aliases = [job.agent_slug, job.source_agent_slug, job.remote_slug]
+        .map(optionalText)
+        .map((value) => value
+        ?.toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "") || null)
+        .filter((value) => typeof value === "string" && value.length > 0 && value.length <= MAX_RELAY_AGENT_SLUG_LENGTH);
+    return [...new Set(aliases)];
+}
+function boundedRelayAgentAliases(activeAliases) {
+    const aliases = [];
+    const seen = new Set();
+    for (const group of activeAliases) {
+        for (const alias of group) {
+            if (seen.has(alias))
+                continue;
+            seen.add(alias);
+            aliases.push(alias);
+            if (aliases.length >= MAX_POLL_EXCLUDED_AGENT_SLUGS) {
+                return aliases;
+            }
+        }
+    }
+    return aliases;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -588,6 +622,39 @@ function parsePositiveInteger(value, fallback) {
     }
     return Math.floor(parsed);
 }
+function parseNonNegativeInteger(value, fallback) {
+    const parsed = value === undefined || value === null || value === ""
+        ? fallback
+        : typeof value === "number"
+            ? value
+            : typeof value === "string"
+                ? Number(value)
+                : Number.NaN;
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error("MSWARM_SELF_HOSTED_RESERVED_LLM_JOBS must be a non-negative integer");
+    }
+    return parsed;
+}
+function parseRelayPriority(value, fallback) {
+    const parsed = value === undefined || value === null || value === ""
+        ? fallback
+        : typeof value === "number"
+            ? value
+            : typeof value === "string"
+                ? Number(value)
+                : Number.NaN;
+    if (!Number.isInteger(parsed) || parsed < MIN_RELAY_PRIORITY || parsed > MAX_RELAY_PRIORITY) {
+        throw new Error(`MSWARM_SELF_HOSTED_RESERVED_PRIORITY_MAX must be an integer from ${MIN_RELAY_PRIORITY} to ${MAX_RELAY_PRIORITY}`);
+    }
+    return parsed;
+}
+function assertReservedLlmCapacity(input) {
+    const totalLlmJobs = input.maxConcurrentLlmJobs + input.reservedLlmJobs;
+    if (totalLlmJobs > input.maxConcurrentJobs) {
+        throw new Error("MSWARM_SELF_HOSTED_MAX_CONCURRENT_JOBS must be greater than or equal to " +
+            "MSWARM_SELF_HOSTED_MAX_CONCURRENT_LLM_JOBS plus MSWARM_SELF_HOSTED_RESERVED_LLM_JOBS");
+    }
+}
 function parseBoolean(value, fallback) {
     if (typeof value === "boolean")
         return value;
@@ -1280,6 +1347,8 @@ function serviceEnvironment(config, env, homeDir) {
         MSWARM_SELF_HOSTED_JOB_TIMEOUT_MS: String(config.jobTimeoutMs),
         MSWARM_SELF_HOSTED_MAX_CONCURRENT_JOBS: String(config.maxConcurrentJobs || 1),
         MSWARM_SELF_HOSTED_MAX_CONCURRENT_LLM_JOBS: String(config.maxConcurrentLlmJobs || config.maxConcurrentJobs || 1),
+        MSWARM_SELF_HOSTED_RESERVED_LLM_JOBS: String(config.reservedLlmJobs ?? 0),
+        MSWARM_SELF_HOSTED_RESERVED_PRIORITY_MAX: String(config.reservedPriorityMax ?? DEFAULT_RESERVED_PRIORITY_MAX),
         MSWARM_SELF_HOSTED_GENERIC_JOBS_ENABLED: config.genericJobsEnabled ? "true" : "false",
         MSWARM_SELF_HOSTED_GENERIC_JOB_TIMEOUT_MS: String(config.genericJobTimeoutMs),
         MSWARM_SELF_HOSTED_GENERIC_JOB_MAX_CONCURRENCY: String(config.genericJobMaxConcurrency),
@@ -1695,6 +1764,9 @@ export async function readSelfHostedNodeConfig(env = process.env) {
     const packageNodeVersion = await readPackageNodeVersion();
     const maxConcurrentJobs = parsePositiveInteger(env.MSWARM_SELF_HOSTED_MAX_CONCURRENT_JOBS, state.max_concurrent_jobs || 1);
     const maxConcurrentLlmJobs = parsePositiveInteger(env.MSWARM_SELF_HOSTED_MAX_CONCURRENT_LLM_JOBS, state.max_concurrent_llm_jobs || maxConcurrentJobs);
+    const reservedLlmJobs = parseNonNegativeInteger(env.MSWARM_SELF_HOSTED_RESERVED_LLM_JOBS, state.reserved_llm_jobs ?? 0);
+    const reservedPriorityMax = parseRelayPriority(env.MSWARM_SELF_HOSTED_RESERVED_PRIORITY_MAX, state.reserved_priority_max ?? DEFAULT_RESERVED_PRIORITY_MAX);
+    assertReservedLlmCapacity({ maxConcurrentJobs, maxConcurrentLlmJobs, reservedLlmJobs });
     return {
         gatewayBaseUrl: trimTrailingSlash(gatewayBaseUrl),
         jobsPollPath: optionalText(env.MSWARM_SELF_HOSTED_JOBS_POLL_PATH) ||
@@ -1738,6 +1810,8 @@ export async function readSelfHostedNodeConfig(env = process.env) {
         jobTimeoutMs: parsePositiveInteger(env.MSWARM_SELF_HOSTED_JOB_TIMEOUT_MS, state.job_timeout_ms || DEFAULT_JOB_TIMEOUT_MS),
         maxConcurrentJobs,
         maxConcurrentLlmJobs,
+        reservedLlmJobs,
+        reservedPriorityMax,
         genericJobsEnabled: parseBoolean(env.MSWARM_SELF_HOSTED_GENERIC_JOBS_ENABLED ?? env.MSWARM_SELF_HOSTED_GENERIC_JOBS, state.generic_jobs_enabled === true),
         genericJobTimeoutMs: parsePositiveInteger(env.MSWARM_SELF_HOSTED_GENERIC_JOB_TIMEOUT_MS, state.generic_job_timeout_ms || state.job_timeout_ms || DEFAULT_JOB_TIMEOUT_MS),
         genericJobMaxConcurrency: parsePositiveInteger(env.MSWARM_SELF_HOSTED_GENERIC_JOB_MAX_CONCURRENCY, state.generic_job_max_concurrency || 1),
@@ -1787,6 +1861,9 @@ export async function readOwnerSetupConfig(argv = process.argv.slice(3), env = p
     const packageNodeVersion = await readPackageNodeVersion();
     const maxConcurrentJobs = parsePositiveInteger(options["max-concurrent-jobs"] || env.MSWARM_SELF_HOSTED_MAX_CONCURRENT_JOBS, 1);
     const maxConcurrentLlmJobs = parsePositiveInteger(options["max-concurrent-llm-jobs"] || env.MSWARM_SELF_HOSTED_MAX_CONCURRENT_LLM_JOBS, maxConcurrentJobs);
+    const reservedLlmJobs = parseNonNegativeInteger(options["reserved-llm-jobs"] ?? env.MSWARM_SELF_HOSTED_RESERVED_LLM_JOBS, 0);
+    const reservedPriorityMax = parseRelayPriority(options["reserved-priority-max"] ?? env.MSWARM_SELF_HOSTED_RESERVED_PRIORITY_MAX, DEFAULT_RESERVED_PRIORITY_MAX);
+    assertReservedLlmCapacity({ maxConcurrentJobs, maxConcurrentLlmJobs, reservedLlmJobs });
     return {
         apiKey,
         handle: handle || undefined,
@@ -1812,6 +1889,8 @@ export async function readOwnerSetupConfig(argv = process.argv.slice(3), env = p
         jobTimeoutMs: parsePositiveInteger(options["job-timeout-ms"] || env.MSWARM_SELF_HOSTED_JOB_TIMEOUT_MS, DEFAULT_JOB_TIMEOUT_MS),
         maxConcurrentJobs,
         maxConcurrentLlmJobs,
+        reservedLlmJobs,
+        reservedPriorityMax,
         genericJobsEnabled: parseBoolean(options["enable-generic-jobs"] || env.MSWARM_SELF_HOSTED_GENERIC_JOBS_ENABLED || env.MSWARM_SELF_HOSTED_GENERIC_JOBS, false),
         genericJobTimeoutMs: parsePositiveInteger(options["generic-job-timeout-ms"] || env.MSWARM_SELF_HOSTED_GENERIC_JOB_TIMEOUT_MS, DEFAULT_JOB_TIMEOUT_MS),
         genericJobMaxConcurrency: parsePositiveInteger(options["generic-job-max-concurrency"] || env.MSWARM_SELF_HOSTED_GENERIC_JOB_MAX_CONCURRENCY, 1),
@@ -2203,6 +2282,41 @@ function mcodaAgentDefaultModel(agent) {
         optionalText(agent.models?.find((model) => model.isDefault === true || model.is_default === true)?.model_name) ||
         null);
 }
+/**
+ * The agent's base URL, but only when it names a runner on this machine.
+ *
+ * The catalogue publishes a mirror of each self-hosted agent back to the node,
+ * and that mirror's base URL is the gateway. Serving a job from it sends the
+ * request back out instead of to the model running here, so a loopback address
+ * is what distinguishes the real runner from its reflection.
+ */
+function mcodaAgentLocalRunnerBaseUrl(agent) {
+    const config = isRecord(agent.config) ? agent.config : {};
+    const localRunner = isRecord(config.localRunner) ? config.localRunner : {};
+    const baseUrl = readConfigString({ ...localRunner, ...config }, [
+        "baseUrl",
+        "base_url",
+        "endpoint",
+        "apiBaseUrl",
+        "api_base_url"
+    ]);
+    if (!baseUrl) {
+        return null;
+    }
+    let host;
+    try {
+        host = new URL(baseUrl).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+    const isLoopback = host === "localhost" ||
+        host === "::1" ||
+        host === "0.0.0.0" ||
+        host.endsWith(".localhost") ||
+        /^127\./.test(host);
+    return isLoopback ? baseUrl : null;
+}
 function resolveCodaliProviderForAgent(agent) {
     const adapter = optionalText(agent.adapter);
     if (isLocalOpenAiCompatibleAdapter(adapter)) {
@@ -4100,6 +4214,7 @@ export class MswarmSelfHostedNodeClient {
         this.jobsResultPathTemplate = lifecyclePath(input.jobsResultPathTemplate, DEFAULT_SELF_HOSTED_JOBS_RESULT_PATH_TEMPLATE);
         this.fetchImpl = input.fetchImpl || fetch;
         this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
+        this.resultTimeoutMs = Math.max(this.timeoutMs, input.resultTimeoutMs || DEFAULT_RESULT_POST_TIMEOUT_MS);
     }
     lifecycleEndpoint(kind) {
         const path = kind === "poll"
@@ -4214,7 +4329,7 @@ export class MswarmSelfHostedNodeClient {
                 authorization: `Bearer ${runtimeToken}`
             },
             body: JSON.stringify(payload)
-        }, this.timeoutMs);
+        }, this.resultTimeoutMs);
     }
     async postJobStart(runtimeToken, jobId, payload) {
         return fetchJson(this.fetchImpl, this.lifecycleUrl("start", jobId), {
@@ -4246,6 +4361,12 @@ export class SelfHostedNodeRuntime {
         this.latencySamplesMs = [];
         this.recentFailures = [];
         this.lifecyclePollingDisabled = false;
+        assertReservedLlmCapacity({
+            maxConcurrentJobs: Math.max(1, Math.floor(config.maxConcurrentJobs || 1)),
+            maxConcurrentLlmJobs: Math.max(1, Math.floor(config.maxConcurrentLlmJobs || config.maxConcurrentJobs || 1)),
+            reservedLlmJobs: parseNonNegativeInteger(config.reservedLlmJobs, 0)
+        });
+        parseRelayPriority(config.reservedPriorityMax, DEFAULT_RESERVED_PRIORITY_MAX);
         this.config = config;
         this.fetchImpl = deps?.fetchImpl || fetch;
         this.useDedicatedGenerativeDispatcher = deps?.fetchImpl === undefined;
@@ -4258,7 +4379,8 @@ export class SelfHostedNodeRuntime {
                     jobsEventsPathTemplate: config.jobsEventsPathTemplate,
                     jobsResultPathTemplate: config.jobsResultPathTemplate,
                     fetchImpl: this.fetchImpl,
-                    timeoutMs: config.requestTimeoutMs
+                    timeoutMs: config.requestTimeoutMs,
+                    resultTimeoutMs: Math.min(config.jobTimeoutMs, DEFAULT_RESULT_POST_TIMEOUT_MS)
                 });
         this.mcoda =
             deps?.mcoda ||
@@ -4448,7 +4570,8 @@ export class SelfHostedNodeRuntime {
             new MswarmSelfHostedNodeClient({
                 gatewayBaseUrl: setupConfig.gatewayBaseUrl,
                 fetchImpl: deps?.fetchImpl,
-                timeoutMs: setupConfig.requestTimeoutMs
+                timeoutMs: setupConfig.requestTimeoutMs,
+                resultTimeoutMs: Math.min(setupConfig.jobTimeoutMs, DEFAULT_RESULT_POST_TIMEOUT_MS)
             });
         const machineId = await readOrCreateSelfHostedMachineId(setupConfig.machineIdPath);
         const machineFingerprint = machineFingerprintFromId(machineId);
@@ -4517,6 +4640,8 @@ export class SelfHostedNodeRuntime {
             job_timeout_ms: setupConfig.jobTimeoutMs,
             max_concurrent_jobs: setupConfig.maxConcurrentJobs,
             max_concurrent_llm_jobs: setupConfig.maxConcurrentLlmJobs,
+            reserved_llm_jobs: setupConfig.reservedLlmJobs,
+            reserved_priority_max: setupConfig.reservedPriorityMax,
             generic_jobs_enabled: setupConfig.genericJobsEnabled,
             generic_job_timeout_ms: setupConfig.genericJobTimeoutMs,
             generic_job_max_concurrency: setupConfig.genericJobMaxConcurrency,
@@ -4541,7 +4666,8 @@ export class SelfHostedNodeRuntime {
                 jobsEventsPathTemplate,
                 jobsResultPathTemplate,
                 fetchImpl: deps?.fetchImpl,
-                timeoutMs: setupConfig.requestTimeoutMs
+                timeoutMs: setupConfig.requestTimeoutMs,
+                resultTimeoutMs: Math.min(setupConfig.jobTimeoutMs, DEFAULT_RESULT_POST_TIMEOUT_MS)
             });
         const runtime = new SelfHostedNodeRuntime({
             gatewayBaseUrl: trimTrailingSlash(relayGatewayBaseUrl),
@@ -4572,6 +4698,8 @@ export class SelfHostedNodeRuntime {
             jobTimeoutMs: setupConfig.jobTimeoutMs,
             maxConcurrentJobs: setupConfig.maxConcurrentJobs,
             maxConcurrentLlmJobs: setupConfig.maxConcurrentLlmJobs,
+            reservedLlmJobs: setupConfig.reservedLlmJobs,
+            reservedPriorityMax: setupConfig.reservedPriorityMax,
             genericJobsEnabled: setupConfig.genericJobsEnabled,
             genericJobTimeoutMs: setupConfig.genericJobTimeoutMs,
             genericJobMaxConcurrency: setupConfig.genericJobMaxConcurrency,
@@ -4702,6 +4830,8 @@ export class SelfHostedNodeRuntime {
             job_timeout_ms: this.config.jobTimeoutMs,
             max_concurrent_jobs: this.config.maxConcurrentJobs,
             max_concurrent_llm_jobs: this.config.maxConcurrentLlmJobs,
+            reserved_llm_jobs: this.config.reservedLlmJobs ?? 0,
+            reserved_priority_max: this.config.reservedPriorityMax ?? DEFAULT_RESERVED_PRIORITY_MAX,
             generic_jobs_enabled: this.config.genericJobsEnabled,
             generic_job_timeout_ms: this.config.genericJobTimeoutMs,
             generic_job_max_concurrency: this.config.genericJobMaxConcurrency,
@@ -4730,7 +4860,16 @@ export class SelfHostedNodeRuntime {
     async executeOpenAiToolPassthrough(job, agent) {
         const baseUrl = optionalText(agent.baseUrl);
         if (!baseUrl) {
-            throw new SelfHostedPreStartJobError("selected_agent_unavailable", "agent has no local runner base URL for OpenAI tool pass-through");
+            /*
+             * Name the agent. "agent has no local runner base URL" alone cannot be
+             * acted on: a node holds several entries per model - the local runner and
+             * the gateway's mirror of it - and this says nothing about which one was
+             * resolved or whether it carried a config at all.
+             */
+            throw new SelfHostedPreStartJobError("selected_agent_unavailable", `agent has no local runner base URL for OpenAI tool pass-through ` +
+                `(slug=${optionalText(agent.slug) || "?"} adapter=${optionalText(agent.adapter) || "?"} ` +
+                `runnerKind=${optionalText(agent.runnerKind) || "?"} ` +
+                `localRunner=${agent.localRunner ? "yes" : "no"} model=${optionalText(agent.model) || "?"})`);
         }
         const headers = { "content-type": "application/json" };
         const bearer = agent.authMode === "bearer"
@@ -5123,7 +5262,7 @@ export class SelfHostedNodeRuntime {
         }
         const rawAgents = await this.mcoda.listRawAgents();
         const strictSelectedAgent = selectedSourceAgentSlug || selectedAgentSlug;
-        const agent = rawAgents.find((entry) => {
+        const matches = rawAgents.filter((entry) => {
             const slug = optionalText(entry.slug);
             if (strictSelectedAgent) {
                 return slug === strictSelectedAgent;
@@ -5131,6 +5270,15 @@ export class SelfHostedNodeRuntime {
             const defaultModel = mcodaAgentDefaultModel(entry);
             return slug === selected || defaultModel === selected;
         });
+        /*
+         * A node carries two entries for the same model: the local runner, and the
+         * gateway mirror that the catalogue publishes back to it. The mirror's base
+         * URL is the gateway itself, so serving a job from it sends the request back
+         * out to the gateway instead of to the model sitting on this machine - which
+         * is why OpenAI tool pass-through reported having no local runner to call.
+         * Take the entry that actually points at a runner here.
+         */
+        const agent = matches.find((entry) => Boolean(mcodaAgentLocalRunnerBaseUrl(entry))) ?? matches[0];
         if (!agent) {
             throw new SelfHostedPreStartJobError("selected_agent_unavailable", `selected local mcoda agent ${selected} is not available on this node`);
         }
@@ -5853,11 +6001,11 @@ export class SelfHostedNodeRuntime {
         });
         return { count: models.filter((model) => model.exposed !== false).length, response };
     }
-    async pollAndExecuteJob(waitMs = DEFAULT_JOB_POLL_WAIT_MS) {
+    async pollRelayJob(waitMs = DEFAULT_JOB_POLL_WAIT_MS, options = {}) {
         const lifecycleState = await this.readLifecycleState();
         if (this.lifecyclePollingDisabled || this.isLifecycleProtocolDegradedState(lifecycleState)) {
             this.lifecyclePollingDisabled = true;
-            return { executed: false, status: "failed" };
+            return { claim: null, status: "failed" };
         }
         const enrollment = await this.ensureEnrolled();
         const pollCapacity = this.buildLoadTelemetry({ models: [] });
@@ -5871,7 +6019,17 @@ export class SelfHostedNodeRuntime {
                     max_jobs: pollCapacity.max_concurrency,
                     max_concurrency: pollCapacity.max_concurrency,
                     free_slots: pollCapacity.free_slots,
-                    drain_mode: pollCapacity.drain_mode
+                    drain_mode: pollCapacity.drain_mode,
+                    ...(options.excludedAgentSlugs !== undefined
+                        ? {
+                            excluded_agent_slugs: boundedRelayAgentAliases([
+                                options.excludedAgentSlugs
+                            ])
+                        }
+                        : {}),
+                    ...(options.maxRequestedPriority !== undefined
+                        ? { max_requested_priority: options.maxRequestedPriority }
+                        : {})
                 },
                 wait_ms: waitMs
             });
@@ -5880,14 +6038,24 @@ export class SelfHostedNodeRuntime {
             const mismatch = this.lifecycleProtocolMismatch("poll", error);
             if (mismatch) {
                 await this.markLifecycleProtocolDegraded(mismatch);
-                return { executed: false, status: "failed" };
+                return { claim: null, status: "failed" };
             }
             throw error;
         }
         const job = response.job || null;
         if (!job) {
-            return { executed: false };
+            return { claim: null };
         }
+        return {
+            claim: {
+                runtimeToken: enrollment.runtimeToken,
+                job,
+                attachedMswarmApiKey: optionalText(response.attached_mswarm_api_key) || undefined
+            }
+        };
+    }
+    async executeRelayJobClaim(claim) {
+        const { job, runtimeToken } = claim;
         const chatStreaming = (normalizeSelfHostedGenerativeOperationName(job.operation) ?? "chat.completions") ===
             "chat.completions" &&
             job.openai_request.stream === true;
@@ -5900,7 +6068,7 @@ export class SelfHostedNodeRuntime {
             }
             const stream_events = pendingStreamEvents.splice(0, pendingStreamEvents.length);
             try {
-                await this.gateway.postJobEvents(enrollment.runtimeToken, job.job_id, {
+                await this.gateway.postJobEvents(runtimeToken, job.job_id, {
                     node_id: this.config.nodeId,
                     stream_events
                 });
@@ -5917,10 +6085,10 @@ export class SelfHostedNodeRuntime {
             }
         };
         let result = await this.executeJob(job, {
-            attachedMswarmApiKey: optionalText(response.attached_mswarm_api_key) || undefined,
+            attachedMswarmApiKey: claim.attachedMswarmApiKey,
             onStarted: async (event) => {
                 try {
-                    await this.gateway.postJobStart(enrollment.runtimeToken, job.job_id, {
+                    await this.gateway.postJobStart(runtimeToken, job.job_id, {
                         node_id: this.config.nodeId,
                         agent_slug: event.agent_slug || job.agent_slug,
                         source_agent_slug: event.source_agent_slug || job.source_agent_slug || null,
@@ -5975,7 +6143,7 @@ export class SelfHostedNodeRuntime {
         let resultPostError = null;
         for (let attempt = 0; attempt <= RELAY_RESULT_POST_RETRY_DELAYS_MS.length; attempt += 1) {
             try {
-                await this.gateway.postJobResult(enrollment.runtimeToken, job.job_id, this.jobResultPayload(postedResult));
+                await this.gateway.postJobResult(runtimeToken, job.job_id, this.jobResultPayload(postedResult));
                 resultPostError = null;
                 break;
             }
@@ -6003,6 +6171,13 @@ export class SelfHostedNodeRuntime {
         }
         return { executed: true, job_id: job.job_id, status: result.status };
     }
+    async pollAndExecuteJob(waitMs = DEFAULT_JOB_POLL_WAIT_MS) {
+        const polled = await this.pollRelayJob(waitMs);
+        if (!polled.claim) {
+            return { executed: false, ...(polled.status ? { status: polled.status } : {}) };
+        }
+        return this.executeRelayJobClaim(polled.claim);
+    }
     async doctor() {
         const checks = [];
         checks.push({ name: "config", ok: Boolean(this.config.nodeId), message: this.config.nodeId || "missing node id" });
@@ -6041,19 +6216,33 @@ export class SelfHostedNodeRuntime {
         let stopped = false;
         let timer = null;
         let pollTimer = null;
+        let pollTimerDueAt = 0;
         let polling = false;
-        let pollFailureStreak = 0;
+        let relayPollFailureStreak = 0;
+        let relayExecutionFailureStreak = 0;
+        let activeRelayExecutions = 0;
+        let activeRegularRelayExecutions = 0;
+        let relayExecutionSequence = 0;
+        const activeRelayAgentAliases = new Map();
         let revoked = false;
+        const regularRelayExecutionLimit = Math.max(1, Math.floor(this.config.maxConcurrentLlmJobs || this.config.maxConcurrentJobs || 1));
+        const reservedRelayExecutionLimit = parseNonNegativeInteger(this.config.reservedLlmJobs, 0);
+        const reservedPriorityMax = parseRelayPriority(this.config.reservedPriorityMax, DEFAULT_RESERVED_PRIORITY_MAX);
+        const relayExecutionLimit = regularRelayExecutionLimit + reservedRelayExecutionLimit;
+        const clearPollTimer = () => {
+            if (pollTimer) {
+                clearTimeout(pollTimer);
+                pollTimer = null;
+            }
+            pollTimerDueAt = 0;
+        };
         const halt = () => {
             stopped = true;
             if (timer) {
                 clearTimeout(timer);
                 timer = null;
             }
-            if (pollTimer) {
-                clearTimeout(pollTimer);
-                pollTimer = null;
-            }
+            clearPollTimer();
         };
         // 410 means the gateway has retired this node's credentials: it was removed there.
         // Retrying at full rate achieves nothing but a hot loop and a flooded journal, so
@@ -6067,10 +6256,7 @@ export class SelfHostedNodeRuntime {
             if (!isHttpStatusError(error, 410)) {
                 return false;
             }
-            if (pollTimer) {
-                clearTimeout(pollTimer);
-                pollTimer = null;
-            }
+            clearPollTimer();
             if (!revoked) {
                 revoked = true;
                 console.error(`[mswarm] this node was removed at the gateway (node ${this.config.nodeId}). ` +
@@ -6081,42 +6267,112 @@ export class SelfHostedNodeRuntime {
             return true;
         };
         const noteAlive = () => {
-            if (!revoked) {
+            const recoveredFromRevocation = revoked;
+            const relayPollingIsBackedOff = (relayPollFailureStreak > 0 || relayExecutionFailureStreak > 0) && !polling;
+            if (!recoveredFromRevocation && !relayPollingIsBackedOff) {
                 return;
             }
-            revoked = false;
-            console.error(`[mswarm] node ${this.config.nodeId} is accepted at the gateway again; resuming normal operation.`);
-            poll();
+            if (recoveredFromRevocation) {
+                revoked = false;
+                console.error(`[mswarm] node ${this.config.nodeId} is accepted at the gateway again; resuming normal operation.`);
+            }
+            clearPollTimer();
+            relayPollFailureStreak = 0;
+            relayExecutionFailureStreak = 0;
+            schedulePoll(0);
+        };
+        const currentRelayRetryDelayMs = () => Math.max(pollRetryDelayMs(relayPollFailureStreak), pollRetryDelayMs(relayExecutionFailureStreak));
+        const schedulePoll = (delayMs) => {
+            if (stopped ||
+                polling ||
+                revoked ||
+                this.lifecyclePollingDisabled ||
+                this.config.relayMode === "direct" ||
+                activeRelayExecutions >= relayExecutionLimit) {
+                return;
+            }
+            const dueAt = Date.now() + Math.max(0, delayMs);
+            if (pollTimer && pollTimerDueAt >= dueAt) {
+                return;
+            }
+            clearPollTimer();
+            pollTimerDueAt = dueAt;
+            pollTimer = setTimeout(() => {
+                pollTimer = null;
+                pollTimerDueAt = 0;
+                poll();
+            }, Math.max(0, dueAt - Date.now()));
         };
         const poll = () => {
             if (stopped ||
                 polling ||
                 revoked ||
                 this.lifecyclePollingDisabled ||
-                this.config.relayMode === "direct") {
+                this.config.relayMode === "direct" ||
+                activeRelayExecutions >= relayExecutionLimit) {
                 return;
             }
             polling = true;
-            void this.pollAndExecuteJob()
-                .then(() => {
-                pollFailureStreak = 0;
+            const reservedOnly = reservedRelayExecutionLimit > 0 &&
+                activeRegularRelayExecutions >= regularRelayExecutionLimit &&
+                activeRelayExecutions < relayExecutionLimit;
+            const excludedAgentSlugs = boundedRelayAgentAliases(activeRelayAgentAliases.values());
+            void this.pollRelayJob(reservedOnly ? RESERVED_JOB_POLL_WAIT_MS : DEFAULT_JOB_POLL_WAIT_MS, {
+                ...(reservedRelayExecutionLimit > 0 ? { excludedAgentSlugs } : {}),
+                ...(reservedOnly ? { maxRequestedPriority: reservedPriorityMax } : {})
+            })
+                .then((polled) => {
+                relayPollFailureStreak = 0;
+                const claim = polled.claim;
+                if (!claim) {
+                    return;
+                }
+                const regularLane = !reservedOnly;
+                const executionId = ++relayExecutionSequence;
+                activeRelayExecutions += 1;
+                if (regularLane) {
+                    activeRegularRelayExecutions += 1;
+                }
+                activeRelayAgentAliases.set(executionId, relayJobAgentAliases(claim.job));
+                void this.executeRelayJobClaim(claim)
+                    .then(() => {
+                    relayExecutionFailureStreak = 0;
+                })
+                    .catch((error) => {
+                    if (noteRevoked(error)) {
+                        return;
+                    }
+                    relayExecutionFailureStreak += 1;
+                    console.error(`[mswarm] self-hosted relay job ${claim.job.job_id} failed: ${runtimeErrorMessage(error)}`);
+                })
+                    .finally(() => {
+                    activeRelayExecutions = Math.max(0, activeRelayExecutions - 1);
+                    if (regularLane) {
+                        activeRegularRelayExecutions = Math.max(0, activeRegularRelayExecutions - 1);
+                    }
+                    activeRelayAgentAliases.delete(executionId);
+                    schedulePoll(currentRelayRetryDelayMs());
+                });
             })
                 .catch((error) => {
                 if (noteRevoked(error)) {
                     return;
                 }
-                pollFailureStreak += 1;
+                relayPollFailureStreak += 1;
                 console.error(`[mswarm] self-hosted relay poll failed: ${runtimeErrorMessage(error)}`);
             })
                 .finally(() => {
                 polling = false;
-                if (stopped || revoked) {
+                if (stopped ||
+                    revoked ||
+                    this.lifecyclePollingDisabled ||
+                    activeRelayExecutions >= relayExecutionLimit) {
                     return;
                 }
                 // A healthy poll long-polls at the gateway, so re-entering immediately is
                 // correct. A failing one returns at once, so without this the loop spins as
                 // fast as the network allows.
-                pollTimer = setTimeout(poll, pollRetryDelayMs(pollFailureStreak));
+                schedulePoll(currentRelayRetryDelayMs());
             });
         };
         const schedule = () => {
@@ -6138,7 +6394,7 @@ export class SelfHostedNodeRuntime {
         })
             .finally(() => {
             schedule();
-            poll();
+            schedulePoll(0);
         });
         return { stop: halt };
     }