@nemesis-oss/ollama-sdk 1.10.0 → 1.12.0

package/dist/index.cjs

@@ -341,6 +341,23 @@ var OllamaAgentMaxIterationsError = class extends OllamaClientError {
     this.maxIterations = options.maxIterations;
   }
 };
+var OllamaAgentToolLoopError = class extends OllamaClientError {
+  /** Name of the tool whose identical call would exceed the repeat budget. */
+  toolName;
+  /** How many times this exact call would have executed including the rejected one. */
+  repeatedExecutions;
+  /** The configured per-signature execution budget. */
+  maxRepeatedToolCalls;
+  /** Canonical `name(args)` signature of the repeated call (very large payloads truncated). */
+  signature;
+  constructor(message, options) {
+    super(message, { ...options, code: "agent_tool_loop_detected", retryable: false });
+    this.toolName = options.toolName;
+    this.repeatedExecutions = options.repeatedExecutions;
+    this.maxRepeatedToolCalls = options.maxRepeatedToolCalls;
+    this.signature = options.signature;
+  }
+};
 var OllamaMcpError = class extends OllamaClientError {
   mcpMethod;
   toolName;
@@ -640,6 +657,15 @@ var EndpointRegistry = class {
   }
 };
 
+// src/transport/url.ts
+function joinUrlPath(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const tail = path.replace(/^\/+/, "");
+  if (tail === "") return base;
+  if (base === "") return `/${tail}`;
+  return `${base}/${tail}`;
+}
+
 // src/middleware.ts
 function composeMiddleware(middlewares, finalHandler) {
   return function runPipeline(initialRequest) {
@@ -1011,6 +1037,27 @@ var ATTR_OLLAMA_AGENT_MAX_ITERATIONS = "ollama.agent.max_iterations";
 var ATTR_OLLAMA_AGENT_ITERATION = "ollama.agent.iteration";
 var GEN_AI_SYSTEM_OLLAMA = "ollama";
 
+// src/telemetry/metrics.ts
+function nsToMs(ns) {
+  return ns ? Math.round(ns / 1e6 * 100) / 100 : 0;
+}
+function formatTelemetry(raw) {
+  const evalDurationSec = raw.eval_duration ? raw.eval_duration / 1e9 : 0;
+  const promptDurationSec = raw.prompt_eval_duration ? raw.prompt_eval_duration / 1e9 : 0;
+  const promptEvaluated = raw.prompt_eval_count ?? 0;
+  const promptCached = raw.prompt_eval_cached_count ?? 0;
+  const promptTotal = promptCached + promptEvaluated;
+  return {
+    totalLatencyMs: nsToMs(raw.total_duration),
+    modelLoadMs: nsToMs(raw.load_duration),
+    promptEvalMs: nsToMs(raw.prompt_eval_duration),
+    generationMs: nsToMs(raw.eval_duration),
+    tokensPerSecond: evalDurationSec > 0 && raw.eval_count ? Math.round(raw.eval_count / evalDurationSec * 10) / 10 : 0,
+    promptTokensPerSecond: promptDurationSec > 0 && promptEvaluated ? Math.round(promptEvaluated / promptDurationSec * 10) / 10 : 0,
+    cacheHitRatio: promptTotal > 0 ? Math.round(promptCached / promptTotal * 1e3) / 1e3 : 0
+  };
+}
+
 // src/transport/http.ts
 function routeTemplate(path) {
   return path.replace(/^\/api\/blobs\/.+$/, "/api/blobs/{digest}");
@@ -1192,7 +1239,7 @@ var HttpClient = class {
     }
   }
   async request(options) {
-    const url = `${this.baseUrl}${options.path}`;
+    const url = joinUrlPath(this.baseUrl, options.path);
     const method = options.method ?? (options.body !== void 0 || options.rawBody !== void 0 ? "POST" : "GET");
     const headers = this.buildHeaders(options.headers);
     if (options.rawBody !== void 0 && !options.headers?.["Content-Type"]) {
@@ -1252,7 +1299,7 @@ var HttpClient = class {
    * can decode their provider-specific event payloads without duplicating transport logic.
    */
   async requestSseStream(options) {
-    const url = `${this.baseUrl}${options.path}`;
+    const url = joinUrlPath(this.baseUrl, options.path);
     const method = options.method ?? "POST";
     const headers = {
       ...this.buildHeaders(options.headers),
@@ -1319,7 +1366,7 @@ var HttpClient = class {
     );
   }
   async requestStream(options) {
-    const url = `${this.baseUrl}${options.path}`;
+    const url = joinUrlPath(this.baseUrl, options.path);
     const method = options.method ?? "POST";
     const headers = this.buildHeaders(options.headers);
     return withSpan(
@@ -1548,6 +1595,256 @@ async function listAvailableModels(http) {
   });
   return [...res.models];
 }
+
+// src/context-safety.ts
+var DEFAULT_CONTEXT_WARNING_THRESHOLD = 0.9;
+var IMAGE_TOKEN_ESTIMATE = 300;
+var CHARS_PER_TOKEN = 4;
+function isCjkCodePoint(code) {
+  return code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 13312 && code <= 19903 || // CJK Extension A
+  code >= 12352 && code <= 12543 || // Hiragana + Katakana
+  code >= 44032 && code <= 55215 || // Hangul syllables
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 65280 && code <= 65519;
+}
+function estimateTokens(text) {
+  if (text.length === 0) return 0;
+  let cjk = 0;
+  let other = 0;
+  for (const char of text) {
+    if (isCjkCodePoint(char.codePointAt(0) ?? 0)) cjk += 1;
+    else other += 1;
+  }
+  return Math.ceil(cjk + other / CHARS_PER_TOKEN);
+}
+var MESSAGE_OVERHEAD_TOKENS = 4;
+function estimateMessageTokens(message) {
+  let total = MESSAGE_OVERHEAD_TOKENS + estimateTokens(message.content ?? "");
+  if (message.thinking !== void 0) total += estimateTokens(message.thinking);
+  if (message.tool_calls !== void 0) {
+    for (const call of message.tool_calls) {
+      total += estimateTokens(call.function.name);
+      total += estimateTokens(JSON.stringify(call.function.arguments ?? {}));
+    }
+  }
+  if (message.images !== void 0) total += message.images.length * IMAGE_TOKEN_ESTIMATE;
+  return total;
+}
+function estimateChatRequestTokens(req) {
+  let total = 0;
+  for (const message of req.messages) total += estimateMessageTokens(message);
+  if (req.tools !== void 0) {
+    for (const tool of req.tools) {
+      total += estimateTokens(tool.function.description ?? "");
+      total += estimateTokens(JSON.stringify(tool.function.parameters ?? {}));
+    }
+  }
+  return total;
+}
+function estimateGenerateRequestTokens(req) {
+  let total = estimateTokens(req.prompt ?? "");
+  if (req.system !== void 0) total += estimateTokens(req.system);
+  if (req.template !== void 0) total += estimateTokens(req.template);
+  if (req.images !== void 0) total += req.images.length * IMAGE_TOKEN_ESTIMATE;
+  return total;
+}
+function checkChatContext(req, options = {}) {
+  return check(estimateChatRequestTokens(req), req.options?.num_ctx, options);
+}
+function checkGenerateContext(req, options = {}) {
+  return check(estimateGenerateRequestTokens(req), req.options?.num_ctx, options);
+}
+function check(estimatedPromptTokens, requestNumCtx, options) {
+  const threshold = options.threshold ?? DEFAULT_CONTEXT_WARNING_THRESHOLD;
+  if (requestNumCtx !== void 0) {
+    return {
+      estimatedPromptTokens,
+      effectiveContextLength: requestNumCtx,
+      windowSource: "request",
+      exceedsThreshold: estimatedPromptTokens > requestNumCtx * threshold
+    };
+  }
+  if (options.defaultContextLength !== void 0) {
+    return {
+      estimatedPromptTokens,
+      effectiveContextLength: options.defaultContextLength,
+      windowSource: "client-default",
+      exceedsThreshold: estimatedPromptTokens > options.defaultContextLength * threshold
+    };
+  }
+  return {
+    estimatedPromptTokens,
+    effectiveContextLength: OLLAMA_FALLBACK_CONTEXT_LENGTH,
+    windowSource: "server-fallback",
+    exceedsThreshold: estimatedPromptTokens > OLLAMA_FALLBACK_CONTEXT_LENGTH
+  };
+}
+var OLLAMA_FALLBACK_CONTEXT_LENGTH = 2048;
+function contextWarningMessage(check2, kind) {
+  const where = `OllamaClient.${kind}()`;
+  const estimate = `~${check2.estimatedPromptTokens} tokens`;
+  if (check2.windowSource === "request") {
+    return `${where}: estimated prompt size ${estimate} is close to or beyond the request's context window (num_ctx=${check2.effectiveContextLength}). The server will likely silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Raise \`options.num_ctx\` or shorten the conversation. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
+  }
+  if (check2.windowSource === "client-default") {
+    return `${where}: estimated prompt size ${estimate} is close to or beyond the client's \`defaultContextLength\` (${check2.effectiveContextLength}, injected as \`num_ctx\`). The server will likely silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Raise \`defaultContextLength\`, set \`options.num_ctx\` per request, or shorten the conversation. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
+  }
+  return `${where}: estimated prompt size ${estimate} outright exceeds Ollama's conservative server-default context window (${OLLAMA_FALLBACK_CONTEXT_LENGTH}\u20134096 tokens when \`num_ctx\` is unset \u2014 model-dependent). Unless the model's default is larger, the server will silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Set \`options.num_ctx\` (or the client's \`defaultContextLength\`) to an explicit window to make truncation visible and controllable. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
+}
+
+// src/context-discovery.ts
+function extractParameterNumCtx(parameters) {
+  if (!parameters) return void 0;
+  const match = /^[ \t]*num_ctx[ \t]+(\d+)\s*$/m.exec(parameters);
+  if (match === null) return void 0;
+  const value = Number.parseInt(match[1], 10);
+  return Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function matchesModelReference(entry, model) {
+  const exact = entry.name === model || entry.model === model;
+  const taglessPrefix = !model.includes(":") && (entry.name !== void 0 && entry.name.startsWith(`${model}:`) || entry.model !== void 0 && entry.model.startsWith(`${model}:`));
+  return exact || taglessPrefix;
+}
+function isModelResident(psModels, model) {
+  return psModels.some((entry) => matchesModelReference(entry, model));
+}
+function findRunningModelContextLength(psModels, model) {
+  for (const entry of psModels) {
+    if (matchesModelReference(entry, model)) {
+      return typeof entry.context_length === "number" && Number.isFinite(entry.context_length) && entry.context_length > 0 ? entry.context_length : void 0;
+    }
+  }
+  return void 0;
+}
+function positiveInt(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function resolveContextLength(signals) {
+  const running = positiveInt(signals.running);
+  const parameter = positiveInt(signals.parameter);
+  const native = positiveInt(signals.native);
+  if (running !== void 0) {
+    return {
+      contextLength: running,
+      source: "running",
+      ...parameter !== void 0 ? { parameterContextLength: parameter } : {},
+      ...native !== void 0 ? { nativeContextLength: native } : {},
+      runningContextLength: running
+    };
+  }
+  if (parameter !== void 0) {
+    return {
+      contextLength: parameter,
+      source: "parameters",
+      parameterContextLength: parameter,
+      ...native !== void 0 ? { nativeContextLength: native } : {}
+    };
+  }
+  if (native !== void 0) {
+    return { contextLength: native, source: "model-info", nativeContextLength: native };
+  }
+  return { contextLength: OLLAMA_FALLBACK_CONTEXT_LENGTH, source: "fallback" };
+}
+
+// src/providers/model-affinity-router.ts
+var DEFAULT_TTL_MS = 3e4;
+var DEFAULT_FAILURE_RETRY_MS = 5e3;
+var ModelAffinityRouter = class {
+  fetchPs;
+  ttlMs;
+  failureRetryMs;
+  now;
+  cache = /* @__PURE__ */ new Map();
+  failedAt = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  constructor(fetchPs, options = {}) {
+    this.fetchPs = fetchPs;
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.failureRetryMs = options.failureRetryMs ?? DEFAULT_FAILURE_RETRY_MS;
+    this.now = options.now ?? Date.now;
+  }
+  /**
+   * Synchronously reorders `candidates` so 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 —
+   * 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.
+   */
+  reorder(candidates, model) {
+    if (model === void 0 || candidates.length < 2) return candidates;
+    const currentTime = this.now();
+    let allFresh = true;
+    for (const endpoint of candidates) {
+      const entry = this.cache.get(endpoint.name);
+      if (entry === void 0 || currentTime - entry.fetchedAt > this.ttlMs) {
+        allFresh = false;
+        this.kickRefresh(endpoint);
+      }
+    }
+    if (!allFresh) return candidates;
+    const resident = candidates.filter((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))];
+  }
+  /**
+   * Forces a refresh of the affinity cache for the given endpoints (deduped with
+   * any in-flight refresh; bypasses the failure backoff, because this is an
+   * explicit caller request — `client.warmModelAffinity()`). Resolves once every
+   * probe has settled — successfully or not; individual failures never reject.
+   */
+  async warm(endpoints) {
+    await Promise.all(endpoints.map((endpoint) => this.refresh(endpoint)));
+  }
+  /** Introspection snapshots for the given endpoints (defaults to cached ones). */
+  status(endpoints) {
+    const names = endpoints !== void 0 ? endpoints.map((ep) => ep.name) : [...this.cache.keys(), ...this.failedAt.keys()];
+    const byName = new Map((endpoints ?? []).map((ep) => [ep.name, ep]));
+    const currentTime = this.now();
+    return names.filter((name, i, arr) => arr.indexOf(name) === i).map((name) => {
+      const entry = this.cache.get(name);
+      return {
+        endpointName: name,
+        baseUrl: byName.get(name)?.baseUrl ?? "",
+        loadedModels: entry?.models.map((m) => m.name ?? m.model ?? "").filter((n) => n !== "") ?? [],
+        fetchedAt: entry?.fetchedAt,
+        fresh: entry !== void 0 && currentTime - entry.fetchedAt <= this.ttlMs
+      };
+    });
+  }
+  /**
+   * Starts (or joins) a background refresh for `endpoint`, unless one is already
+   * in flight or the failure backoff suppresses it. Fire-and-forget: the promise
+   * is stored only for dedupe/warm-joins; callers never await it on the request
+   * path.
+   */
+  kickRefresh(endpoint) {
+    if (this.inflight.has(endpoint.name)) return;
+    const lastFailure = this.failedAt.get(endpoint.name);
+    if (lastFailure !== void 0 && this.now() - lastFailure < this.failureRetryMs) return;
+    void this.refresh(endpoint);
+  }
+  /** Refreshes one endpoint's snapshot; never rejects (failures record a backoff). */
+  refresh(endpoint) {
+    const existing = this.inflight.get(endpoint.name);
+    if (existing !== void 0) return existing;
+    const attempt = this.fetchPs(endpoint).then((models) => {
+      this.cache.set(endpoint.name, { models, fetchedAt: this.now() });
+      this.failedAt.delete(endpoint.name);
+    }).catch(() => {
+      this.failedAt.set(endpoint.name, this.now());
+    }).finally(() => {
+      this.inflight.delete(endpoint.name);
+    });
+    this.inflight.set(endpoint.name, attempt);
+    return attempt;
+  }
+};
 function extractJsonSubstring(text) {
   const trimmed = text.trim();
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
@@ -2273,9 +2570,66 @@ var ModelsClient = class {
       { ...request, singleEndpoint: true }
     );
   }
-  ps() {
-    return this.runner((http) => http.request({ path: "/api/ps", method: "GET" }), {
-      singleEndpoint: true
+  ps(request) {
+    return this.runner(
+      (http, signal) => http.request({ path: "/api/ps", method: "GET", signal }),
+      {
+        singleEndpoint: true,
+        ...request?.signal !== void 0 ? { signal: request.signal } : {},
+        ...request?.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {}
+      }
+    );
+  }
+  /**
+   * Discovers the model's real context window from the server — no more
+   * 2048/4096 guesswork. Consults, in precedence order:
+   *
+   *   1. `GET /api/ps` — the window the **running instance actually
+   *      allocated** (exact, reflects the Modelfile `num_ctx` default and
+   *      what fit in memory); skipped when the model isn't loaded, when
+   *      `skipRunningCheck` is set, or harmlessly on servers without the
+   *      field.
+   *   2. `POST /api/show` `parameters` — a Modelfile-authored
+   *      `num_ctx <n>` default, i.e. the window a cold load will allocate.
+   *   3. `POST /api/show` `model_info["<arch>.context_length"]` — the
+   *      model's **native GGUF maximum** (a ceiling to raise `num_ctx`
+   *      toward, not the allocated window).
+   *   4. Fallback — Ollama's conservative unset-`num_ctx` default (2048).
+   *
+   * The result carries every signal it found, so `nativeContextLength:
+   * 131072` vs `contextLength: 4096` (a 32× gap seen in the official API
+   * examples) is visible rather than guessed. Typical wiring:
+   *
+   * ```ts
+   * const { contextLength, source, nativeContextLength } =
+   *   await client.models.getContextLength({ model: 'gemma4' });
+   * // -> { contextLength: 4096, source: 'running', nativeContextLength: 131072 }
+   * ```
+   *
+   * Makes two server calls (`/api/ps` + `/api/show`) unless
+   * `skipRunningCheck` is set. A 404 from `/api/ps` (endpoint without the
+   * listing) is treated as "not running" and never fails the lookup;
+   * other transport errors propagate normally.
+   */
+  async getContextLength(request) {
+    let running;
+    if (request.skipRunningCheck !== true) {
+      try {
+        const ps = await this.ps({ signal: request.signal, timeoutMs: request.timeoutMs });
+        running = findRunningModelContextLength(ps.models, request.model);
+      } catch (err) {
+        if (!(err instanceof OllamaNotFoundError)) throw err;
+      }
+    }
+    const showRes = await this.show({
+      model: request.model,
+      signal: request.signal,
+      timeoutMs: request.timeoutMs
+    });
+    return resolveContextLength({
+      running,
+      parameter: extractParameterNumCtx(showRes.parameters),
+      native: extractContextLength(showRes.model_info)
     });
   }
   version() {
@@ -4273,6 +4627,52 @@ var ResponsesModule = class {
 };
 
 // src/conversation.ts
+function compactConversationHistory(messages, options) {
+  const reserve = Math.max(0, options.reserveForReply ?? 0);
+  const minTail = Math.max(0, options.minTailMessages ?? 2);
+  const budget = Math.max(0, options.maxEstimatedTokens - reserve);
+  let split = 0;
+  while (split < messages.length && messages[split].role === "system") split += 1;
+  const pinned = messages.slice(0, split);
+  const tail = messages.slice(split);
+  let used = 0;
+  for (const message of pinned) used += estimateMessageTokens(message);
+  const retained = [];
+  for (let i = tail.length - 1; i >= 0; i -= 1) {
+    const message = tail[i];
+    const cost = estimateMessageTokens(message);
+    const fits = used + cost <= budget;
+    if (!fits && retained.length >= minTail) break;
+    retained.unshift(message);
+    used += cost;
+  }
+  return [...pinned, ...retained];
+}
+function sanitizeHistoryForNextTurn(messages, options = {}) {
+  const keep = Math.max(0, options.keepImagesOnLastMessages ?? 1);
+  const placeholder = options.imagePlaceholder;
+  const cutoff = messages.length - keep;
+  const sanitized = [];
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (index >= cutoff || !message.images || message.images.length === 0) {
+      sanitized.push(message);
+      continue;
+    }
+    const { images: _evicted, ...rest } = message;
+    if (placeholder === void 0) {
+      sanitized.push(rest);
+    } else {
+      sanitized.push({
+        ...rest,
+        content: rest.content === "" ? placeholder : `${rest.content}
+
+${placeholder}`
+      });
+    }
+  }
+  return sanitized;
+}
 function extractTurnStats(res) {
   const cachedTokens = res.prompt_eval_cached_count ?? 0;
   const evaluatedTokens = res.prompt_eval_count ?? 0;
@@ -4359,6 +4759,48 @@ var ConversationSession = class {
   getMessages() {
     return this.history.map((message) => message);
   }
+  /**
+   * Compacts the session's history in place: pinned system prompt plus the
+   * most recent turns that fit the budget, oldest tailable turns dropped.
+   *
+   * This is the explicit escape hatch for sessions that outgrew their
+   * window — `cacheStats.hitRate` collapsing toward zero while history grows
+   * is the usual symptom, and the pre-flight warnings on `chat()` fire once
+   * the prompt estimate crosses the threshold. After compaction the next
+   * turn's prompt prefix differs from everything before it, so the KV cache
+   * starts cold — visible as a one-turn `evaluatedTokens` spike in
+   * `cacheStats`. Cumulative cache tallies are deliberately **not** reset:
+   * they are observations, and the spike is part of the story.
+   *
+   * Returns the before/after estimates and the drop count. No-op (zero
+   * drops, equal before/after estimates) when the history already fits.
+   */
+  compact(options = {}) {
+    const window = options.maxEstimatedTokens ?? this.config.options?.num_ctx ?? OLLAMA_FALLBACK_CONTEXT_LENGTH;
+    const reserve = options.reserveForReply ?? Math.ceil(window * 0.1);
+    const estimatedTokensBefore = this.history.reduce(
+      (sum, message) => sum + estimateMessageTokens(message),
+      0
+    );
+    const compacted = compactConversationHistory(this.history, {
+      maxEstimatedTokens: window,
+      reserveForReply: reserve,
+      ...options.minTailMessages !== void 0 ? { minTailMessages: options.minTailMessages } : {}
+    });
+    const estimatedTokensAfter = compacted.reduce(
+      (sum, message) => sum + estimateMessageTokens(message),
+      0
+    );
+    const droppedMessages = this.history.length - compacted.length;
+    this.history.length = 0;
+    this.history.push(...compacted);
+    return {
+      droppedMessages,
+      estimatedTokensBefore,
+      estimatedTokensAfter,
+      effectiveBudget: window - reserve
+    };
+  }
   /**
    * Clears the conversation back to its initial state (system prompt, zero
    * turns, zeroed cache statistics). The next turn starts with a cold cache
@@ -4377,103 +4819,6 @@ var ConversationSession = class {
   }
 };
 
-// src/context-safety.ts
-var DEFAULT_CONTEXT_WARNING_THRESHOLD = 0.9;
-var IMAGE_TOKEN_ESTIMATE = 300;
-var CHARS_PER_TOKEN = 4;
-function isCjkCodePoint(code) {
-  return code >= 19968 && code <= 40959 || // CJK Unified Ideographs
-  code >= 13312 && code <= 19903 || // CJK Extension A
-  code >= 12352 && code <= 12543 || // Hiragana + Katakana
-  code >= 44032 && code <= 55215 || // Hangul syllables
-  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
-  code >= 65280 && code <= 65519;
-}
-function estimateTokens(text) {
-  if (text.length === 0) return 0;
-  let cjk = 0;
-  let other = 0;
-  for (const char of text) {
-    if (isCjkCodePoint(char.codePointAt(0) ?? 0)) cjk += 1;
-    else other += 1;
-  }
-  return Math.ceil(cjk + other / CHARS_PER_TOKEN);
-}
-var MESSAGE_OVERHEAD_TOKENS = 4;
-function estimateMessageTokens(message) {
-  let total = MESSAGE_OVERHEAD_TOKENS + estimateTokens(message.content ?? "");
-  if (message.thinking !== void 0) total += estimateTokens(message.thinking);
-  if (message.tool_calls !== void 0) {
-    for (const call of message.tool_calls) {
-      total += estimateTokens(call.function.name);
-      total += estimateTokens(JSON.stringify(call.function.arguments ?? {}));
-    }
-  }
-  if (message.images !== void 0) total += message.images.length * IMAGE_TOKEN_ESTIMATE;
-  return total;
-}
-function estimateChatRequestTokens(req) {
-  let total = 0;
-  for (const message of req.messages) total += estimateMessageTokens(message);
-  if (req.tools !== void 0) {
-    for (const tool of req.tools) {
-      total += estimateTokens(tool.function.description ?? "");
-      total += estimateTokens(JSON.stringify(tool.function.parameters ?? {}));
-    }
-  }
-  return total;
-}
-function estimateGenerateRequestTokens(req) {
-  let total = estimateTokens(req.prompt ?? "");
-  if (req.system !== void 0) total += estimateTokens(req.system);
-  if (req.template !== void 0) total += estimateTokens(req.template);
-  if (req.images !== void 0) total += req.images.length * IMAGE_TOKEN_ESTIMATE;
-  return total;
-}
-function checkChatContext(req, options = {}) {
-  return check(estimateChatRequestTokens(req), req.options?.num_ctx, options);
-}
-function checkGenerateContext(req, options = {}) {
-  return check(estimateGenerateRequestTokens(req), req.options?.num_ctx, options);
-}
-function check(estimatedPromptTokens, requestNumCtx, options) {
-  const threshold = options.threshold ?? DEFAULT_CONTEXT_WARNING_THRESHOLD;
-  if (requestNumCtx !== void 0) {
-    return {
-      estimatedPromptTokens,
-      effectiveContextLength: requestNumCtx,
-      windowSource: "request",
-      exceedsThreshold: estimatedPromptTokens > requestNumCtx * threshold
-    };
-  }
-  if (options.defaultContextLength !== void 0) {
-    return {
-      estimatedPromptTokens,
-      effectiveContextLength: options.defaultContextLength,
-      windowSource: "client-default",
-      exceedsThreshold: estimatedPromptTokens > options.defaultContextLength * threshold
-    };
-  }
-  return {
-    estimatedPromptTokens,
-    effectiveContextLength: OLLAMA_FALLBACK_CONTEXT_LENGTH,
-    windowSource: "server-fallback",
-    exceedsThreshold: estimatedPromptTokens > OLLAMA_FALLBACK_CONTEXT_LENGTH
-  };
-}
-var OLLAMA_FALLBACK_CONTEXT_LENGTH = 2048;
-function contextWarningMessage(check2, kind) {
-  const where = `OllamaClient.${kind}()`;
-  const estimate = `~${check2.estimatedPromptTokens} tokens`;
-  if (check2.windowSource === "request") {
-    return `${where}: estimated prompt size ${estimate} is close to or beyond the request's context window (num_ctx=${check2.effectiveContextLength}). The server will likely silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Raise \`options.num_ctx\` or shorten the conversation. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
-  }
-  if (check2.windowSource === "client-default") {
-    return `${where}: estimated prompt size ${estimate} is close to or beyond the client's \`defaultContextLength\` (${check2.effectiveContextLength}, injected as \`num_ctx\`). The server will likely silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Raise \`defaultContextLength\`, set \`options.num_ctx\` per request, or shorten the conversation. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
-  }
-  return `${where}: estimated prompt size ${estimate} outright exceeds Ollama's conservative server-default context window (${OLLAMA_FALLBACK_CONTEXT_LENGTH}\u20134096 tokens when \`num_ctx\` is unset \u2014 model-dependent). Unless the model's default is larger, the server will silently truncate the top of the conversation \u2014 the model loses earlier turns with no error. Set \`options.num_ctx\` (or the client's \`defaultContextLength\`) to an explicit window to make truncation visible and controllable. Estimates are heuristic (\xB120\u201330%); see \`estimateTokens\`.`;
-}
-
 // src/embed-batch.ts
 var DEFAULT_EMBED_BATCH_SIZE = 32;
 var DEFAULT_EMBED_CONCURRENCY = 3;
@@ -5098,7 +5443,7 @@ function createLogicalRequestId() {
   logicalRequestSequence += 1;
   return `ollama-request-${logicalRequestSequence}`;
 }
-var OllamaClient = class {
+var OllamaClient = class _OllamaClient {
   registry;
   models;
   retryConfig;
@@ -5130,6 +5475,16 @@ var OllamaClient = class {
    * (streams, via `executeWithFailover`'s `holdUntil` release path).
    */
   activeRequests = /* @__PURE__ */ new Set();
+  /**
+   * Dynamic multi-host model-affinity routing, active only when
+   * `config.endpointHealth.modelAffinity` is set — see
+   * `src/providers/model-affinity-router.ts` and ADR 0028. `undefined` means
+   * the request path skips reordering entirely (zero overhead, and no `/api/ps`
+   * probes are ever issued).
+   */
+  modelAffinity;
+  /** Default timeout for one-off probe requests (`ping`, affinity `/api/ps` refreshes). */
+  static PROBE_TIMEOUT_MS = 5e3;
   constructor(config = {}) {
     this.cloudApiKey = resolveApiKey(config.apiKey);
     const defaultBaseUrl = resolveBaseUrl(config.baseUrl);
@@ -5157,6 +5512,11 @@ var OllamaClient = class {
     this.defaultContextLength = config.defaultContextLength;
     this.contextWarningThreshold = config.contextWarningThreshold;
     this.onContextOverflow = config.onContextOverflow ?? "warn";
+    const modelAffinityOptions = config.endpointHealth?.modelAffinity;
+    this.modelAffinity = modelAffinityOptions !== void 0 ? new ModelAffinityRouter(
+      (endpoint) => this.fetchEndpointRunningModels(endpoint),
+      modelAffinityOptions
+    ) : void 0;
     this.models = new ModelsClient((op, opts) => this.executeWithFailover(op, opts));
   }
   get modelsClient() {
@@ -5367,7 +5727,8 @@ var OllamaClient = class {
           );
           continue;
         }
-        for (const [attemptIndex, endpoint] of runnable.entries()) {
+        const ordered = this.modelAffinity !== void 0 ? this.modelAffinity.reorder(runnable, options?.model) : runnable;
+        for (const [attemptIndex, endpoint] of ordered.entries()) {
           this.logger.debug(`Executing on endpoint "${endpoint.name}" (${endpoint.baseUrl})`);
           const http = new HttpClient({
             baseUrl: endpoint.baseUrl,
@@ -5668,7 +6029,15 @@ var OllamaClient = class {
   createModel = (r) => this.models.create(r);
   deleteModel = (req) => this.models.delete(req);
   copyModel = (req) => this.models.copy(req);
-  ps = () => this.models.ps();
+  ps = (request) => this.models.ps(request);
+  /**
+   * Discovers the model's real context window — the allocated window of the
+   * running instance (`/api/ps`), the Modelfile `num_ctx` default, and the
+   * native GGUF maximum (`/api/show` `model_info`), resolved by precedence.
+   * Convenience alias for {@link ModelsClient.getContextLength} — see that
+   * method for the full contract and the precedence order.
+   */
+  getContextLength = (request) => this.models.getContextLength(request);
   version = () => this.models.version();
   createBlob = (digest, data) => this.models.createBlob(digest, data);
   checkBlob = (digest) => this.models.checkBlob(digest);
@@ -5881,9 +6250,114 @@ var OllamaClient = class {
       )
     );
   }
+  /**
+   * Ultra-lightweight liveness probe against the client's current best
+   * endpoint: `HEAD /` — the root ping Ollama's documentation defines for
+   * load-balancer health checks (HTTP 200; the daemon answers `GET /` with the
+   * plain-text body "Ollama is running", which a HEAD request doesn't transfer).
+   *
+   * Deliberately a *single-endpoint, single-shot* probe — no failover to other
+   * candidates, no retry — so the answer reflects one concrete host, not "some
+   * endpoint eventually answered". To audit every configured endpoint, use
+   * {@link healthCheck} (which probes all of them, and also reports the server
+   * version at the cost of the heavier `GET /api/version` round trip).
+   *
+   * Resolves — never throws — with `{ healthy: false, error }` for connection
+   * failures and timeouts; only caller-initiated cancellation (`signal`/
+   * `destroy()`) rejects, mirroring how any other aborted request behaves.
+   */
+  async ping(options) {
+    const endpoint = this.registry.candidates()[0];
+    if (endpoint === void 0) {
+      return { healthy: false, latencyMs: 0, baseUrl: "", error: "No configured endpoints" };
+    }
+    const http = new HttpClient({
+      baseUrl: endpoint.baseUrl,
+      ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
+      ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
+      fetch: this.fetchImpl,
+      middleware: this.middleware,
+      onLifecycleEvent: this.onLifecycleEvent
+    });
+    const timeout = createTimeoutSignal(
+      options?.timeoutMs ?? _OllamaClient.PROBE_TIMEOUT_MS,
+      options?.signal
+    );
+    const startTime = Date.now();
+    try {
+      await http.request({ path: "/", method: "HEAD", signal: timeout.signal });
+      return { healthy: true, latencyMs: Date.now() - startTime, baseUrl: endpoint.baseUrl };
+    } catch (err) {
+      if (options?.signal?.aborted) {
+        throw err instanceof Error ? err : new Error(String(err));
+      }
+      return {
+        healthy: false,
+        latencyMs: Date.now() - startTime,
+        baseUrl: endpoint.baseUrl,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      timeout.cancel();
+    }
+  }
+  /**
+   * Affinity-cache snapshots for every configured endpoint — which models each
+   * host held in VRAM at the last successful `/api/ps` probe, when that was, and
+   * whether it's still fresh. Empty when `endpointHealth.modelAffinity` isn't
+   * configured (no probes are ever issued, so there is nothing to report).
+   */
+  modelAffinityStatus() {
+    return this.modelAffinity?.status(this.registry.list()) ?? [];
+  }
+  /**
+   * Explicitly refreshes the model-affinity cache for every configured endpoint
+   * (deduped with any in-flight background refresh). No-op — resolves
+   * immediately — when `endpointHealth.modelAffinity` isn't configured. Use it
+   * to warm the cache at startup so the very first request already routes by
+   * residency instead of waiting for the self-warming first-round refresh.
+   */
+  async warmModelAffinity() {
+    await this.modelAffinity?.warm(this.registry.list());
+  }
   endpointStatus() {
     return this.registry.status();
   }
+  /**
+   * Fetches one endpoint's `GET /api/ps` running-model list for the affinity
+   * router. Bypasses `executeWithFailover` deliberately: probes must not
+   * reenter the routing machinery they inform, must not touch the registry's
+   * circuit-breaker/failure bookkeeping (a dead host's probe failing must not
+   * cool it down harder than its real traffic already does), and must not fail
+   * over to a different host (the answer is per-host by definition). Failures
+   * propagate to the router, which records a short backoff and retries later.
+   */
+  async fetchEndpointRunningModels(endpoint) {
+    var _stack = [];
+    try {
+      const http = new HttpClient({
+        baseUrl: endpoint.baseUrl,
+        ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
+        ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
+        fetch: this.fetchImpl,
+        middleware: this.middleware,
+        onLifecycleEvent: this.onLifecycleEvent
+      });
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), _OllamaClient.PROBE_TIMEOUT_MS);
+      const _timer = __using(_stack, disposableTimer(timer));
+      const res = await http.request({
+        path: "/api/ps",
+        method: "GET",
+        signal: controller.signal
+      });
+      return res.models ?? [];
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
   /**
    * Immediately aborts every in-flight request and active stream managed by
    * this client — the clean teardown path for short-lived processes, CLI
@@ -6916,11 +7390,29 @@ ${systemPrompt}`
 }
 
 // src/agent/agent.ts
+var SIGNATURE_REPORT_LIMIT = 200;
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`);
+  return `{${entries.join(",")}}`;
+}
+function canonicalToolCallSignature(toolCall) {
+  return `${toolCall.function.name}(${stableStringify(toolCall.function.arguments)})`;
+}
+function reportableSignature(signature) {
+  return signature.length <= SIGNATURE_REPORT_LIMIT ? signature : `${signature.slice(0, SIGNATURE_REPORT_LIMIT)}\u2026`;
+}
 var Agent = class {
   client;
   tools;
   maxIterations;
   maxToolCalls;
+  maxRepeatedToolCalls;
   hooks;
   validateToolCapability;
   toolContextSize;
@@ -6929,10 +7421,14 @@ var Agent = class {
     this.tools = config.tools;
     this.maxIterations = config.maxIterations ?? 10;
     this.maxToolCalls = config.maxToolCalls;
+    this.maxRepeatedToolCalls = config.maxRepeatedToolCalls;
     this.hooks = config.hooks;
     if (this.maxToolCalls !== void 0 && (!Number.isInteger(this.maxToolCalls) || this.maxToolCalls < 0)) {
       throw new RangeError("Agent maxToolCalls must be a non-negative integer");
     }
+    if (this.maxRepeatedToolCalls !== void 0 && (!Number.isInteger(this.maxRepeatedToolCalls) || this.maxRepeatedToolCalls < 1)) {
+      throw new RangeError("Agent maxRepeatedToolCalls must be a positive integer");
+    }
     this.validateToolCapability = config.validateToolCapability ?? true;
     this.toolContextSize = config.toolContextSize ?? 32768;
     if (!Number.isInteger(this.toolContextSize) || this.toolContextSize <= 0) {
@@ -6979,6 +7475,7 @@ var Agent = class {
       )
     } : input.options;
     let toolCallsExecuted = 0;
+    const signatureCounts = /* @__PURE__ */ new Map();
     for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
       const outcome = await withSpan(
         "ollama.agent.turn",
@@ -7010,6 +7507,24 @@ var Agent = class {
               { maxToolCalls: this.maxToolCalls, toolCallsExecuted }
             );
           }
+          if (this.maxRepeatedToolCalls !== void 0) {
+            for (const tc of toolCalls) {
+              const signature = canonicalToolCallSignature(tc);
+              const executions = (signatureCounts.get(signature) ?? 0) + 1;
+              if (executions > this.maxRepeatedToolCalls) {
+                throw new OllamaAgentToolLoopError(
+                  `Agent would repeat tool call "${tc.function.name}" ${executions} times (max ${this.maxRepeatedToolCalls}) without changing arguments \u2014 stuck in a tool loop`,
+                  {
+                    toolName: tc.function.name,
+                    repeatedExecutions: executions,
+                    maxRepeatedToolCalls: this.maxRepeatedToolCalls,
+                    signature: reportableSignature(signature)
+                  }
+                );
+              }
+              signatureCounts.set(signature, executions);
+            }
+          }
           for (const tc of toolCalls) {
             this.hooks?.onToolCallStart?.(tc);
           }
@@ -7042,6 +7557,160 @@ var Agent = class {
   }
 };
 
+// src/affinity.ts
+var DEFAULT_CONCURRENT_MODELS = 1;
+var DEFAULT_PER_MODEL_CONCURRENCY = 1;
+var DEFAULT_PS_CACHE_TTL_MS = 3e4;
+var ModelAffinityScheduler = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.concurrentModels = options.concurrentModels ?? DEFAULT_CONCURRENT_MODELS;
+    this.perModelConcurrency = options.perModelConcurrency ?? DEFAULT_PER_MODEL_CONCURRENCY;
+    this.psCacheTtlMs = options.psCacheTtlMs ?? DEFAULT_PS_CACHE_TTL_MS;
+    if (!Number.isInteger(this.concurrentModels) || this.concurrentModels < 1) {
+      throw new OllamaClientError("concurrentModels must be an integer >= 1.", {
+        code: "invalid_request"
+      });
+    }
+    if (!Number.isInteger(this.perModelConcurrency) || this.perModelConcurrency < 1) {
+      throw new OllamaClientError("perModelConcurrency must be an integer >= 1.", {
+        code: "invalid_request"
+      });
+    }
+    if (!Number.isFinite(this.psCacheTtlMs) || this.psCacheTtlMs < 0) {
+      throw new OllamaClientError("psCacheTtlMs must be a non-negative number.", {
+        code: "invalid_request"
+      });
+    }
+  }
+  queues = /* @__PURE__ */ new Map();
+  concurrentModels;
+  perModelConcurrency;
+  psCacheTtlMs;
+  psCache;
+  drainWaiters = [];
+  /**
+   * Runs `task` on the scheduler, serialized per model. When `model` is a
+   * list of candidates, the already-loaded one is preferred (fresh
+   * `/api/ps` data subject to the TTL cache); with none loaded — or when the
+   * lookup fails — the first candidate runs. The chosen model is handed to
+   * the task.
+   */
+  async run(model, task) {
+    const candidates = typeof model === "string" ? [model] : [...model];
+    if (candidates.length === 0 || candidates.some((name) => typeof name !== "string" || name === "")) {
+      throw new OllamaClientError("run() requires at least one non-empty model name.", {
+        code: "invalid_request"
+      });
+    }
+    const chosen = candidates.length === 1 ? candidates[0] : await this.chooseCandidate(candidates);
+    return new Promise((resolve, reject) => {
+      const queue = this.queues.get(chosen) ?? { items: [], active: 0 };
+      this.queues.set(chosen, queue);
+      queue.items.push({
+        task,
+        resolve,
+        reject
+      });
+      this.pump();
+    });
+  }
+  /**
+   * Names of the models currently loaded, per `GET /api/ps`, cached for
+   * `psCacheTtlMs`. Degrades to an empty list when the server can't answer
+   * (never throws; candidate selection treats it as "nothing loaded").
+   */
+  async loadedModels() {
+    const names = await this.refreshPsNames();
+    return [...names];
+  }
+  /** Current scheduling state — active models and queued task count. */
+  get stats() {
+    const activeModels = [];
+    let queuedTasks = 0;
+    for (const [name, queue] of this.queues) {
+      if (queue.active > 0) activeModels.push(name);
+      queuedTasks += queue.items.length;
+    }
+    return { activeModels, queuedTasks };
+  }
+  /**
+   * Resolves once every queue is empty and no task is running. Does not
+   * abort anything — tasks are caller-owned; abort them via their own
+   * signals before disposing if needed.
+   */
+  async dispose() {
+    if (this.stats.queuedTasks === 0 && this.stats.activeModels.length === 0) return;
+    await new Promise((resolve) => {
+      this.drainWaiters.push(resolve);
+    });
+  }
+  async chooseCandidate(candidates) {
+    const loaded = await this.refreshPsNames();
+    for (const candidate of candidates) {
+      if (loaded.has(candidate)) return candidate;
+    }
+    return candidates[0];
+  }
+  async refreshPsNames() {
+    const now = Date.now();
+    if (this.psCache !== void 0 && now - this.psCache.at <= this.psCacheTtlMs) {
+      return this.psCache.names;
+    }
+    let names;
+    try {
+      const ps = await this.client.models.ps();
+      names = new Set(ps.models.map((entry) => entry.name));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+    this.psCache = { at: now, names };
+    return names;
+  }
+  pump() {
+    for (const [name, queue] of this.queues) {
+      while (queue.items.length > 0 && queue.active < this.perModelConcurrency) {
+        if (queue.active === 0 && this.activeModelCount() >= this.concurrentModels) {
+          break;
+        }
+        const entry = queue.items.shift();
+        queue.active += 1;
+        this.execute(name, queue, entry);
+      }
+    }
+  }
+  activeModelCount() {
+    let count = 0;
+    for (const queue of this.queues.values()) {
+      if (queue.active > 0) count += 1;
+    }
+    return count;
+  }
+  execute(name, queue, entry) {
+    void (async () => {
+      try {
+        entry.resolve(await entry.task(name));
+      } catch (err) {
+        entry.reject(err);
+      } finally {
+        queue.active -= 1;
+        if (queue.items.length === 0 && queue.active === 0) {
+          this.queues.delete(name);
+        }
+        if (this.stats.queuedTasks === 0 && this.stats.activeModels.length === 0) {
+          const waiters = [...this.drainWaiters];
+          this.drainWaiters.length = 0;
+          for (const resolve of waiters) resolve();
+        }
+        this.pump();
+      }
+    })();
+  }
+};
+function createModelAffinityScheduler(client, options) {
+  return new ModelAffinityScheduler(client, options);
+}
+
 // src/system-one.ts
 var MAX_SYSTEM_ONE_IMAGES_BYTES = 32 * 1024 * 1024;
 var MAX_SYSTEM_ONE_REQUEST_BYTES = 64 * 1024;
@@ -7088,7 +7757,10 @@ exports.KEEP_ALIVE_UNLOAD = KEEP_ALIVE_UNLOAD;
 exports.KNOWN_DONE_REASONS = KNOWN_DONE_REASONS;
 exports.MAX_SYSTEM_ONE_IMAGES_BYTES = MAX_SYSTEM_ONE_IMAGES_BYTES;
 exports.MAX_SYSTEM_ONE_REQUEST_BYTES = MAX_SYSTEM_ONE_REQUEST_BYTES;
+exports.MESSAGE_OVERHEAD_TOKENS = MESSAGE_OVERHEAD_TOKENS;
 exports.McpBridge = McpBridge;
+exports.ModelAffinityRouter = ModelAffinityRouter;
+exports.ModelAffinityScheduler = ModelAffinityScheduler;
 exports.ModelsClient = ModelsClient;
 exports.NANOS_PER_MS = NANOS_PER_MS;
 exports.NANOS_PER_SECOND = NANOS_PER_SECOND;
@@ -7098,6 +7770,7 @@ exports.OLLAMA_FALLBACK_CONTEXT_LENGTH = OLLAMA_FALLBACK_CONTEXT_LENGTH;
 exports.OllamaAbortError = OllamaAbortError;
 exports.OllamaAgentMaxIterationsError = OllamaAgentMaxIterationsError;
 exports.OllamaAgentMaxToolCallsError = OllamaAgentMaxToolCallsError;
+exports.OllamaAgentToolLoopError = OllamaAgentToolLoopError;
 exports.OllamaAuthError = OllamaAuthError;
 exports.OllamaBadGatewayError = OllamaBadGatewayError;
 exports.OllamaClient = OllamaClient;
@@ -7138,13 +7811,16 @@ exports.addSpanEvent = addSpanEvent;
 exports.applySkill = applySkill;
 exports.batchEmbed = batchEmbed;
 exports.calculateBackoff = calculateBackoff;
+exports.canonicalToolCallSignature = canonicalToolCallSignature;
 exports.checkChatContext = checkChatContext;
 exports.checkEndpointHealth = checkEndpointHealth;
 exports.checkGenerateContext = checkGenerateContext;
+exports.compactConversationHistory = compactConversationHistory;
 exports.composeMiddleware = composeMiddleware;
 exports.contextWarningMessage = contextWarningMessage;
 exports.createConsoleLogger = createConsoleLogger;
 exports.createDecision = createDecision;
+exports.createModelAffinityScheduler = createModelAffinityScheduler;
 exports.createOllamaCloudFreeTierQuota = createOllamaCloudFreeTierQuota;
 exports.createTimeoutSignal = createTimeoutSignal;
 exports.defineTool = defineTool;
@@ -7153,15 +7829,21 @@ exports.embedBatchOverflowMessage = embedBatchOverflowMessage;
 exports.encodeImage = encodeImage;
 exports.estimateChatRequestTokens = estimateChatRequestTokens;
 exports.estimateGenerateRequestTokens = estimateGenerateRequestTokens;
+exports.estimateMessageTokens = estimateMessageTokens;
 exports.estimateSystemOneRequestBytes = estimateSystemOneRequestBytes;
 exports.estimateTokens = estimateTokens;
+exports.extractNativeContextLength = extractContextLength;
+exports.extractParameterNumCtx = extractParameterNumCtx;
 exports.extractUsage = extractUsage;
 exports.fetchWithBackoff = fetchWithBackoff;
 exports.findOversizedEmbedInputs = findOversizedEmbedInputs;
+exports.findRunningModelContextLength = findRunningModelContextLength;
+exports.formatTelemetry = formatTelemetry;
 exports.imageStringNeedsResolution = imageStringNeedsResolution;
 exports.inferRuntimeMode = inferRuntimeMode;
 exports.isKeepAliveSugar = isKeepAliveSugar;
 exports.isKnownDoneReason = isKnownDoneReason;
+exports.isModelResident = isModelResident;
 exports.isSameToolCall = isSameToolCall;
 exports.listAllMcpTools = listAllMcpTools;
 exports.listAvailableModels = listAvailableModels;
@@ -7179,8 +7861,10 @@ exports.parseNdjsonStream = parseNdjsonStream;
 exports.parseSseStream = parseSseStream;
 exports.parseStructuredOutput = parseStructuredOutput;
 exports.registerMcpTools = registerMcpTools;
+exports.resolveContextLength = resolveContextLength;
 exports.resolveCredentialEndpoints = resolveCredentialEndpoints;
 exports.resolveImageInput = resolveImageInput;
+exports.sanitizeHistoryForNextTurn = sanitizeHistoryForNextTurn;
 exports.setSpanError = setSpanError;
 exports.toDataStream = toDataStream;
 exports.toResponse = toResponse;