@mcoda/mswarm 0.1.133 → 0.1.134

package/dist/runtime.js

@@ -202,6 +202,7 @@ function resolvePersistentNodePath(nodePath) {
 const DEFAULT_EXPOSE_ALL_MODELS = true;
 const LOCAL_OPENAI_COMPATIBLE_ADAPTERS = new Set([
     "openai-compatible-local",
+    "strata-local",
     "vllm-local",
     "llama-cpp-local",
     "llamacpp-local"
@@ -244,6 +245,7 @@ const DEFAULT_VIDEO_GENERATIVE_OUTPUT_BYTES = 256 * 1024 * 1024;
 const GENERATIVE_RESPONSE_JSON_OVERHEAD_BYTES = 64 * 1024;
 const LOCAL_RUNNER_KIND_ALIASES = {
     vllm: "vllm",
+    strata: "strata",
     "llama-cpp": "llama-cpp",
     "llama.cpp": "llama-cpp",
     llamacpp: "llama-cpp",
@@ -526,6 +528,8 @@ function defaultLocalRunnerKindForAdapter(adapter) {
     const lookupKey = normalizeLookupKey(normalized);
     if (lookupKey === "vllm-local")
         return "vllm";
+    if (lookupKey === "strata-local")
+        return "strata";
     if (lookupKey === "llama-cpp-local" || lookupKey === "llamacpp-local")
         return "llama-cpp";
     return undefined;
@@ -4472,6 +4476,7 @@ export class SelfHostedNodeRuntime {
         this.activeRequestIds = new Set();
         this.lastModels = [];
         this.loadRuntimeToken = null;
+        this.loadReportQueue = Promise.resolve();
         this.fastLoadUnsupported = false;
         this.nativeActiveJobs = 0;
         this.nativeProbeKeys = new Map();
@@ -5684,6 +5689,9 @@ export class SelfHostedNodeRuntime {
         }
         finally {
             this.activeRequestIds.delete(job.request_id);
+            // A product often starts its next stage immediately after this result.
+            // Publish the newly free native slot before the gateway delivers it.
+            await this.reportLoad().catch(() => undefined);
         }
     }
     async executeTrackedJob(job, options) {
@@ -6057,14 +6065,15 @@ export class SelfHostedNodeRuntime {
     async refreshNativeLoad() {
         const runners = new Map();
         for (const model of this.lastModels) {
+            const isStrata = model.runner_kind === "strata" || model.adapter === "strata-local";
             if (model.exposed === false || !model.base_url ||
-                (model.runner_kind !== "llama-cpp" && model.adapter !== "llama-cpp-local"))
+                (!isStrata && model.runner_kind !== "llama-cpp" && model.adapter !== "llama-cpp-local"))
                 continue;
             try {
                 const url = new URL(model.base_url);
                 if (!["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))
                     continue;
-                const endpoint = new URL("/slots", url).toString();
+                const endpoint = new URL(isStrata ? "/v1/status" : "/slots", url).toString();
                 const models = runners.get(endpoint) || [];
                 models.push(model);
                 runners.set(endpoint, models);
@@ -6089,12 +6098,30 @@ export class SelfHostedNodeRuntime {
                 }
                 const response = await this.fetchImpl(endpoint, { signal: AbortSignal.timeout(1500),
                     ...(apiKey ? { headers: { authorization: `Bearer ${apiKey}` } } : {}) });
-                // Slot introspection is optional and may require different local credentials.
-                if ([401, 403, 404].includes(response.status))
+                const isStrata = new URL(endpoint).pathname === "/v1/status";
+                // llama.cpp slot introspection is optional. Strata status also proves the model is loaded.
+                if (!isStrata && [401, 403, 404].includes(response.status))
                     return;
                 if (!response.ok)
                     throw new Error("runner_load_unavailable");
                 const slots = await response.json();
+                if (isStrata) {
+                    const concurrency = isRecord(slots) && isRecord(slots.concurrency) ? slots.concurrency.serving : undefined;
+                    const inFlight = isRecord(slots) && isRecord(slots.activity) ? slots.activity.in_flight : undefined;
+                    if (!isRecord(slots) || slots.loaded !== true ||
+                        typeof concurrency !== "number" || !Number.isSafeInteger(concurrency) || concurrency < 1 ||
+                        typeof inFlight !== "number" || !Number.isSafeInteger(inFlight) || inFlight < 0) {
+                        throw new Error("runner_load_unavailable");
+                    }
+                    const processing = Math.min(concurrency, inFlight);
+                    active += processing;
+                    const capacity = { max_concurrency: concurrency, active_jobs: processing,
+                        queued_jobs: Math.max(0, inFlight - concurrency), free_slots: Math.max(0, concurrency - inFlight),
+                        pool: `runner:${createHash("sha256").update(endpoint).digest("hex").slice(0, 16)}` };
+                    for (const model of models)
+                        modelCapacity[model.model_id || model.model || model.name] = capacity;
+                    return;
+                }
                 if (!Array.isArray(slots))
                     return;
                 const processing = slots.filter((slot) => isRecord(slot) && slot.is_processing === true).length;
@@ -6114,7 +6141,14 @@ export class SelfHostedNodeRuntime {
         this.nativeModelCapacity = modelCapacity;
         this.unavailableModelIds = [...new Set(unavailable)];
     }
-    async reportLoad() {
+    reportLoad() {
+        // Serialize probes and writes so an older busy snapshot cannot overwrite
+        // the completion snapshot when the periodic reporter is already running.
+        const pending = this.loadReportQueue.then(() => this.reportLoadSnapshot());
+        this.loadReportQueue = pending.catch(() => undefined);
+        return pending;
+    }
+    async reportLoadSnapshot() {
         if (this.config.loadReportingEnabled === false || this.fastLoadUnsupported || !this.loadRuntimeToken)
             return;
         await this.refreshNativeLoad();