@nemesis-oss/ollama-sdk 1.12.0 → 1.12.1

package/dist/index.d.cts

@@ -390,8 +390,9 @@ declare function withRetry<T>(operation: (attempt: number) => Promise<T>, config
  *   registry's synchronous `candidates()`/`filterWithCapacity()` and the
  *   endpoint's `acquire()` — no `await` in between — so the strategy's
  *   no-two-calls-pick-the-same-idle-endpoint guarantee is untouched. Affinity
- *   only reorders *within* the runnable set; priority tiers and per-strategy
- *   ordering stay intact inside the resident/non-resident groups.
+ *   only reorders *within each priority tier* of the runnable set: a
+ *   higher-priority endpoint is always tried before a lower-priority one, and
+ *   per-strategy ordering is kept inside the resident/non-resident groups.
  * - **Best-effort, never blocking, never failing a request.** A probe failure is
  *   recorded with a short backoff (`failureRetryMs`) and never cached as data;
  *   the affected endpoint is simply treated as unknown until a probe succeeds.
@@ -461,9 +462,10 @@ declare class ModelAffinityRouter {
         readonly now?: NowFn;
     });
     /**
-     * Synchronously reorders `candidates` so endpoints whose fresh `/api/ps`
+     * Synchronously reorders `candidates` so that, within each priority tier
+     * (run of consecutive equal `priority`), endpoints whose fresh `/api/ps`
      * snapshot shows `model` resident come first (relative order preserved within
-     * each group). Returns the input unchanged — and kicks a background refresh —
+     * each group). Never moves an endpoint across tiers. Returns the input unchanged — and kicks a background refresh —
      * when any candidate's snapshot is missing or stale: a wrong reorder is worse
      * than no reorder, and the first request after a cache miss simply isn't
      * reordered. No-op without a `model` or with fewer than two candidates.

package/dist/index.d.ts

@@ -390,8 +390,9 @@ declare function withRetry<T>(operation: (attempt: number) => Promise<T>, config
  *   registry's synchronous `candidates()`/`filterWithCapacity()` and the
  *   endpoint's `acquire()` — no `await` in between — so the strategy's
  *   no-two-calls-pick-the-same-idle-endpoint guarantee is untouched. Affinity
- *   only reorders *within* the runnable set; priority tiers and per-strategy
- *   ordering stay intact inside the resident/non-resident groups.
+ *   only reorders *within each priority tier* of the runnable set: a
+ *   higher-priority endpoint is always tried before a lower-priority one, and
+ *   per-strategy ordering is kept inside the resident/non-resident groups.
  * - **Best-effort, never blocking, never failing a request.** A probe failure is
  *   recorded with a short backoff (`failureRetryMs`) and never cached as data;
  *   the affected endpoint is simply treated as unknown until a probe succeeds.
@@ -461,9 +462,10 @@ declare class ModelAffinityRouter {
         readonly now?: NowFn;
     });
     /**
-     * Synchronously reorders `candidates` so endpoints whose fresh `/api/ps`
+     * Synchronously reorders `candidates` so that, within each priority tier
+     * (run of consecutive equal `priority`), endpoints whose fresh `/api/ps`
      * snapshot shows `model` resident come first (relative order preserved within
-     * each group). Returns the input unchanged — and kicks a background refresh —
+     * each group). Never moves an endpoint across tiers. Returns the input unchanged — and kicks a background refresh —
      * when any candidate's snapshot is missing or stale: a wrong reorder is worse
      * than no reorder, and the first request after a cache miss simply isn't
      * reordered. No-op without a `model` or with fewer than two candidates.

package/dist/index.js

@@ -1763,9 +1763,10 @@ var ModelAffinityRouter = class {
     this.now = options.now ?? Date.now;
   }
   /**
-   * Synchronously reorders `candidates` so endpoints whose fresh `/api/ps`
+   * Synchronously reorders `candidates` so that, within each priority tier
+   * (run of consecutive equal `priority`), endpoints whose fresh `/api/ps`
    * snapshot shows `model` resident come first (relative order preserved within
-   * each group). Returns the input unchanged — and kicks a background refresh —
+   * each group). Never moves an endpoint across tiers. Returns the input unchanged — and kicks a background refresh —
    * when any candidate's snapshot is missing or stale: a wrong reorder is worse
    * than no reorder, and the first request after a cache miss simply isn't
    * reordered. No-op without a `model` or with fewer than two candidates.
@@ -1782,13 +1783,28 @@ var ModelAffinityRouter = class {
       }
     }
     if (!allFresh) return candidates;
-    const resident = candidates.filter((ep) => {
+    const isResident = (ep) => {
       const entry = this.cache.get(ep.name);
       return entry !== void 0 && isModelResident(entry.models, model);
-    });
-    if (resident.length === 0 || resident.length === candidates.length) return candidates;
-    const residentSet = new Set(resident.map((ep) => ep.name));
-    return [...resident, ...candidates.filter((ep) => !residentSet.has(ep.name))];
+    };
+    const reordered = [];
+    let changed = false;
+    for (let start = 0; start < candidates.length; ) {
+      const tierPriority = candidates[start].priority ?? 0;
+      let end = start + 1;
+      while (end < candidates.length && (candidates[end].priority ?? 0) === tierPriority) end++;
+      const tier = candidates.slice(start, end);
+      const resident = tier.filter(isResident);
+      if (resident.length === 0 || resident.length === tier.length) {
+        reordered.push(...tier);
+      } else {
+        const tierOrder = [...resident, ...tier.filter((ep) => !isResident(ep))];
+        changed ||= tierOrder.some((ep, i) => ep !== tier[i]);
+        reordered.push(...tierOrder);
+      }
+      start = end;
+    }
+    return changed ? reordered : candidates;
   }
   /**
    * Forces a refresh of the affinity cache for the given endpoints (deduped with