@nemesis-oss/ollama-sdk 1.7.0 → 1.9.0

package/dist/index.cjs

@@ -48,6 +48,47 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 
+// src/transport/host.ts
+var DEFAULT_PORT = "11434";
+var SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+function normalizeBaseUrl(host) {
+  const trimmed = host.trim();
+  if (trimmed === "") return trimmed;
+  const implicitScheme = !SCHEME_RE.test(trimmed);
+  const withHost = trimmed.startsWith(":") ? `127.0.0.1${trimmed}` : trimmed;
+  const candidate = implicitScheme ? `http://${withHost}` : withHost;
+  let url;
+  try {
+    url = new URL(candidate);
+  } catch {
+    return trimmed.replace(/\/+$/, "");
+  }
+  let protocol = url.protocol;
+  let port = url.port;
+  if (implicitScheme) {
+    if (port === "443") {
+      protocol = "https:";
+      port = "";
+    } else if (port === "") {
+      port = DEFAULT_PORT;
+    }
+  }
+  const authority = `${url.hostname}${port !== "" ? `:${port}` : ""}`;
+  return `${protocol}//${authority}${url.pathname}`.replace(/\/+$/, "");
+}
+function isEnvApiKeyHost(baseUrl) {
+  let hostname;
+  try {
+    hostname = new URL(normalizeBaseUrl(baseUrl)).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (hostname === "ollama.com" || hostname.endsWith(".ollama.com")) return true;
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) return true;
+  if (hostname === "[::1]" || hostname === "::1" || hostname === "0.0.0.0") return true;
+  return /^127(?:\.\d{1,3}){3}$/.test(hostname);
+}
+
 // src/config.ts
 var DEFAULT_BASE_URL = "http://localhost:11434";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -56,11 +97,16 @@ function readEnv(name) {
   return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
 }
 function resolveBaseUrl(configBaseUrl) {
-  return configBaseUrl ?? readEnv("OLLAMA_HOST") ?? DEFAULT_BASE_URL;
+  return normalizeBaseUrl(configBaseUrl ?? readEnv("OLLAMA_HOST") ?? DEFAULT_BASE_URL);
 }
 function resolveApiKey(configApiKey) {
   return configApiKey ?? readEnv("OLLAMA_API_KEY");
 }
+function resolveEndpointApiKey(configApiKey, baseUrl) {
+  if (configApiKey !== void 0) return configApiKey;
+  const envKey = readEnv("OLLAMA_API_KEY");
+  return envKey !== void 0 && isEnvApiKeyHost(baseUrl) ? envKey : void 0;
+}
 function resolveCredentialEndpoints(config) {
   if (config.credentials === void 0) return [];
   const modelsByCredential = /* @__PURE__ */ new Map();
@@ -93,6 +139,18 @@ var DEFAULT_FAILOVER_CODES = [
   "network_error",
   "timeout",
   "server_error",
+  // HTTP 503 — server queue saturated (OLLAMA_MAX_QUEUE exceeded).
+  // The new OllamaOverloadedError specialization is retryable: the
+  // queue will eventually drain, and a different candidate endpoint
+  // may have capacity right now. Listed separately from
+  // 'server_error' because OllamaOverloadedError extends
+  // OllamaClientError (NOT OllamaServerError) — see
+  // src/errors.ts for the rationale.
+  "overloaded",
+  // HTTP 502 — cloud model could not be reached by the Ollama Cloud
+  // proxy. Fail over to a different model/endpoint rather than
+  // retrying the same one.
+  "bad_gateway",
   "rate_limited",
   "auth_error",
   // A candidate endpoint rejected the request pre-flight for a known-unsupported
@@ -161,6 +219,24 @@ var OllamaServerError = class extends OllamaClientError {
     super(message, { ...options, code: "server_error", retryable: true });
   }
 };
+var OllamaOverloadedError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "overloaded", status: 503, retryable: true });
+  }
+};
+var OllamaBadGatewayError = class extends OllamaClientError {
+  constructor(message, options) {
+    super(message, { ...options, code: "bad_gateway", status: 502, retryable: true });
+  }
+};
+var OllamaStreamError = class extends OllamaClientError {
+  /** Content accumulated before the in-band error frame, or '' if none. */
+  partialContent;
+  constructor(message, options) {
+    super(message, { ...options, code: "stream_error", retryable: false });
+    this.partialContent = options?.partialContent ?? "";
+  }
+};
 var OllamaAbortError = class extends OllamaClientError {
   constructor(message, options) {
     super(message, { ...options, code: "aborted", retryable: false });
@@ -184,6 +260,35 @@ var OllamaRequestValidationError = class extends OllamaClientError {
     this.issues = options.issues;
   }
 };
+var OllamaRequestTooLargeError = class extends OllamaClientError {
+  operationId;
+  actualBytes;
+  maxBytes;
+  constructor(message, options) {
+    super(message, { ...options, code: "request_too_large", retryable: false, status: 413 });
+    this.operationId = options.operationId;
+    this.actualBytes = options.actualBytes;
+    this.maxBytes = options.maxBytes;
+  }
+};
+var OllamaResponseValidationError = class extends OllamaClientError {
+  operationId;
+  issues;
+  constructor(message, options) {
+    super(message, { ...options, code: "response_validation_error", retryable: false });
+    this.operationId = options.operationId;
+    this.issues = options.issues;
+  }
+};
+var OllamaServerVersionUnknownError = class extends OllamaClientError {
+  operationId;
+  minRequiredVersion;
+  constructor(message, options) {
+    super(message, { ...options, code: "server_version_unknown", retryable: false });
+    this.operationId = options.operationId;
+    this.minRequiredVersion = options.minRequiredVersion;
+  }
+};
 var OllamaToolTimeoutError = class extends OllamaClientError {
   toolName;
   timeoutMs;
@@ -281,6 +386,12 @@ function statusToError(status, message, options) {
   if (status === 429) {
     return new OllamaRateLimitError(message, { ...options, status });
   }
+  if (status === 502) {
+    return new OllamaBadGatewayError(message, { ...options });
+  }
+  if (status === 503) {
+    return new OllamaOverloadedError(message, { ...options });
+  }
   if (status >= 500) {
     return new OllamaServerError(message, { ...options, status });
   }
@@ -551,6 +662,75 @@ function composeMiddleware(middlewares, finalHandler) {
   };
 }
 
+// src/vision.ts
+var DATA_URI_PATTERN = /^data:image\/[a-z0-9.+-]+;base64,/i;
+var IMAGE_FILE_EXTENSION_PATTERN = /\.(png|jpe?g|webp|gif|bmp|tiff?|avif)$/i;
+function imageStringNeedsResolution(input) {
+  return DATA_URI_PATTERN.test(input) || input.startsWith("http://") || input.startsWith("https://") || IMAGE_FILE_EXTENSION_PATTERN.test(input);
+}
+function hasNodeFs() {
+  return typeof process !== "undefined" && process !== null && typeof process.versions?.node === "string";
+}
+var NODE_FS_MODULE = "node:fs";
+async function readFileAsBase64(path) {
+  const { promises: fs } = await import(NODE_FS_MODULE);
+  const data = await fs.readFile(path);
+  return data.toString("base64");
+}
+async function fetchUrlAsBase64(url, signal) {
+  const res = await fetch(url, signal !== void 0 ? { signal } : void 0);
+  if (!res.ok) {
+    throw new OllamaClientError(
+      `Failed to fetch image from URL "${url}": HTTP ${res.status} ${res.statusText}.`,
+      { code: "image_fetch_failed" }
+    );
+  }
+  const arrayBuffer = await res.arrayBuffer();
+  return encodeBytesBase64(new Uint8Array(arrayBuffer));
+}
+function encodeBytesBase64(bytes) {
+  const bufferCtor = globalThis.Buffer;
+  if (bufferCtor !== void 0) return bufferCtor.from(bytes).toString("base64");
+  const CHUNK_SIZE = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK_SIZE));
+  }
+  return btoa(binary);
+}
+async function resolveImageInput(input, signal) {
+  if (typeof input !== "string") {
+    return encodeBytesBase64(input instanceof Uint8Array ? input : new Uint8Array(input));
+  }
+  if (DATA_URI_PATTERN.test(input)) {
+    return input.replace(DATA_URI_PATTERN, "").trim();
+  }
+  if (input.startsWith("http://") || input.startsWith("https://")) {
+    return fetchUrlAsBase64(input, signal);
+  }
+  if (IMAGE_FILE_EXTENSION_PATTERN.test(input)) {
+    if (!hasNodeFs()) {
+      throw new OllamaClientError(
+        `Vision input "${input}" looks like a local file path, but this runtime has no Node.js \`fs\` module (browser/edge). Read the file into bytes yourself and pass the \`Uint8Array\`, or pass a base64 string / data URI / http(s) URL instead.`,
+        { code: "vision_path_unsupported_runtime" }
+      );
+    }
+    try {
+      return await readFileAsBase64(input);
+    } catch {
+      return input;
+    }
+  }
+  return input.trim();
+}
+async function resolveImages(images, signal) {
+  if (images === void 0) return void 0;
+  if (images.every((image) => typeof image === "string" && !imageStringNeedsResolution(image))) {
+    return images;
+  }
+  return Promise.all(images.map((image) => resolveImageInput(image, signal)));
+}
+
 // src/utils.ts
 async function encodeImage(image) {
   if (typeof image === "string") return image;
@@ -563,18 +743,22 @@ async function encodeImage(image) {
   }
   return btoa(binary);
 }
-async function encodeImages(images) {
-  if (images === void 0) return void 0;
-  return Promise.all(images.map((image) => encodeImage(image)));
+async function encodeImages(images, signal) {
+  return resolveImages(images, signal);
 }
-async function withEncodedImages(req) {
-  if (!req.images?.some((image) => image instanceof Uint8Array)) return req;
-  return { ...req, images: await encodeImages(req.images) };
+async function withEncodedImages(req, signal) {
+  const needsResolution = req.images?.some(
+    (image) => typeof image !== "string" || imageStringNeedsResolution(image)
+  );
+  if (!needsResolution) return req;
+  return { ...req, images: await encodeImages(req.images ?? [], signal) };
 }
-async function withEncodedMessageImages(messages) {
-  if (!messages.some((message) => message.images?.some((image) => image instanceof Uint8Array)))
-    return messages;
-  return Promise.all(messages.map((message) => withEncodedImages(message)));
+async function withEncodedMessageImages(messages, signal) {
+  const needsResolution = messages.some(
+    (message) => message.images?.some((image) => typeof image !== "string" || imageStringNeedsResolution(image))
+  );
+  if (!needsResolution) return messages;
+  return Promise.all(messages.map((message) => withEncodedImages(message, signal)));
 }
 function disposableTimer(timer) {
   return {
@@ -603,6 +787,12 @@ function disposableSpan(span) {
 }
 
 // src/streaming/ndjson.ts
+function isInBandErrorFrame(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  if (typeof record.error !== "string" || record.error.length === 0) return false;
+  return !("model" in record) && !("response" in record) && !("message" in record) && !("status" in record) && !("done" in record);
+}
 async function* parseNdjsonStream(stream) {
   var _stack = [];
   try {
@@ -619,17 +809,34 @@ async function* parseNdjsonStream(stream) {
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
+        let json;
         try {
-          yield JSON.parse(trimmed);
+          json = JSON.parse(trimmed);
         } catch (err) {
           throw new OllamaGenericClientError(`Failed to parse stream JSON chunk: ${trimmed}`, {
             cause: err
           });
         }
+        if (isInBandErrorFrame(json)) {
+          throw new OllamaStreamError(json.error);
+        }
+        yield json;
       }
     }
     if (buffer.trim()) {
-      yield JSON.parse(buffer.trim());
+      const trimmed = buffer.trim();
+      let json;
+      try {
+        json = JSON.parse(trimmed);
+      } catch (err) {
+        throw new OllamaGenericClientError(`Failed to parse stream JSON chunk: ${trimmed}`, {
+          cause: err
+        });
+      }
+      if (isInBandErrorFrame(json)) {
+        throw new OllamaStreamError(json.error);
+      }
+      yield json;
     }
   } catch (_) {
     var _error = _, _hasError = true;
@@ -840,7 +1047,7 @@ var HttpClient = class {
   onLifecycleEvent;
   requestId;
   constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
     this.apiKey = options.apiKey;
     this.defaultHeaders = options.headers ?? {};
     this.fetchImpl = options.fetch ?? globalThis.fetch;
@@ -1229,7 +1436,7 @@ async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3, middlew
 function inferRuntimeMode(baseUrl) {
   try {
     const url = new URL(baseUrl);
-    const host = url.hostname.toLowerCase();
+    const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
     if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.startsWith("192.168.") || host.startsWith("10.")) {
       return "local";
     }
@@ -1247,6 +1454,63 @@ function extractContextLength(modelInfo) {
   }
   return void 0;
 }
+function extractModelFamily(showRes) {
+  if (showRes.model_info) {
+    for (const [key, value] of Object.entries(showRes.model_info)) {
+      if (key.endsWith(".architecture") && typeof value === "string" && value.length > 0) {
+        return value.toLowerCase();
+      }
+    }
+  }
+  if (showRes.details?.family && showRes.details.family.length > 0) {
+    return showRes.details.family.toLowerCase();
+  }
+  const families = showRes.details?.families;
+  if (families && families.length > 0) {
+    const first = families[0];
+    if (typeof first === "string" && first.length > 0) return first.toLowerCase();
+  }
+  return void 0;
+}
+var PARALLEL_TOOL_CALL_LOCAL_FAMILIES = /* @__PURE__ */ new Set([
+  "qwen2",
+  "qwen2.5",
+  "qwen3",
+  "llama3.1",
+  "llama3.2",
+  "llama3.3",
+  "llama4",
+  "mistral",
+  "mixtral",
+  "hermes",
+  "command-r",
+  "command-r-plus"
+]);
+var PARALLEL_TOOL_CALL_NAME_HINTS = /* @__PURE__ */ new Set([
+  "tool-use",
+  "tooluse",
+  "function-call",
+  "functioncall",
+  "instruct",
+  // Most "instruct" variants of tool-capable families ship with parallel tool calls
+  "hermes",
+  "command-r"
+]);
+function inferLocalParallelToolCalls(model, family) {
+  const modelLower = model.toLowerCase();
+  if (family !== void 0 && PARALLEL_TOOL_CALL_LOCAL_FAMILIES.has(family)) {
+    return "yes";
+  }
+  for (const hint of PARALLEL_TOOL_CALL_NAME_HINTS) {
+    if (modelLower.includes(hint)) {
+      return "yes";
+    }
+  }
+  return "unknown";
+}
+function inferCloudParallelToolCalls(supportsTools) {
+  return supportsTools ? "yes" : "unknown";
+}
 async function detectModelCapabilities(http, model, signal) {
   const showRes = await http.request({
     path: "/api/show",
@@ -1256,10 +1520,16 @@ async function detectModelCapabilities(http, model, signal) {
   const reported = showRes.capabilities ?? [];
   const reportedSet = new Set(reported.map((c) => c.toLowerCase()));
   const contextLength = extractContextLength(showRes.model_info);
+  const supportsTools = reportedSet.has("tools");
+  const runtimeMode = inferRuntimeMode(http.baseUrl);
+  const parallelToolCalls = runtimeMode === "cloud" ? inferCloudParallelToolCalls(supportsTools) : runtimeMode === "local" ? inferLocalParallelToolCalls(model, extractModelFamily(showRes)) : (
+    // unknown runtime mode — can't even tell if we're cloud or local
+    "unknown"
+  );
   return {
     model,
     reported,
-    supportsTools: reportedSet.has("tools"),
+    supportsTools,
     supportsVision: reportedSet.has("vision"),
     supportsEmbedding: reportedSet.has("embedding"),
     supportsCompletion: reportedSet.has("completion") || !reportedSet.has("embedding"),
@@ -1267,7 +1537,8 @@ async function detectModelCapabilities(http, model, signal) {
     ...showRes.thinking !== void 0 ? { thinking: showRes.thinking } : {},
     ...contextLength !== void 0 ? { contextLength } : {},
     supportsStreaming: true,
-    supportsStructuredOutputRequest: inferRuntimeMode(http.baseUrl) !== "cloud"
+    supportsStructuredOutputRequest: runtimeMode !== "cloud",
+    parallelToolCalls
   };
 }
 async function listAvailableModels(http) {
@@ -1412,7 +1683,131 @@ function ensureToolCallIds(toolCalls) {
   return toolCalls.map((tc) => tc.id !== void 0 ? tc : { ...tc, id: generateToolCallId() });
 }
 
+// src/tools/tool-call-accumulator.ts
+function isSameToolCall(a, b, aIndex, bIndex) {
+  if (a.id !== void 0 && b.id !== void 0) {
+    return a.id === b.id;
+  }
+  if (aIndex !== void 0 && bIndex !== void 0) {
+    return aIndex === bIndex;
+  }
+  return false;
+}
+function mergeToolCall(earlier, later) {
+  const earlierFn = earlier.function;
+  const laterFn = later.function;
+  const earlierArgs = earlierFn.arguments;
+  const laterArgs = laterFn.arguments;
+  const mergedFn = {
+    name: laterFn.name || earlierFn.name,
+    arguments: earlierArgs !== void 0 && laterArgs !== void 0 ? { ...earlierArgs, ...laterArgs } : laterArgs ?? earlierArgs ?? {}
+  };
+  return {
+    // id: prefer the later one if present, else the earlier one
+    ...later.id !== void 0 ? { id: later.id } : earlier.id !== void 0 ? { id: earlier.id } : {},
+    function: mergedFn
+  };
+}
+function mergeToolCallArgumentsString(earlier, later) {
+  const earlierArgs = earlier.function.arguments;
+  const laterArgs = later.function.arguments;
+  const concatenated = (typeof earlierArgs === "string" ? earlierArgs : "") + (typeof laterArgs === "string" ? laterArgs : "");
+  return {
+    ...later.id !== void 0 ? { id: later.id } : earlier.id !== void 0 ? { id: earlier.id } : {},
+    function: {
+      name: later.function.name || earlier.function.name,
+      arguments: concatenated
+    }
+  };
+}
+var ToolCallAccumulator = class {
+  entries = [];
+  /**
+   * Process a chunk's `tool_calls` array. Entries that match an
+   * existing accumulated entry (by id or array position) are merged;
+   * new entries are appended.
+   *
+   * Returns the current accumulated state (a shallow copy — entries
+   * themselves are NOT deep-cloned, so callers that mutate
+   * `function.arguments` on a returned entry will mutate the
+   * accumulator's internal state. Use {@link snapshot} for an
+   * explicitly read-only view, or deep-clone the result if you need
+   * full isolation).
+   */
+  process(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) {
+      return [...this.entries];
+    }
+    for (let i = 0; i < toolCalls.length; i++) {
+      const incoming = toolCalls[i];
+      if (!incoming) continue;
+      let matchedIndex = -1;
+      for (let j = 0; j < this.entries.length; j++) {
+        const existing = this.entries[j];
+        if (existing && isSameToolCall(existing, incoming, j, i)) {
+          matchedIndex = j;
+          break;
+        }
+      }
+      if (matchedIndex >= 0) {
+        this.entries[matchedIndex] = mergeToolCall(this.entries[matchedIndex], incoming);
+      } else {
+        this.entries.push(incoming);
+      }
+    }
+    return [...this.entries];
+  }
+  /**
+   * Returns the final accumulated tool calls. Identical to calling
+   * `process(undefined)` — included for ergonomics so callers can
+   * express "I'm done, give me the result" without a no-op call.
+   *
+   * The returned array is a shallow copy; entries themselves are
+   * the same object references the accumulator holds internally.
+   */
+  finalize() {
+    return [...this.entries];
+  }
+  /**
+   * Returns the current accumulated state without modifying the
+   * accumulator. Useful for mid-stream inspection.
+   *
+   * The returned array is a shallow copy; mutating it (e.g.
+   * `result.push(...)`) does not affect the accumulator, but
+   * mutating an entry's `function.arguments` object DOES affect
+   * the accumulator's internal state because the entry reference
+   * is shared. Deep-clone the result if you need full isolation.
+   */
+  snapshot() {
+    return [...this.entries];
+  }
+  /**
+   * Returns the number of accumulated tool calls so far.
+   */
+  get length() {
+    return this.entries.length;
+  }
+};
+function mergeToolCallArrays(earlier, later) {
+  const acc = new ToolCallAccumulator();
+  acc.process(earlier);
+  acc.process(later);
+  return acc.finalize();
+}
+
 // src/streaming/stream.ts
+function extractPartialContent(accumulated) {
+  if (typeof accumulated !== "object" || accumulated === null) return "";
+  const record = accumulated;
+  const message = record.message;
+  if (typeof message === "object" && message !== null) {
+    const content = message.content;
+    if (typeof content === "string") return content;
+  }
+  const response = record.response;
+  if (typeof response === "string") return response;
+  return "";
+}
 var OllamaStream = class {
   constructor(source, mapChunk, aggregate, initial, signal) {
     this.source = source;
@@ -1433,10 +1828,6 @@ var OllamaStream = class {
       }
     }
   }
-  source;
-  mapChunk;
-  aggregate;
-  initial;
   mode = "unconsumed";
   listeners = /* @__PURE__ */ new Map();
   finalResultPromise;
@@ -1495,7 +1886,10 @@ var OllamaStream = class {
     } catch (error) {
       this.removeAbortListener?.();
       this.removeAbortListener = void 0;
-      const mapped = mapError(error);
+      const mapped = error instanceof OllamaStreamError && error.partialContent === "" ? new OllamaStreamError(error.message, {
+        partialContent: extractPartialContent(accumulated),
+        cause: error
+      }) : mapError(error);
       this.emit({ type: "error", data: { error: mapped } });
       this.rejectFinal(mapped);
     }
@@ -1522,7 +1916,10 @@ var OllamaStream = class {
         }
       }
     } catch (error) {
-      const mapped = mapError(error);
+      const mapped = error instanceof OllamaStreamError && error.partialContent === "" ? new OllamaStreamError(error.message, {
+        partialContent: extractPartialContent(accumulated),
+        cause: error
+      }) : mapError(error);
       this.rejectFinal(mapped);
       yield { type: "error", data: { error: mapped } };
     } finally {
@@ -1544,7 +1941,17 @@ function aggregateChat(accumulated, chunk) {
       role: message.role || accumulated.message.role,
       content: accumulated.message.content + (message.content ?? ""),
       thinking: message.thinking !== void 0 ? (accumulated.message.thinking ?? "") + message.thinking : accumulated.message.thinking,
-      tool_calls: message.tool_calls?.length ? [...accumulated.message.tool_calls ?? [], ...message.tool_calls] : accumulated.message.tool_calls
+      // Defensive tool-call merging: instead of blindly appending
+      // every chunk's tool_calls array (which would produce
+      // duplicates if Ollama ever starts streaming them
+      // incrementally), merge entries that refer to the same logical
+      // call (matched by id or array position). For the documented
+      // native behavior (tool_calls arrive complete in one chunk)
+      // this is a no-op — the accumulator appends exactly once.
+      //
+      // See src/tools/tool-call-accumulator.ts for the full merge
+      // semantics and the rationale.
+      tool_calls: message.tool_calls?.length || accumulated.message.tool_calls?.length ? mergeToolCallArrays(accumulated.message.tool_calls, message.tool_calls) : void 0
     },
     model: chunk.model,
     done: chunk.done,
@@ -1753,12 +2160,24 @@ function createTimeoutSignal(timeoutMs, userSignal) {
   return { signal: controller.signal, cancel };
 }
 
+// src/keep-alive.ts
+var KEEP_ALIVE_UNLOAD = 0;
+var KEEP_ALIVE_INDEFINITE = -1;
+function normalizeKeepAlive(keepAlive) {
+  if (keepAlive === void 0) return void 0;
+  if (keepAlive === "unload") return KEEP_ALIVE_UNLOAD;
+  if (keepAlive === "indefinite") return KEEP_ALIVE_INDEFINITE;
+  return keepAlive;
+}
+function isKeepAliveSugar(value) {
+  return value === "unload" || value === "indefinite";
+}
+
 // src/models-client.ts
 var ModelsClient = class {
   constructor(runner) {
     this.runner = runner;
   }
-  runner;
   list() {
     return this.runner((http) => listAvailableModels(http), { singleEndpoint: true });
   }
@@ -1865,6 +2284,76 @@ var ModelsClient = class {
       { singleEndpoint: true }
     );
   }
+  /**
+   * Immediately unloads `model` from VRAM/RAM by issuing an empty
+   * `/api/generate` request with `keep_alive: 0`. The server
+   * finalizes any in-flight generation, releases the model's
+   * weights from GPU memory, and frees the slot for subsequent
+   * pipelines (e.g. swap a vision encoder out before loading an
+   * LLM).
+   *
+   * This is the ergonomic equivalent of:
+   *
+   * ```ts
+   * client.generate({ model, prompt: '', keep_alive: 0 });
+   * ```
+   *
+   * Use {@link pin} for the opposite lifecycle — pinning a model
+   * indefinitely in VRAM for hot-loop inference.
+   *
+   * Resolves once the server acknowledges the unload. The promise
+   * rejects on transport errors, model-not-found (404), or auth
+   * failures — callers handling transient issues can retry via the
+   * standard {@link withRetry} policy.
+   *
+   * See: https://github.com/ollama/ollama/blob/main/docs/faq.md
+   *      #how-do-i-keep-a-model-loaded-in-memory-or-make-it-unload-immediately
+   */
+  async unload(model) {
+    await this.runner(
+      (http, signal) => http.request({
+        path: "/api/generate",
+        body: { model, prompt: "", keep_alive: KEEP_ALIVE_UNLOAD, stream: false },
+        signal
+      }),
+      { model, singleEndpoint: true }
+    );
+  }
+  /**
+   * Pre-loads and pins `model` into VRAM indefinitely by issuing an
+   * empty `/api/generate` request with `keep_alive: -1`. The server
+   * loads the model into GPU memory (paying the cold-load latency
+   * once) and keeps it resident until either:
+   *
+   *   - an explicit {@link unload} call is made,
+   *   - the server process is restarted, or
+   *   - the host runs out of VRAM and the server's own eviction
+   *     policy kicks in.
+   *
+   * This is the ergonomic equivalent of:
+   *
+   * ```ts
+   * client.generate({ model, prompt: '', keep_alive: -1 });
+   * ```
+   *
+   * Use {@link unload} to release the pinned slot when the hot loop
+   * is done — leaving models pinned indefinitely exhausts VRAM and
+   * starves subsequent pipelines.
+   *
+   * Resolves once the server acknowledges the pin (i.e. the model
+   * is fully loaded). The promise rejects on transport errors,
+   * model-not-found (404), or VRAM-exhaustion failures.
+   */
+  async pin(model) {
+    await this.runner(
+      (http, signal) => http.request({
+        path: "/api/generate",
+        body: { model, prompt: "", keep_alive: KEEP_ALIVE_INDEFINITE, stream: false },
+        signal
+      }),
+      { model, singleEndpoint: true }
+    );
+  }
   async createBlob(digest, data) {
     await this.runner(
       (http, signal) => http.request({
@@ -1887,9 +2376,104 @@ var ModelsClient = class {
         { singleEndpoint: true }
       );
       return true;
-    } catch {
-      return false;
+    } catch (err) {
+      if (err instanceof OllamaNotFoundError) return false;
+      throw err;
+    }
+  }
+  /**
+   * Computes a blob digest the way Ollama's content-addressed store expects:
+   * SHA-256 over the raw bytes, formatted as `sha256:<64 lowercase hex>`.
+   *
+   * Uses the Web Crypto API (`crypto.subtle.digest`), which exists in every
+   * supported runtime — Node.js ≥ 19 exposes it as a global (this SDK
+   * requires Node ≥ 20), and browsers/edge runtimes have always had it.
+   */
+  async computeBlobDigest(data) {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === void 0) {
+      throw new OllamaClientError(
+        "computeBlobDigest requires the Web Crypto API (crypto.subtle), unavailable in this runtime.",
+        { code: "crypto_unavailable" }
+      );
+    }
+    const digestBytes = await subtle.digest("SHA-256", data);
+    const hex = Array.from(
+      new Uint8Array(digestBytes),
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+    return `sha256:${hex}`;
+  }
+  /**
+   * Computes the SHA-256 digest of `data` and pushes it as a blob in one
+   * step — the content-addressed upload Ollama's own tooling performs
+   * (`curl -T file http://…/api/blobs/sha256:…`). Returns the digest, which
+   * `/api/create`'s `files` field references.
+   *
+   * Pass `digest` to skip recomputation when the caller already knows it —
+   * the server verifies the content against the digest and rejects mismatches.
+   */
+  async createBlobFromData(data, opts) {
+    const digest = opts?.digest ?? await this.computeBlobDigest(data);
+    const alreadyExisted = await this.checkBlob(digest);
+    if (!alreadyExisted) {
+      await this.createBlob(digest, data);
+    }
+    return { digest, alreadyExisted };
+  }
+  /**
+   * Reads a local file and uploads it as a blob (Node.js only — dynamic
+   * `node:fs` import, so browser bundles never pull it in). The file name
+   * (basename) is what `/api/create`'s `files` map expects as the key, so
+   * this returns it alongside the digest.
+   */
+  async createBlobFromFile(path, opts) {
+    const nodeFsModule = "node:fs";
+    const { promises: fs } = await import(nodeFsModule);
+    const data = await fs.readFile(path);
+    const result = await this.createBlobFromData(new Uint8Array(data), {
+      ...opts
+    });
+    const fileName = path.split(/[\\/]/).pop() ?? path;
+    return { ...result, fileName };
+  }
+  /**
+   * One-shot custom-model publishing from raw GGUF weights, following the
+   * protocol Ollama's API reference documents: push a blob for the GGUF
+   * bytes, then `POST /api/create` with `files: { <fileName>: <digest> }`.
+   * Split GGUFs are supported via `files` — pass every shard's path.
+   *
+   * ```ts
+   * await client.models.createModelFromGguf('my-model', '/path/to/model.gguf', {
+   *   template: '{{ .Prompt }}',
+   * });
+   * ```
+   *
+   * @param model Name for the new model (e.g. `'my-model:latest'`).
+   * @param gguf Path(s) to GGUF file(s) on the local filesystem.
+   * @param opts Everything else `/api/create` accepts (`template`, `system`,
+   *   `parameters`, `license`, `quantize`, …) except `files` and `from`.
+   */
+  async createModelFromGguf(model, gguf, opts) {
+    const paths = typeof gguf === "string" ? [gguf] : gguf;
+    if (paths.length === 0) {
+      throw new OllamaClientError("createModelFromGguf: at least one GGUF path is required.", {
+        code: "invalid_request"
+      });
     }
+    const files = {};
+    for (const path of paths) {
+      const uploaded = await this.createBlobFromFile(path, { signal: opts?.signal });
+      files[uploaded.fileName] = uploaded.digest;
+    }
+    const {
+      model: _model,
+      files: _files,
+      from: _from,
+      stream: _stream,
+      ...rest
+    } = opts ?? {};
+    return this.create({ ...rest, model, files, stream: false });
   }
 };
 
@@ -1917,7 +2501,6 @@ var OpenAIChatCompletionStream = class {
       }
     }
   }
-  source;
   finalResultPromise;
   resolveFinal;
   rejectFinal;
@@ -2061,7 +2644,6 @@ var OpenAICompletionStream = class {
       }
     }
   }
-  source;
   finalResultPromise;
   resolveFinal;
   rejectFinal;
@@ -2142,7 +2724,6 @@ var OpenAIResponsesStream = class {
       }
     }
   }
-  source;
   finalResultPromise;
   resolveFinal;
   rejectFinal;
@@ -2367,8 +2948,6 @@ var OpenAICompatClient = class {
     this.http = http;
     this.runner = runner;
   }
-  http;
-  runner;
   request(operation, model, signal, holdUntil) {
     if (this.runner) {
       return this.runner(
@@ -2588,7 +3167,6 @@ var AnthropicMessagesStream = class {
       }
     }
   }
-  source;
   finalResultPromise;
   resolveFinal;
   rejectFinal;
@@ -2703,8 +3281,6 @@ var AnthropicCompatClient = class {
     this.http = http;
     this.runner = runner;
   }
-  http;
-  runner;
   request(operation, model, signal, holdUntil) {
     if (this.runner) {
       return this.runner(
@@ -2750,6 +3326,32 @@ var AnthropicCompatClient = class {
     return this.createMessage(request, signal);
   }
 };
+var IncludedBalanceSchema = zod.z.object({
+  balance_usd: zod.z.number(),
+  allowance_usd: zod.z.number(),
+  period: zod.z.object({
+    from: zod.z.string(),
+    until: zod.z.string()
+  })
+});
+var LegacyBalanceLimitSchema = zod.z.object({
+  remaining_percent: zod.z.number().min(0).max(100),
+  resets_at: zod.z.string()
+});
+
+// src/generated/models/LegacyIncludedBalance.schema.ts
+var LegacyIncludedBalanceSchema = zod.z.object({
+  session: LegacyBalanceLimitSchema,
+  weekly: LegacyBalanceLimitSchema
+});
+
+// src/generated/models/BalanceResponse.schema.ts
+var BalanceResponseSchema = zod.z.object({
+  included: zod.z.union([IncludedBalanceSchema, LegacyIncludedBalanceSchema]),
+  purchased: zod.z.object({
+    balance_usd: zod.z.number()
+  })
+});
 var ToolCallSchema = zod.z.object({
   function: zod.z.object({
     name: zod.z.string(),
@@ -2798,28 +3400,45 @@ var ChatRequestSchema = zod.z.object({
   logprobs: zod.z.boolean().optional(),
   top_logprobs: zod.z.number().optional()
 });
-var GenerateRequestSchema = zod.z.object({
-  model: zod.z.string(),
-  prompt: zod.z.string().optional(),
-  suffix: zod.z.string().optional(),
-  images: zod.z.array(zod.z.string()).optional(),
-  format: zod.z.union([zod.z.string(), zod.z.object({})]).optional(),
-  system: zod.z.string().optional(),
-  stream: zod.z.boolean().optional(),
-  think: ThinkValueSchema.optional(),
-  raw: zod.z.boolean().optional(),
-  keep_alive: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
-  options: ModelOptionsSchema.optional(),
-  logprobs: zod.z.boolean().optional(),
-  top_logprobs: zod.z.number().optional()
+var TokenLogprobSchema = zod.z.object({
+  token: zod.z.string().optional(),
+  logprob: zod.z.number().optional(),
+  bytes: zod.z.array(zod.z.number()).optional()
 });
-var EmbedRequestSchema = zod.z.object({
-  model: zod.z.string(),
-  input: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
-  truncate: zod.z.boolean().optional(),
-  dimensions: zod.z.number().optional(),
-  keep_alive: zod.z.string().optional(),
-  options: ModelOptionsSchema.optional()
+
+// src/generated/models/Logprob.schema.ts
+var LogprobSchema = zod.z.object({
+  token: zod.z.string().optional(),
+  logprob: zod.z.number().optional(),
+  bytes: zod.z.array(zod.z.number()).optional(),
+  top_logprobs: zod.z.array(TokenLogprobSchema).optional()
+});
+
+// src/generated/models/ChatResponse.schema.ts
+var ChatResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  created_at: zod.z.string().optional(),
+  message: zod.z.object({
+    role: zod.z.enum(["assistant"]).optional(),
+    content: zod.z.string().optional(),
+    thinking: zod.z.string().optional(),
+    tool_calls: zod.z.array(ToolCallSchema).optional(),
+    images: zod.z.array(zod.z.string()).optional()
+  }).optional(),
+  done: zod.z.boolean().optional(),
+  done_reason: zod.z.string().optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional(),
+  prompt_eval_cached_count: zod.z.number().optional(),
+  prompt_eval_duration: zod.z.number().optional(),
+  eval_count: zod.z.number().optional(),
+  eval_duration: zod.z.number().optional(),
+  logprobs: zod.z.array(LogprobSchema).optional()
+});
+var CopyRequestSchema = zod.z.object({
+  source: zod.z.string(),
+  destination: zod.z.string()
 });
 var CreateRequestSchema = zod.z.object({
   model: zod.z.string(),
@@ -2836,50 +3455,296 @@ var CreateRequestSchema = zod.z.object({
   quantize: zod.z.string().optional(),
   draft_quantize: zod.z.string().optional(),
   requires: zod.z.string().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional(),
   stream: zod.z.boolean().optional()
 });
-var CopyRequestSchema = zod.z.object({
-  source: zod.z.string(),
-  destination: zod.z.string()
-});
 var DeleteRequestSchema = zod.z.object({
   model: zod.z.string()
 });
-var PullRequestSchema = zod.z.object({
+var EmbedRequestSchema = zod.z.object({
   model: zod.z.string(),
-  insecure: zod.z.boolean().optional(),
-  stream: zod.z.boolean().optional()
+  input: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]),
+  truncate: zod.z.boolean().optional(),
+  dimensions: zod.z.number().optional(),
+  keep_alive: zod.z.string().optional(),
+  options: ModelOptionsSchema.optional()
 });
-var PushRequestSchema = zod.z.object({
-  model: zod.z.string(),
-  insecure: zod.z.boolean().optional(),
-  stream: zod.z.boolean().optional()
+var EmbedResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  embeddings: zod.z.array(zod.z.array(zod.z.number())).optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional()
 });
-var ShowRequestSchema = zod.z.object({
+var GenerateRequestSchema = zod.z.object({
   model: zod.z.string(),
-  verbose: zod.z.boolean().optional()
+  prompt: zod.z.string().optional(),
+  suffix: zod.z.string().optional(),
+  images: zod.z.array(zod.z.string()).optional(),
+  format: zod.z.union([zod.z.string(), zod.z.object({})]).optional(),
+  system: zod.z.string().optional(),
+  stream: zod.z.boolean().optional(),
+  think: ThinkValueSchema.optional(),
+  raw: zod.z.boolean().optional(),
+  keep_alive: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  options: ModelOptionsSchema.optional(),
+  logprobs: zod.z.boolean().optional(),
+  top_logprobs: zod.z.number().optional()
 });
-
+var GenerateResponseSchema = zod.z.object({
+  model: zod.z.string().optional(),
+  created_at: zod.z.string().optional(),
+  response: zod.z.string().optional(),
+  thinking: zod.z.string().optional(),
+  done: zod.z.boolean().optional(),
+  done_reason: zod.z.string().optional(),
+  total_duration: zod.z.number().optional(),
+  load_duration: zod.z.number().optional(),
+  prompt_eval_count: zod.z.number().optional(),
+  prompt_eval_cached_count: zod.z.number().optional(),
+  prompt_eval_duration: zod.z.number().optional(),
+  eval_count: zod.z.number().optional(),
+  eval_duration: zod.z.number().optional(),
+  logprobs: zod.z.array(LogprobSchema).optional()
+});
+var ModelSummarySchema = zod.z.object({
+  name: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  remote_model: zod.z.string().optional(),
+  remote_host: zod.z.string().optional(),
+  modified_at: zod.z.string().optional(),
+  size: zod.z.number().optional(),
+  digest: zod.z.string().optional(),
+  details: zod.z.object({
+    format: zod.z.string().optional(),
+    family: zod.z.string().optional(),
+    families: zod.z.union([zod.z.array(zod.z.string()), zod.z.null()]).optional(),
+    parameter_size: zod.z.string().optional(),
+    quantization_level: zod.z.string().optional()
+  }).optional()
+});
+
+// src/generated/models/ListResponse.schema.ts
+var ListResponseSchema = zod.z.object({
+  models: zod.z.array(ModelSummarySchema).optional()
+});
+var PsSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  model: zod.z.string().optional(),
+  size: zod.z.number().optional(),
+  digest: zod.z.string().optional(),
+  details: zod.z.object({}).optional(),
+  expires_at: zod.z.string().optional(),
+  size_vram: zod.z.number().optional(),
+  context_length: zod.z.number().optional()
+});
+
+// src/generated/models/PsResponse.schema.ts
+var PsResponseSchema = zod.z.object({
+  models: zod.z.array(PsSchema).optional()
+});
+var PullRequestSchema = zod.z.object({
+  model: zod.z.string(),
+  insecure: zod.z.boolean().optional(),
+  stream: zod.z.boolean().optional()
+});
+var PushRequestSchema = zod.z.object({
+  model: zod.z.string(),
+  insecure: zod.z.boolean().optional(),
+  stream: zod.z.boolean().optional()
+});
+var ShowRequestSchema = zod.z.object({
+  model: zod.z.string(),
+  verbose: zod.z.boolean().optional()
+});
+var ThinkingSchema = zod.z.object({
+  values: zod.z.array(zod.z.union([zod.z.boolean(), zod.z.string()])),
+  default: zod.z.union([zod.z.boolean(), zod.z.string()])
+});
+
+// src/generated/models/ShowResponse.schema.ts
+var ShowResponseSchema = zod.z.object({
+  thinking: ThinkingSchema.optional(),
+  parameters: zod.z.string().optional(),
+  license: zod.z.string().optional(),
+  modified_at: zod.z.string().optional(),
+  details: zod.z.object({}).optional(),
+  template: zod.z.string().optional(),
+  capabilities: zod.z.array(zod.z.string()).optional(),
+  model_info: zod.z.object({}).optional()
+});
+var StatusResponseSchema = zod.z.object({
+  status: zod.z.string().optional()
+});
+var SystemOneContentSchema = zod.z.union([
+  zod.z.string().regex(new RegExp("\\S")),
+  zod.z.object({}).catchall(zod.z.unknown()),
+  zod.z.array(zod.z.unknown())
+]);
+
+// src/generated/models/SystemOneChoiceQuestion.schema.ts
+var SystemOneChoiceQuestionSchema = zod.z.object({
+  type: zod.z.enum(["choice"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.object({}).catchall(zod.z.union([zod.z.string(), zod.z.null()])).refine((v) => Object.keys(v).length >= 2, { message: "must have at least 2 properties" }).refine((v) => Object.keys(v).length <= 26, { message: "must have at most 26 properties" }).refine((v) => Object.keys(v).every((k) => new RegExp("\\S").test(k)), {
+    message: 'property names must match pattern "\\S"'
+  })
+});
+var SystemOneNoulQuestionSchema = zod.z.object({
+  type: zod.z.enum(["noul"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.object({
+    false: zod.z.string().optional(),
+    true: zod.z.string().optional()
+  }).optional()
+});
+var SystemOneScoreQuestionSchema = zod.z.object({
+  type: zod.z.enum(["score"]),
+  instructions: SystemOneContentSchema,
+  criteria: zod.z.array(zod.z.string()).min(2).max(26)
+});
+
+// src/generated/models/SystemOneRequest.schema.ts
+var SystemOneRequestSchema = zod.z.object({
+  model: zod.z.string().regex(new RegExp("\\S")),
+  state: SystemOneContentSchema,
+  images: zod.z.array(zod.z.string()).optional(),
+  questions: zod.z.object({}).catchall(
+    zod.z.union([
+      SystemOneChoiceQuestionSchema,
+      SystemOneNoulQuestionSchema,
+      SystemOneScoreQuestionSchema
+    ])
+  ).refine((v) => Object.keys(v).length >= 1, { message: "must have at least 1 properties" }).refine((v) => Object.keys(v).length <= 64, { message: "must have at most 64 properties" }).refine((v) => Object.keys(v).every((k) => new RegExp("\\S").test(k)), {
+    message: 'property names must match pattern "\\S"'
+  }),
+  keep_alive: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+});
+var SystemOneConfidenceSchema = zod.z.number().min(0).max(1);
+var SystemOneProbabilitiesSchema = zod.z.object({}).catchall(zod.z.number().min(0).max(1));
+
+// src/generated/models/SystemOneChoiceAnswer.schema.ts
+var SystemOneChoiceAnswerSchema = zod.z.object({
+  type: zod.z.enum(["choice"]),
+  choice: zod.z.string(),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+var SystemOneNoulAnswerSchema = zod.z.object({
+  type: zod.z.enum(["noul"]),
+  noul: zod.z.number().min(0).max(1)
+});
+var SystemOneScoreAnswerSchema = zod.z.object({
+  type: zod.z.enum(["score"]),
+  score: zod.z.number().min(0).max(25),
+  legend: zod.z.object({}).catchall(zod.z.string()),
+  probabilities: SystemOneProbabilitiesSchema,
+  confidence: SystemOneConfidenceSchema
+});
+
+// src/generated/models/SystemOneResponse.schema.ts
+var SystemOneResponseSchema = zod.z.object({
+  model: zod.z.string(),
+  answers: zod.z.object({}).catchall(
+    zod.z.union([SystemOneChoiceAnswerSchema, SystemOneNoulAnswerSchema, SystemOneScoreAnswerSchema])
+  ),
+  usage: zod.z.object({
+    input_tokens: zod.z.number().min(0),
+    output_tokens: zod.z.number().min(0)
+  })
+});
+var UsageMetricsSchema = zod.z.object({
+  request_count: zod.z.number().min(0),
+  usage_usd: zod.z.number().optional(),
+  input_tokens: zod.z.number().optional(),
+  cached_input_tokens: zod.z.number().optional(),
+  output_tokens: zod.z.number().optional()
+});
+
+// src/generated/models/UsageBucket.schema.ts
+var UsageBucketSchema = zod.z.intersection(
+  UsageMetricsSchema,
+  zod.z.object({
+    from: zod.z.string(),
+    until: zod.z.string(),
+    partial: zod.z.boolean().optional()
+  })
+);
+
+// src/generated/models/UsageResponse.schema.ts
+var UsageResponseSchema = zod.z.object({
+  range: zod.z.enum(["24h", "7d", "30d"]),
+  scope: zod.z.enum(["self", "team"]),
+  granularity: zod.z.enum(["hour", "day"]),
+  from: zod.z.string(),
+  until: zod.z.string(),
+  totals: UsageMetricsSchema,
+  buckets: zod.z.array(UsageBucketSchema)
+});
+var VersionResponseSchema = zod.z.object({
+  version: zod.z.string().optional()
+});
+var WebFetchRequestSchema = zod.z.object({
+  url: zod.z.string()
+});
+var WebFetchResponseSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  links: zod.z.array(zod.z.string()).optional()
+});
+var WebSearchRequestSchema = zod.z.object({
+  query: zod.z.string(),
+  max_results: zod.z.number().min(1).max(10).optional()
+});
+var WebSearchResultSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  content: zod.z.string().optional()
+});
+
+// src/generated/models/WebSearchResponse.schema.ts
+var WebSearchResponseSchema = zod.z.object({
+  results: zod.z.array(WebSearchResultSchema).optional()
+});
+
 // src/generated/runtime/schema-registry.ts
 var requestSchemas = {
   chat: ChatRequestSchema,
-  generate: GenerateRequestSchema,
-  embed: EmbedRequestSchema,
-  create: CreateRequestSchema,
   copy: CopyRequestSchema,
+  create: CreateRequestSchema,
   delete: DeleteRequestSchema,
+  embed: EmbedRequestSchema,
+  generate: GenerateRequestSchema,
   pull: PullRequestSchema,
   push: PushRequestSchema,
-  show: ShowRequestSchema
-  // Operations without a registered request schema (blobs, ps, tags,
-  // version, systemOne, openai*, anthropic*) skip validation. This is
-  // deliberate — the OpenAPI spec doesn't define request bodies for
-  // GET/HEAD operations, and the compat-surface request schemas (OpenAI,
-  // Anthropic) are richer than what the IR currently models.
+  show: ShowRequestSchema,
+  systemOne: SystemOneRequestSchema,
+  webFetch: WebFetchRequestSchema,
+  webSearch: WebSearchRequestSchema
+};
+var responseSchemas = {
+  balance: BalanceResponseSchema,
+  chat: ChatResponseSchema,
+  create: StatusResponseSchema,
+  embed: EmbedResponseSchema,
+  generate: GenerateResponseSchema,
+  ps: PsResponseSchema,
+  pull: StatusResponseSchema,
+  push: StatusResponseSchema,
+  show: ShowResponseSchema,
+  systemOne: SystemOneResponseSchema,
+  tags: ListResponseSchema,
+  usage: UsageResponseSchema,
+  version: VersionResponseSchema,
+  webFetch: WebFetchResponseSchema,
+  webSearch: WebSearchResponseSchema
 };
 function getRequestSchema(operationId) {
   return requestSchemas[operationId];
 }
+function getResponseSchema(operationId) {
+  return responseSchemas[operationId];
+}
 
 // src/generated/runtime/runtime.ts
 function compareVersions(a, b) {
@@ -2892,18 +3757,13 @@ function compareVersions(a, b) {
   }
   return 0;
 }
-function assertOperationAllowed(operation, options) {
-  const localMode = options.localMode ?? true;
-  if (!localMode && !operation.environment.cloud) {
-    throw new OllamaGenericClientError(
-      `Operation ${operation.operationId} (${operation.method} ${operation.path}) is local-only and not supported in cloud mode.`
-    );
-  }
-  if (operation.constraints?.minOllamaVersion && options.serverVersion && compareVersions(options.serverVersion, operation.constraints.minOllamaVersion) < 0) {
-    throw new OllamaGenericClientError(
-      `Operation ${operation.operationId} (${operation.method} ${operation.path}) requires Ollama >= ${operation.constraints.minOllamaVersion} (server reports ${options.serverVersion}).`
-    );
-  }
+async function fetchServerVersion(http) {
+  const result = await http.request({
+    path: "/api/version",
+    method: "GET"
+  });
+  if (result && typeof result.version === "string") return result.version;
+  return void 0;
 }
 function shouldStream(req) {
   if (req.body && typeof req.body === "object" && "stream" in req.body) {
@@ -2925,7 +3785,35 @@ var OllamaRuntime = class {
   constructor(options) {
     this.options = options;
   }
-  options;
+  /**
+   * Cached promise of the Ollama server version, populated lazily the first
+   * time a version-gated operation is invoked. `undefined` until then.
+   *
+   * Wave 12 (P0 #5): see {@link OllamaRuntimeOptions.enforceVersion}.
+   */
+  serverVersionCache;
+  /**
+   * Wave 15 (P0): resolve the HTTP backend for a given operation.
+   *
+   * Operations with a declared `host` (e.g. web search/fetch at
+   * https://ollama.com) must route to a HttpClient pointed at that host,
+   * not the default one. The runtime accepts an optional `cloudHttp`
+   * backend for this purpose — if the operation declares a host and no
+   * cloud backend is configured, the runtime throws rather than silently
+   * sending the request to the wrong server.
+   */
+  resolveHttpBackend(operation) {
+    if (operation.host) {
+      const cloudHttp = this.options.cloudHttp;
+      if (!cloudHttp) {
+        throw new OllamaGenericClientError(
+          `Operation ${operation.operationId} (${operation.method} ${operation.path}) targets host "${operation.host}" but the runtime has no cloudHttp backend configured. Use OllamaClient.webSearch() / OllamaClient.webFetch() for cloud-hosted operations, or construct OllamaRuntime with a cloudHttp option.`
+        );
+      }
+      return cloudHttp;
+    }
+    return this.options.http;
+  }
   /**
    * Invoke an operation. Called by every generated API method.
    *
@@ -2934,7 +3822,7 @@ var OllamaRuntime = class {
    * class's overloads pick the right return type at compile time.
    */
   async invoke(req) {
-    assertOperationAllowed(req.operation, this.options);
+    await this.assertOperationAllowed(req.operation);
     let body = buildBody(req);
     if (this.options.validateRequests === true && body !== void 0) {
       const schema = getRequestSchema(req.operation.operationId);
@@ -2953,32 +3841,1133 @@ var OllamaRuntime = class {
         body = result.data;
       }
     }
+    if (body !== void 0) {
+      const serialized = serializeForByteCount(body);
+      const hasImages = bodyHasImages(body);
+      const maxBytesWithImages = req.operation.constraints?.maxRequestBytesWithImages;
+      const maxBytesBase = req.operation.constraints?.maxRequestBytes;
+      const applicableLimit = hasImages && maxBytesWithImages !== void 0 ? maxBytesWithImages : maxBytesBase;
+      if (applicableLimit !== void 0 && serialized.byteLength > applicableLimit) {
+        throw new OllamaRequestTooLargeError(
+          `Operation ${req.operation.operationId} (${req.operation.method} ${req.operation.path}) request body is ${serialized.byteLength} bytes, exceeding the contract limit of ${applicableLimit} bytes` + (hasImages ? " (images limit)." : "."),
+          {
+            operationId: req.operation.operationId,
+            actualBytes: serialized.byteLength,
+            maxBytes: applicableLimit,
+            request: { method: req.operation.method, url: req.operation.path }
+          }
+        );
+      }
+    }
     const streaming = shouldStream(req);
+    const resolvedPath = resolvePathParams(req.operation.path, req.pathParams);
+    const pathWithQuery = applyQueryParams(resolvedPath, req.queryParams);
+    const model = req.model ?? extractModelFromBody(body);
+    const headers = {};
+    if (req.headerParams) {
+      for (const [key, value] of Object.entries(req.headerParams)) {
+        headers[key] = value;
+      }
+    }
     const httpReq = {
-      path: req.operation.path,
+      path: pathWithQuery,
       method: req.operation.method,
       ...body !== void 0 ? { body } : {},
+      ...Object.keys(headers).length > 0 ? { headers } : {},
       ...req.signal !== void 0 ? { signal: req.signal } : {},
-      // For streaming calls, request the raw Response so we can pipe it
-      // through parseNdjsonStream directly. This inherits middleware,
-      // retry, telemetry, and error-mapping from HttpClient — the
-      // previous Wave 3 implementation bypassed them with a direct
-      // `fetch()` call.
-      ...streaming ? { raw: true } : {}
+      ...streaming ? { raw: true } : {},
+      ...model !== void 0 ? { model } : {}
     };
     if (!streaming) {
-      return await this.options.http.request(httpReq);
+      const result = await this.resolveHttpBackend(req.operation).request(httpReq);
+      if (this.options.validateResponses === true) {
+        const responseSchema = getResponseSchema(req.operation.operationId);
+        if (responseSchema) {
+          const result2 = responseSchema.safeParse(result);
+          if (!result2.success) {
+            throw new OllamaResponseValidationError(
+              `Response validation failed for operation "${req.operation.operationId}" (${req.operation.method} ${req.operation.path}): ` + result2.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; "),
+              {
+                operationId: req.operation.operationId,
+                issues: result2.error.issues,
+                request: { method: req.operation.method, url: req.operation.path }
+              }
+            );
+          }
+        }
+      }
+      return result;
     }
-    const response = await this.options.http.request(httpReq);
+    const response = await this.resolveHttpBackend(req.operation).request(httpReq);
     if (!response.body) {
       throw new OllamaGenericClientError(
         `Operation ${req.operation.operationId}: streaming response had no body.`
       );
     }
-    return parseNdjsonStream(response.body);
+    return parseStreamByMode(req.operation.transport.mode, response.body);
+  }
+  /**
+   * Apply environment + version guards before delegating to HttpClient.
+   *
+   * Throws {@link OllamaGenericClientError} when:
+   *   - The operation is local-only and the runtime is in cloud mode.
+   *   - The operation has `constraints.minOllamaVersion` and the server is older.
+   *
+   * Wave 12 (P0 #5): when `minOllamaVersion` is declared but the runtime's
+   * `serverVersion` is unknown AND `enforceVersion` is `'auto'` or
+   * `'strict'`, the runtime lazily fetches `/api/version` (cached on the
+   * runtime instance) so the constraint is actually enforced even when the
+   * caller didn't supply it. Previously the constraint was only enforced
+   * when `serverVersion` was manually supplied — meaning in practice it was
+   * almost never enforced.
+   */
+  async assertOperationAllowed(operation) {
+    const localMode = this.options.localMode ?? true;
+    if (!localMode && !operation.environment.cloud) {
+      throw new OllamaGenericClientError(
+        `Operation ${operation.operationId} (${operation.method} ${operation.path}) is local-only and not supported in cloud mode.`
+      );
+    }
+    const minVersion = operation.constraints?.minOllamaVersion;
+    if (!minVersion) return;
+    let serverVersion = this.options.serverVersion;
+    const policy = this.options.enforceVersion ?? "auto";
+    if (!serverVersion && policy !== "off") {
+      if (!this.serverVersionCache) {
+        const p = fetchServerVersion(this.options.http).catch((err) => {
+          if (policy === "strict") {
+            throw new OllamaServerVersionUnknownError(
+              `Operation ${operation.operationId} requires Ollama >= ${minVersion} but the runtime could not determine the server version (enforceVersion: 'strict').`,
+              {
+                operationId: operation.operationId,
+                minRequiredVersion: minVersion,
+                cause: err
+              }
+            );
+          }
+          return void 0;
+        });
+        this.serverVersionCache = p;
+      }
+      serverVersion = await this.serverVersionCache ?? void 0;
+    }
+    if (serverVersion && compareVersions(serverVersion, minVersion) < 0) {
+      throw new OllamaGenericClientError(
+        `Operation ${operation.operationId} (${operation.method} ${operation.path}) requires Ollama >= ${minVersion} (server reports ${serverVersion}).`
+      );
+    }
+  }
+};
+function parseStreamByMode(mode, body) {
+  if (mode === "ndjson") {
+    return parseNdjsonStream(body);
+  }
+  if (mode === "sse") {
+    return parseSseStreamAsJson(body);
+  }
+  throw new OllamaGenericClientError(
+    `Transport mode "${mode}" is not a streaming mode; cannot parse a stream for it.`
+  );
+}
+async function* parseSseStreamAsJson(body) {
+  for await (const event of parseSseStream(body)) {
+    const data = event.data;
+    if (!data) continue;
+    if (data === "[DONE]") return;
+    try {
+      yield JSON.parse(data);
+    } catch (err) {
+      throw new OllamaGenericClientError(`Failed to parse SSE event data as JSON: ${data}`, {
+        cause: err
+      });
+    }
+  }
+}
+function serializeForByteCount(body) {
+  if (body instanceof Uint8Array) return body;
+  if (typeof body === "string") return new TextEncoder().encode(body);
+  const json = JSON.stringify(body);
+  return new TextEncoder().encode(json);
+}
+function bodyHasImages(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const obj = body;
+  const images = obj.images;
+  return Array.isArray(images) && images.length > 0;
+}
+function resolvePathParams(pathTemplate, pathParams) {
+  if (!pathTemplate.includes("{")) return pathTemplate;
+  const params = pathParams ?? {};
+  return pathTemplate.replace(/\{([^}]+)\}/g, (_match, name) => {
+    const value = params[name];
+    if (value === void 0) {
+      throw new OllamaGenericClientError(
+        `Missing path parameter "${name}" for path template "${pathTemplate}". Provide it via the pathParams field on the invoke() request.`
+      );
+    }
+    return encodeURIComponent(value);
+  });
+}
+function extractModelFromBody(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const obj = body;
+  const model = obj.model;
+  return typeof model === "string" ? model : void 0;
+}
+function applyQueryParams(path, queryParams) {
+  if (!queryParams || Object.keys(queryParams).length === 0) return path;
+  const pairs = Object.entries(queryParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+  return `${path}?${pairs}`;
+}
+
+// src/responses.ts
+var adapterResponseSequence = 0;
+function toNativeTools(tools) {
+  if (tools === void 0 || tools.length === 0) return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description ?? "",
+      parameters: tool.parameters ?? { type: "object", properties: {} }
+    }
+  }));
+}
+function mapNativeUsage(usage) {
+  if (usage === void 0) return void 0;
+  const input = usage.input_tokens ?? 0;
+  const output = usage.output_tokens ?? 0;
+  return { input_tokens: input, output_tokens: output, total_tokens: input + output };
+}
+function parseToolCallArguments(raw) {
+  if (raw === void 0 || raw === null || raw === "") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return { _raw: raw };
+  }
+}
+function mapNativeResponse(native) {
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  for (const item of native.output ?? []) {
+    if (item.type === "message") {
+      for (const part of item.content ?? []) {
+        if (part.type === "output_text") textParts.push(part.text ?? "");
+        else if (part.type === "refusal") textParts.push(part.refusal ?? "");
+      }
+    } else if (item.type === "reasoning") {
+      if (item.text !== void 0 && item.text !== "") thinkingParts.push(item.text);
+    } else if (item.type === "function_call") {
+      toolCalls.push({
+        ...item.id !== void 0 ? { id: item.id } : {},
+        function: { name: item.name, arguments: parseToolCallArguments(item.arguments) }
+      });
+    }
+  }
+  return {
+    id: native.id ?? `resp_${Date.now().toString(36)}`,
+    model: native.model,
+    created_at: new Date((native.created_at ?? 0) * 1e3).toISOString(),
+    output_text: textParts.join(""),
+    ...thinkingParts.length > 0 ? { thinking: thinkingParts.join("\n") } : {},
+    ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {},
+    ...mapNativeUsage(native.usage) !== void 0 ? { usage: mapNativeUsage(native.usage) } : {}
+  };
+}
+function mapChatUsage(res) {
+  const asChat = res;
+  const asStream = res;
+  const input = asChat.prompt_eval_count ?? asStream.usage?.promptTokens ?? asStream.raw?.prompt_eval_count ?? 0;
+  const output = asChat.eval_count ?? asStream.usage?.completionTokens ?? asStream.raw?.eval_count ?? 0;
+  if (input === 0 && output === 0) return void 0;
+  return { input_tokens: input, output_tokens: output, total_tokens: input + output };
+}
+function mapChatResponse(res) {
+  adapterResponseSequence += 1;
+  return {
+    id: `resp_${Date.now().toString(36)}${adapterResponseSequence.toString(36)}`,
+    model: res.model,
+    created_at: res.created_at,
+    output_text: res.message.content,
+    ...res.message.thinking !== void 0 ? { thinking: res.message.thinking } : {},
+    ...res.message.tool_calls !== void 0 && res.message.tool_calls.length > 0 ? { tool_calls: res.message.tool_calls } : {},
+    ...mapChatUsage(res) !== void 0 ? { usage: mapChatUsage(res) } : {},
+    transport: "chat-adapter"
+  };
+}
+var ResponsesModule = class {
+  constructor(runner) {
+    this.runner = runner;
+  }
+  /** The request body sent to the native endpoint (also reused for streaming). */
+  nativeBody(req) {
+    return {
+      model: req.model,
+      input: req.input,
+      ...req.instructions !== void 0 ? { instructions: req.instructions } : {},
+      ...req.tools !== void 0 && req.tools.length > 0 ? { tools: toNativeTools(req.tools) } : {},
+      ...req.temperature !== void 0 ? { temperature: req.temperature } : {},
+      ...req.top_p !== void 0 ? { top_p: req.top_p } : {},
+      ...req.max_output_tokens !== void 0 ? { max_output_tokens: req.max_output_tokens } : {},
+      ...req.reasoning_effort !== void 0 ? { reasoning: { effort: req.reasoning_effort } } : {},
+      ...req.think !== void 0 ? { think: req.think } : {}
+    };
+  }
+  /**
+   * Runs one Responses request, preferring the native `POST /v1/responses`
+   * endpoint and transparently re-issuing via `/api/chat` when the server
+   * answers `404` (pre-v0.13.3 Ollama without the compatibility endpoint).
+   */
+  async create(req) {
+    const body = this.nativeBody(req);
+    try {
+      const native = await this.runner(
+        (http, signal) => http.request({
+          path: "/v1/responses",
+          body: { ...body, stream: false },
+          signal
+        }),
+        { model: req.model, signal: req.signal, timeoutMs: req.timeoutMs }
+      );
+      return { ...mapNativeResponse(native), transport: "native" };
+    } catch (err) {
+      if (!(err instanceof OllamaNotFoundError)) throw err;
+    }
+    return this.createViaChatAdapter(req);
+  }
+  /** Convenience: `create()` returning only the `output_text` string. */
+  async createText(req) {
+    const res = await this.create(req);
+    return res.output_text;
+  }
+  async createViaChatAdapter(req) {
+    const messages = [
+      ...req.instructions !== void 0 ? [{ role: "system", content: req.instructions }] : [],
+      { role: "user", content: req.input }
+    ];
+    const chatRes = await this.runner(
+      (http, signal) => http.request({
+        path: "/api/chat",
+        body: {
+          model: req.model,
+          messages,
+          ...req.tools !== void 0 && req.tools.length > 0 ? { tools: toNativeTools(req.tools) } : {},
+          options: {
+            ...req.temperature !== void 0 ? { temperature: req.temperature } : {},
+            ...req.top_p !== void 0 ? { top_p: req.top_p } : {},
+            ...req.max_output_tokens !== void 0 ? { num_predict: req.max_output_tokens } : {}
+          },
+          ...req.think !== void 0 ? { think: req.think } : {},
+          stream: false
+        },
+        signal
+      }),
+      { model: req.model, signal: req.signal, timeoutMs: req.timeoutMs }
+    );
+    return mapChatResponse(chatRes);
+  }
+  /**
+   * Streams a Responses request as simplified
+   * `{type: 'text_delta' | 'thinking_delta' | 'done'}` events. Dual-mode like
+   * {@link create}: native SSE from `/v1/responses` when available, otherwise
+   * the normalized `/api/chat` token stream. Tool calls are not delta'd —
+   * collect them from the final `done` event's `response.tool_calls`.
+   *
+   * This is a lazy async generator: nothing is sent until the first
+   * iteration, matching `for await (... of client.responses.stream(req))`
+   * intuition. The generator is also cancellable through `req.signal`.
+   */
+  async *stream(req) {
+    const body = this.nativeBody(req);
+    let nativeStream;
+    try {
+      nativeStream = await this.runner(
+        async (http, signal) => {
+          const source = await http.requestSseStream({
+            path: "/v1/responses",
+            body: { ...body, stream: true },
+            signal
+          });
+          return new OpenAIResponsesStream(source, signal);
+        },
+        {
+          model: req.model,
+          signal: req.signal,
+          timeoutMs: req.timeoutMs,
+          holdUntil: (s) => s.finalResult
+        }
+      );
+    } catch (err) {
+      if (!(err instanceof OllamaNotFoundError)) throw err;
+    }
+    if (nativeStream !== void 0) {
+      for await (const event of nativeStream) {
+        const type = event.type;
+        if (type === "response.output_text.delta") {
+          yield { type: "text_delta", delta: event.delta };
+        } else if (type === "response.reasoning_text.delta") {
+          yield { type: "thinking_delta", delta: event.delta };
+        }
+      }
+      yield {
+        type: "done",
+        response: { ...mapNativeResponse(await nativeStream.finalResult), transport: "native" }
+      };
+      return;
+    }
+    const chatStream = await this.runner(
+      async (http, signal) => {
+        const source = await http.requestStream({
+          path: "/api/chat",
+          body: {
+            model: req.model,
+            messages: [
+              ...req.instructions !== void 0 ? [{ role: "system", content: req.instructions }] : [],
+              { role: "user", content: req.input }
+            ],
+            ...req.tools !== void 0 && req.tools.length > 0 ? { tools: toNativeTools(req.tools) } : {},
+            options: {
+              ...req.temperature !== void 0 ? { temperature: req.temperature } : {},
+              ...req.top_p !== void 0 ? { top_p: req.top_p } : {},
+              ...req.max_output_tokens !== void 0 ? { num_predict: req.max_output_tokens } : {}
+            },
+            ...req.think !== void 0 ? { think: req.think } : {},
+            stream: true
+          },
+          signal
+        });
+        return normalizeChatStream(source, signal);
+      },
+      {
+        model: req.model,
+        signal: req.signal,
+        timeoutMs: req.timeoutMs,
+        holdUntil: (s) => s.finalResult
+      }
+    );
+    for await (const event of chatStream) {
+      if (event.type === "token") {
+        yield { type: "text_delta", delta: event.data.delta };
+      } else if (event.type === "thinking") {
+        yield { type: "thinking_delta", delta: event.data.delta };
+      }
+    }
+    const result = await chatStream.finalResult;
+    yield {
+      type: "done",
+      response: {
+        id: `resp_${Date.now().toString(36)}${(++adapterResponseSequence).toString(36)}`,
+        model: result.model,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        output_text: result.message.content,
+        ...result.message.thinking !== void 0 ? { thinking: result.message.thinking } : {},
+        ...result.message.tool_calls !== void 0 && result.message.tool_calls.length > 0 ? { tool_calls: result.message.tool_calls } : {},
+        ...mapChatUsage(result) !== void 0 ? { usage: mapChatUsage(result) } : {},
+        transport: "chat-adapter"
+      }
+    };
+  }
+};
+
+// src/conversation.ts
+function extractTurnStats(res) {
+  const cachedTokens = res.prompt_eval_cached_count ?? 0;
+  const evaluatedTokens = res.prompt_eval_count ?? 0;
+  const total = cachedTokens + evaluatedTokens;
+  return {
+    cachedTokens,
+    evaluatedTokens,
+    hitRate: total > 0 ? cachedTokens / total : 0
+  };
+}
+var ConversationSession = class {
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+    if (config.systemPrompt !== void 0 && config.systemPrompt !== "") {
+      this.history.push(Object.freeze({ role: "system", content: config.systemPrompt }));
+    }
+  }
+  /** Ordered, append-only history. Message objects are frozen on push. */
+  history = [];
+  /** Mutable tallies behind the read-only {@link cacheStats} view. */
+  tallies = {
+    turns: 0,
+    cachedTokens: 0,
+    evaluatedTokens: 0
+  };
+  /** The model name this session talks to. */
+  get model() {
+    return this.config.model;
+  }
+  /** Number of completed turns. */
+  get turnCount() {
+    return this.tallies.turns;
+  }
+  /** Cumulative KV-cache statistics across completed turns. */
+  get cacheStats() {
+    const total = this.tallies.cachedTokens + this.tallies.evaluatedTokens;
+    return {
+      turns: this.tallies.turns,
+      cachedTokens: this.tallies.cachedTokens,
+      evaluatedTokens: this.tallies.evaluatedTokens,
+      totalPromptTokens: total,
+      hitRate: total > 0 ? this.tallies.cachedTokens / total : 0
+    };
+  }
+  /**
+   * Sends the user's message and returns the assistant's reply text —
+   * the ergonomic path. Use {@link sendTurn} when you also need the
+   * per-turn cache statistics or the raw response.
+   */
+  async send(content, overrides) {
+    const turn = await this.sendTurn(content, overrides);
+    return turn.content;
+  }
+  /**
+   * Sends the user's message and returns the full turn record: reply text,
+   * per-turn KV-cache statistics, and the raw `/api/chat` response.
+   */
+  async sendTurn(content, overrides) {
+    this.history.push(Object.freeze({ role: "user", content }));
+    const response = await this.client.chat({
+      model: this.config.model,
+      messages: [...this.history],
+      ...this.config.tools !== void 0 || overrides?.tools !== void 0 ? { tools: overrides?.tools ?? this.config.tools } : {},
+      ...this.config.format !== void 0 || overrides?.format !== void 0 ? { format: overrides?.format ?? this.config.format } : {},
+      options: { ...this.config.options, ...overrides?.options },
+      ...this.config.think !== void 0 || overrides?.think !== void 0 ? { think: overrides?.think ?? this.config.think } : {},
+      ...this.config.keep_alive !== void 0 || overrides?.keep_alive !== void 0 ? { keep_alive: overrides?.keep_alive ?? this.config.keep_alive } : {},
+      ...overrides?.signal !== void 0 ? { signal: overrides.signal } : {},
+      ...overrides?.timeoutMs !== void 0 ? { timeoutMs: overrides.timeoutMs } : {},
+      stream: false
+    });
+    this.history.push(Object.freeze({ ...response.message }));
+    const cache = extractTurnStats(response);
+    this.tallies.turns += 1;
+    this.tallies.cachedTokens += cache.cachedTokens;
+    this.tallies.evaluatedTokens += cache.evaluatedTokens;
+    return { content: response.message.content, cache, response };
+  }
+  /**
+   * A defensive copy of the session history — mutating the returned array or
+   * its frozen messages has no effect on the session.
+   */
+  getMessages() {
+    return this.history.map((message) => message);
+  }
+  /**
+   * Clears the conversation back to its initial state (system prompt, zero
+   * turns, zeroed cache statistics). The next turn starts with a cold cache
+   * by definition — there is nothing upstream of it to reuse.
+   */
+  reset() {
+    this.history.length = 0;
+    if (this.config.systemPrompt !== void 0 && this.config.systemPrompt !== "") {
+      this.history.push(
+        Object.freeze({ role: "system", content: this.config.systemPrompt })
+      );
+    }
+    this.tallies.turns = 0;
+    this.tallies.cachedTokens = 0;
+    this.tallies.evaluatedTokens = 0;
   }
 };
 
+// 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/generated/api/operations.ts
+var blobsOp = {
+  operationId: "blobs",
+  method: "HEAD",
+  path: "/api/blobs/{digest}",
+  environment: { local: true, cloud: false },
+  parameters: [{ name: "digest", in: "path", required: true, schema: { type: "string" } }],
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "HEAD-only endpoint for blob existence checks; declared in OpenAPI but not in the legacy parity manifest."
+  ]
+};
+var chatOp = {
+  operationId: "chat",
+  method: "POST",
+  path: "/api/chat",
+  request: { $ref: "#/schemas/ChatRequest" },
+  response: { $ref: "#/schemas/ChatResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {
+    thinking: "model-dependent",
+    tools: "model-dependent",
+    vision: "model-dependent",
+    structuredOutput: "supported",
+    logprobs: "supported"
+  },
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "Use /api/show to discover model-specific thinking values and defaults.",
+    "Structured output (format field) is rejected by Ollama Cloud."
+  ]
+};
+var copyOp = {
+  operationId: "copy",
+  method: "POST",
+  path: "/api/copy",
+  request: { $ref: "#/schemas/CopyRequest" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var createOp = {
+  operationId: "create",
+  method: "POST",
+  path: "/api/create",
+  request: { $ref: "#/schemas/CreateRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: { thinking: "unsupported", tools: "unsupported" },
+  status: { documented: true },
+  domain: "native",
+  notes: ["Model creation is local-only; Ollama Cloud does not support it."]
+};
+var deleteOp = {
+  operationId: "delete",
+  method: "DELETE",
+  path: "/api/delete",
+  request: { $ref: "#/schemas/DeleteRequest" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var embedOp = {
+  operationId: "embed",
+  method: "POST",
+  path: "/api/embed",
+  request: { $ref: "#/schemas/EmbedRequest" },
+  response: { $ref: "#/schemas/EmbedResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: { embeddings: "supported" },
+  status: { documented: true },
+  domain: "native"
+};
+var generateOp = {
+  operationId: "generate",
+  method: "POST",
+  path: "/api/generate",
+  request: { $ref: "#/schemas/GenerateRequest" },
+  response: { $ref: "#/schemas/GenerateResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {
+    thinking: "model-dependent",
+    vision: "supported",
+    structuredOutput: "supported",
+    logprobs: "supported"
+  },
+  status: { documented: true },
+  domain: "native"
+};
+var psOp = {
+  operationId: "ps",
+  method: "GET",
+  path: "/api/ps",
+  response: { $ref: "#/schemas/PsResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var pullOp = {
+  operationId: "pull",
+  method: "POST",
+  path: "/api/pull",
+  request: { $ref: "#/schemas/PullRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var pushOp = {
+  operationId: "push",
+  method: "POST",
+  path: "/api/push",
+  request: { $ref: "#/schemas/PushRequest" },
+  response: { $ref: "#/schemas/StatusResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "ndjson", streaming: true, streamingDefault: true },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var showOp = {
+  operationId: "show",
+  method: "POST",
+  path: "/api/show",
+  request: { $ref: "#/schemas/ShowRequest" },
+  response: { $ref: "#/schemas/ShowResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native",
+  notes: [
+    "Capabilities source: /api/show is the runtime source of truth for model-dependent capability values (tools, vision, thinking, embeddings)."
+  ]
+};
+var systemOneOp = {
+  operationId: "systemOne",
+  method: "POST",
+  path: "/v1/systemone",
+  request: { $ref: "#/schemas/SystemOneRequest" },
+  response: { $ref: "#/schemas/SystemOneResponse" },
+  environment: { local: true, cloud: false },
+  transport: { mode: "json", streaming: false },
+  capabilities: {
+    thinking: "unsupported",
+    tools: "unsupported",
+    vision: "model-dependent",
+    structuredOutput: "unsupported",
+    logprobs: "unsupported",
+    embeddings: "unsupported"
+  },
+  constraints: {
+    minOllamaVersion: "0.35.0",
+    maxRequestBytes: 65536,
+    maxRequestBytesWithImages: 33554432
+  },
+  status: { documented: true, experimental: true },
+  domain: "native",
+  notes: [
+    "Local-only; Ollama Cloud rejects /v1/systemone.",
+    "64 KiB request limit without images, 32 MiB with images (includes JSON/base64 overhead).",
+    "No tools, no generation controls (temperature, top_p, etc.).",
+    "Vision is model-dependent: images are accepted by vision-weighted models (Clef/Clef Flash) but not by text-only models.",
+    "Experimental: behavioral surface may change between Ollama releases."
+  ]
+};
+var tagsOp = {
+  operationId: "tags",
+  method: "GET",
+  path: "/api/tags",
+  response: { $ref: "#/schemas/ListResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+var versionOp = {
+  operationId: "version",
+  method: "GET",
+  path: "/api/version",
+  response: { $ref: "#/schemas/VersionResponse" },
+  environment: { local: true, cloud: true },
+  transport: { mode: "json", streaming: false },
+  capabilities: {},
+  status: { documented: true },
+  domain: "native"
+};
+
+// src/generated/api/native-api.ts
+var NativeApi = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  blobs(digest, options) {
+    return this.runtime.invoke({
+      operation: blobsOp,
+      body: void 0,
+      pathParams: { digest },
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  chat(request) {
+    return this.runtime.invoke({
+      operation: chatOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  copy(request) {
+    return this.runtime.invoke({
+      operation: copyOp,
+      body: request
+    });
+  }
+  create(request) {
+    return this.runtime.invoke({
+      operation: createOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  delete(request) {
+    return this.runtime.invoke({
+      operation: deleteOp,
+      body: request
+    });
+  }
+  embed(request) {
+    return this.runtime.invoke({
+      operation: embedOp,
+      body: request
+    });
+  }
+  generate(request) {
+    return this.runtime.invoke({
+      operation: generateOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  ps(options) {
+    return this.runtime.invoke({
+      operation: psOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  pull(request) {
+    return this.runtime.invoke({
+      operation: pullOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  push(request) {
+    return this.runtime.invoke({
+      operation: pushOp,
+      body: request,
+      streamingDefault: true
+    });
+  }
+  show(request) {
+    return this.runtime.invoke({
+      operation: showOp,
+      body: request
+    });
+  }
+  systemOne(request) {
+    return this.runtime.invoke({
+      operation: systemOneOp,
+      body: request
+    });
+  }
+  tags(options) {
+    return this.runtime.invoke({
+      operation: tagsOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+  version(options) {
+    return this.runtime.invoke({
+      operation: versionOp,
+      body: void 0,
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
+    });
+  }
+};
+
+// src/failover-http-client.ts
+var FailoverHttpClient = class {
+  constructor(client, baseUrl) {
+    this.client = client;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * The first candidate endpoint's base URL. Used for inferRuntimeMode()
+   * checks (local vs cloud). The actual request routing picks the best
+   * healthy endpoint per call.
+   */
+  baseUrl;
+  /**
+   * Route a request through OllamaClient's failover machinery.
+   *
+   * Each call to request() goes through executeWithFailover, which:
+   *   - Picks the best healthy endpoint from the registry
+   *   - Applies retry/backoff within that endpoint
+   *   - Fails over to the next candidate on retryable errors
+   *   - Reports success/failure to the endpoint health tracker
+   *
+   * Wave 15 (P1): the model is extracted from the request body by the
+   * runtime and passed via the `model` field on the options. This lets
+   * the failover layer filter endpoints by `OllamaEndpoint.models`
+   * (credential-scoped routing). If no model is provided, all endpoints
+   * are considered.
+   *
+   * The `raw` option (for streaming responses) is passed through
+   * unchanged — executeWithFailover returns whatever the operation
+   * callback returns, including raw Response objects.
+   */
+  async request(options) {
+    const { model, ...httpOptions } = options;
+    return this.client.executeWithFailover(
+      async (http, signal) => {
+        const mergedOptions = {
+          ...httpOptions,
+          ...httpOptions.signal !== void 0 ? { signal } : { signal }
+        };
+        return http.request(mergedOptions);
+      },
+      {
+        singleEndpoint: false,
+        ...model !== void 0 ? { model } : {}
+      }
+    );
+  }
+};
+
+// src/decision.ts
+function createDecision(client) {
+  return {
+    async choice(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "choice",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        choice: answer.choice,
+        probabilities: answer.probabilities,
+        confidence: answer.confidence,
+        usage: response.usage
+      };
+    },
+    async noul(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "noul",
+            instructions: params.instructions
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        noul: answer.noul,
+        bool: answer.noul >= 0.5,
+        usage: response.usage
+      };
+    },
+    async score(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "score",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        score: answer.score,
+        legend: answer.legend,
+        probabilities: answer.probabilities,
+        confidence: answer.confidence,
+        usage: response.usage
+      };
+    },
+    async route(params) {
+      const response = await client.systemOne({
+        model: params.model,
+        state: params.state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "choice",
+            instructions: params.instructions,
+            criteria: params.criteria
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        route: answer.choice,
+        confidence: answer.confidence
+      };
+    },
+    async verify(params) {
+      const state = {
+        claim: params.claim,
+        evidence: params.evidence
+      };
+      const response = await client.systemOne({
+        model: params.model,
+        state,
+        ...params.images ? { images: params.images } : {},
+        questions: {
+          decision: {
+            type: "noul",
+            instructions: params.instructions ?? "Is the claim supported by the evidence?"
+          }
+        },
+        ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+      });
+      const answer = response.answers.decision;
+      return {
+        verified: answer.noul >= 0.5,
+        probability: answer.noul
+      };
+    },
+    async rank(params) {
+      const promises = params.candidates.map(async (candidate) => {
+        const response = await client.systemOne({
+          model: params.model,
+          state: candidate.state,
+          ...params.images ? { images: params.images } : {},
+          questions: {
+            decision: {
+              type: "score",
+              instructions: params.instructions,
+              criteria: params.criteria
+            }
+          },
+          ...params.keepAlive !== void 0 ? { keep_alive: params.keepAlive } : {}
+        });
+        const answer = response.answers.decision;
+        return {
+          candidate: candidate.id,
+          score: answer.score,
+          confidence: answer.confidence
+        };
+      });
+      const results = await Promise.all(promises);
+      return results.sort((a, b) => b.score - a.score);
+    }
+  };
+}
+
 // src/client.ts
 var logicalRequestSequence = 0;
 function createLogicalRequestId() {
@@ -3003,14 +4992,21 @@ var OllamaClient = class {
    * `OLLAMA_API_KEY`), independent of whether `config.endpoints` was used instead.
    */
   cloudApiKey;
+  /** Configured `defaultContextLength` — injected as `num_ctx` when a request omits it. */
+  defaultContextLength;
+  /** Configured `contextWarningThreshold` (default 0.9). */
+  contextWarningThreshold;
+  /** Configured overflow policy — `'warn'` (default) or `'throw'`. */
+  onContextOverflow;
   constructor(config = {}) {
-    const resolvedApiKey = resolveApiKey(config.apiKey);
-    this.cloudApiKey = resolvedApiKey;
+    this.cloudApiKey = resolveApiKey(config.apiKey);
+    const defaultBaseUrl = resolveBaseUrl(config.baseUrl);
+    const resolvedApiKey = resolveEndpointApiKey(config.apiKey, defaultBaseUrl);
     const credentialEndpoints = resolveCredentialEndpoints(config);
     const endpoints = config.endpoints ?? (credentialEndpoints.length > 0 ? [] : [
       {
         name: "default",
-        baseUrl: resolveBaseUrl(config.baseUrl),
+        baseUrl: defaultBaseUrl,
         ...resolvedApiKey !== void 0 ? { apiKey: resolvedApiKey } : {},
         ...config.headers !== void 0 ? { headers: config.headers } : {}
       }
@@ -3026,6 +5022,9 @@ var OllamaClient = class {
     this.middleware = config.middleware;
     this.onLifecycleEvent = config.onLifecycleEvent;
     this.retryConfig = typeof config.retries === "number" ? { ...DEFAULT_RETRY_CONFIG, maxRetries: config.retries } : { ...DEFAULT_RETRY_CONFIG, ...config.retries };
+    this.defaultContextLength = config.defaultContextLength;
+    this.contextWarningThreshold = config.contextWarningThreshold;
+    this.onContextOverflow = config.onContextOverflow ?? "warn";
     this.models = new ModelsClient((op, opts) => this.executeWithFailover(op, opts));
   }
   get modelsClient() {
@@ -3039,42 +5038,130 @@ var OllamaClient = class {
    * API with the generated `NativeApi` / `OpenAIApi` / `AnthropicApi`
    * surface without configuring two separate HttpClient instances.
    *
-   * The returned runtime is bound to the registry's first candidate
-   * endpoint (or the resolved single-endpoint config if no `endpoints`
-   * array was provided). For multi-endpoint configs that need per-call
-   * routing, prefer constructing `OllamaRuntime` directly with a
-   * specific HttpClient:
-   *
-   * ```ts
-   * const http = new HttpClient({ baseUrl: 'http://host-a:11434' });
-   * const runtime = new OllamaRuntime({ http });
-   * const api = new NativeApi(runtime);
-   * ```
+   * Wave 14: the runtime now participates in multi-endpoint failover.
+   * Each request is routed through this client's `executeWithFailover`
+   * machinery via a {@link FailoverHttpClient} wrapper. If the first
+   * candidate endpoint is down, requests automatically fail over to
+   * the next healthy candidate — matching the behavior of the
+   * hand-written OllamaClient methods (chat, generate, etc.).
    *
    * The runtime is cached on first call — subsequent calls return the
-   * same instance.
+   * same instance. The `FailoverHttpClient` holds a reference to this
+   * client, so it always sees the current endpoint registry state.
    */
   get runtime() {
     if (this._runtime === void 0) {
       const candidates = this.registry.candidates();
       const endpoint = candidates[0];
       const baseUrl = endpoint?.baseUrl ?? "http://localhost:11434";
-      const http = new HttpClient({
-        baseUrl,
-        ...endpoint?.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
-        ...endpoint?.headers !== void 0 ? { headers: endpoint.headers } : {},
+      const http = new FailoverHttpClient(this, baseUrl);
+      const cloudHttp = new HttpClient({
+        baseUrl: OLLAMA_CLOUD_BASE_URL,
+        ...this.cloudApiKey !== void 0 ? { apiKey: this.cloudApiKey } : {},
         fetch: this.fetchImpl,
         ...this.middleware !== void 0 ? { middleware: this.middleware } : {},
         ...this.onLifecycleEvent !== void 0 ? { onLifecycleEvent: this.onLifecycleEvent } : {}
       });
       this._runtime = new OllamaRuntime({
         http,
+        cloudHttp,
         localMode: inferRuntimeMode(baseUrl) === "local"
       });
     }
     return this._runtime;
   }
   _runtime;
+  /**
+   * Lazily-constructed `NativeApi` bound to this client's runtime. Exposes
+   * the full generated native API surface (chat, generate, embed, systemOne,
+   * etc.) with contract-driven types and runtime enforcement.
+   *
+   * Wave 13: `systemOne()` delegates to this accessor.
+   */
+  get native() {
+    if (this._nativeApi === void 0) {
+      this._nativeApi = new NativeApi(this.runtime);
+    }
+    return this._nativeApi;
+  }
+  _nativeApi;
+  /**
+   * Higher-level System One decision helpers (Wave 14B).
+   *
+   * Ergonomic wrappers around `systemOne()` for the six most common
+   * decision patterns: `choice()`, `noul()`, `score()`, `route()`,
+   * `verify()`, `rank()`. Each constructs a single-question request
+   * and extracts the typed answer.
+   *
+   * ```ts
+   * const result = await client.decision.choice({
+   *   model: 'tev1:4b',
+   *   state: 'Customer was charged twice',
+   *   instructions: 'What is the primary intent?',
+   *   criteria: {
+   *     refund: 'Customer wants a refund',
+   *     duplicate_charge: 'Customer reports multiple charges',
+   *   },
+   * });
+   * console.log(result.choice); // 'duplicate_charge'
+   * console.log(result.confidence); // 0.89
+   * ```
+   */
+  get decision() {
+    if (this._decision === void 0) {
+      this._decision = createDecision(this);
+    }
+    return this._decision;
+  }
+  _decision;
+  /**
+   * Ergonomic OpenAI Responses API bridge (`client.responses.create()` /
+   * `.stream()`). Dual-mode transport: prefers the native `POST
+   * /v1/responses` endpoint (Ollama ≥ v0.13.3) and transparently re-issues via
+   * `/api/chat` when the server answers 404, so migrating OpenAI code works
+   * unchanged against older servers. See `src/responses.ts`.
+   */
+  get responses() {
+    if (this._responses === void 0) {
+      this._responses = new ResponsesModule((op, opts) => this.executeWithFailover(op, opts));
+    }
+    return this._responses;
+  }
+  _responses;
+  session(modelOrOptions, systemPrompt) {
+    const options = typeof modelOrOptions === "string" ? {
+      model: modelOrOptions,
+      ...systemPrompt !== void 0 ? { systemPrompt } : {}
+    } : modelOrOptions;
+    return new ConversationSession(this, options);
+  }
+  /**
+   * Context-window pre-flight enforcement — see `src/context-safety.ts` and
+   * the `defaultContextLength` / `onContextOverflow` config docs. Logs a
+   * warning (default) or throws client-side when the estimated prompt size
+   * is close to / beyond the effective context window.
+   */
+  enforceContextSafety(kind, check2) {
+    if (!check2.exceedsThreshold) return;
+    const message = contextWarningMessage(check2, kind);
+    if (this.onContextOverflow === "throw") {
+      throw new OllamaClientError(message, { code: "context_overflow" });
+    }
+    this.logger.warn(message);
+  }
+  /**
+   * Returns `options` with `num_ctx` injected from the client's
+   * `defaultContextLength` when the request didn't set one — making the
+   * effective context window explicit on the wire instead of relying on
+   * Ollama's silently-truncating server default. Returns the original
+   * reference when there's nothing to inject (the common case).
+   */
+  injectDefaultContextLength(options) {
+    if (options?.num_ctx !== void 0 || this.defaultContextLength === void 0) {
+      return options;
+    }
+    return { ...options, num_ctx: this.defaultContextLength };
+  }
   /**
    * Fail-fast guard for `format` (structured output) requests: throws before any network
    * call if the candidate endpoint is inferred as Ollama Cloud, which does not currently
@@ -3184,7 +5271,7 @@ var OllamaClient = class {
     }
   }
   async chat(req) {
-    const encodedMessages = await withEncodedMessageImages(req.messages);
+    const encodedMessages = await withEncodedMessageImages(req.messages, req.signal);
     const messages = encodedMessages.map((message) => {
       if (message.role === "tool" && message.tool_call_id !== void 0) {
         const { tool_call_id: _toolCallId, ...nativeMessage } = message;
@@ -3192,6 +5279,14 @@ var OllamaClient = class {
       }
       return message;
     });
+    this.enforceContextSafety(
+      "chat",
+      checkChatContext(req, {
+        defaultContextLength: this.defaultContextLength,
+        threshold: this.contextWarningThreshold
+      })
+    );
+    const options = this.injectDefaultContextLength(req.options);
     if (req.stream) {
       return this.executeWithFailover(
         async (http, signal) => {
@@ -3199,7 +5294,7 @@ var OllamaClient = class {
             this.assertStructuredOutputSupported(http.baseUrl, req.model);
           const stream = await http.requestStream({
             path: "/api/chat",
-            body: { ...req, messages, stream: true },
+            body: { ...req, options, messages, stream: true },
             signal
           });
           return normalizeChatStream(stream, signal);
@@ -3228,7 +5323,7 @@ var OllamaClient = class {
             this.assertStructuredOutputSupported(http.baseUrl, req.model);
           return http.request({
             path: "/api/chat",
-            body: { ...req, messages, stream: false },
+            body: { ...req, options, messages, stream: false },
             signal
           });
         }, req);
@@ -3255,7 +5350,15 @@ var OllamaClient = class {
     return parseStructuredOutput(res.message.content, schema);
   }
   async generate(req) {
-    const encodedReq = await withEncodedImages(req);
+    const encodedReq = await withEncodedImages(req, req.signal);
+    this.enforceContextSafety(
+      "generate",
+      checkGenerateContext(req, {
+        defaultContextLength: this.defaultContextLength,
+        threshold: this.contextWarningThreshold
+      })
+    );
+    const options = this.injectDefaultContextLength(req.options);
     if (encodedReq.stream) {
       return this.executeWithFailover(
         async (http, signal) => {
@@ -3263,7 +5366,7 @@ var OllamaClient = class {
             this.assertStructuredOutputSupported(http.baseUrl, encodedReq.model);
           const stream = await http.requestStream({
             path: "/api/generate",
-            body: { ...encodedReq, stream: true },
+            body: { ...encodedReq, options, stream: true },
             signal
           });
           return normalizeGenerateStream(stream, signal);
@@ -3289,7 +5392,7 @@ var OllamaClient = class {
             this.assertStructuredOutputSupported(http.baseUrl, encodedReq.model);
           return http.request({
             path: "/api/generate",
-            body: { ...encodedReq, stream: false },
+            body: { ...encodedReq, options, stream: false },
             signal
           });
         }, encodedReq);
@@ -3347,6 +5450,55 @@ var OllamaClient = class {
   version = () => this.models.version();
   createBlob = (digest, data) => this.models.createBlob(digest, data);
   checkBlob = (digest) => this.models.checkBlob(digest);
+  /**
+   * Immediately unloads `model` from VRAM. Convenience alias for
+   * {@link ModelsClient.unload} — see that method for the full
+   * lifecycle contract.
+   */
+  unloadModel = (model) => this.models.unload(model);
+  /**
+   * Pre-loads and pins `model` into VRAM indefinitely. Convenience
+   * alias for {@link ModelsClient.pin} — see that method for the
+   * full lifecycle contract.
+   */
+  pinModel = (model) => this.models.pin(model);
+  // --- System One (Wave 13) ---
+  /**
+   * Ollama's System One decision layer (`POST /v1/systemone`) — evaluates
+   * 1–64 typed questions (choice, noul, or score) against a provided state
+   * and returns typed answers with probabilities and confidence.
+   *
+   * Local-only; requires Ollama >= 0.35.0. The runtime enforces the
+   * version constraint automatically (lazily fetching `/api/version` when
+   * `enforceVersion` is `'auto'` or `'strict'`) and rejects cloud-mode
+   * calls. Request size is checked client-side: 64 KiB without images,
+   * 32 MiB with images.
+   *
+   * The generic `Q` parameter captures the caller's question map at
+   * compile time, giving key-safe answer access:
+   *
+   * ```ts
+   * const result = await ollama.systemOne({
+   *   model: 'tev1:4b',
+   *   state: { ticket: 'Customer was charged twice' },
+   *   questions: {
+   *     intent: { type: 'choice', instructions: '...', criteria: { ... } },
+   *     urgent: { type: 'noul', instructions: '...' },
+   *   },
+   * });
+   * result.answers.intent  // ✓ SystemOneAnswer (choice)
+   * result.answers.urgent  // ✓ SystemOneAnswer (noul)
+   * result.answers.typo    // ✗ TypeScript error
+   * ```
+   *
+   * For the low-level generated API (without the generic wrapper), use
+   * `client.native.systemOne(request)` directly.
+   */
+  async systemOne(request) {
+    return this.native.systemOne(
+      request
+    );
+  }
   // --- Web Endpoints ---
   /**
    * Ollama's hosted web search tool (`POST https://ollama.com/api/web_search`) — a fixed
@@ -3379,6 +5531,63 @@ var OllamaClient = class {
       req
     );
   }
+  /**
+   * Ollama Cloud usage statistics (`GET https://ollama.com/api/usage`) — request counts,
+   * USD spend, and token totals (including cached input tokens) for cloud inference,
+   * web search, and web fetch, bucketed by hour (`range: '24h'`) or day (`'7d'`/`'30d'`).
+   *
+   * See {@link OllamaClient.webSearch} for the cloud-endpoint/auth/timeout/retry
+   * behavior, which applies identically here. Query parameters mirror the official
+   * endpoint: `range` (`'24h' | '7d' | '30d'`, server default `'7d'`) and `scope`
+   * (`'self' | 'team'`, server default `'self'`; team scope requires a team admin).
+   * Omitted options are left unset so the server applies its own defaults.
+   *
+   * ```ts
+   * const usage = await client.usage({ range: '24h' });
+   * console.log(usage.totals.request_count, usage.totals.usage_usd);
+   * for (const bucket of usage.buckets) {
+   *   if (bucket.partial) continue; // current hour, still in progress
+   *   // ...
+   * }
+   * ```
+   */
+  usage(req = {}) {
+    const params = new URLSearchParams();
+    if (req.range !== void 0) params.set("range", req.range);
+    if (req.scope !== void 0) params.set("scope", req.scope);
+    const query = params.toString();
+    return this.executeCloudRequest(
+      (http, signal) => http.request({
+        path: query ? `/api/usage?${query}` : "/api/usage",
+        method: "GET",
+        signal
+      }),
+      req
+    );
+  }
+  /**
+   * Ollama Cloud balance (`GET https://ollama.com/api/balance`) — remaining included
+   * and purchased usage credits. The included balance is either a plan-period credit
+   * object (`balance_usd`/`allowance_usd`/`period`) or, on legacy plans, session/weekly
+   * percentage limits; the shape is discriminated at runtime by the server response.
+   * See {@link OllamaClient.webSearch} for the cloud-endpoint/auth/timeout/retry
+   * behavior, which applies identically here.
+   *
+   * ```ts
+   * const balance = await client.balance();
+   * if ('balance_usd' in balance.included) {
+   *   console.log(balance.included.balance_usd, balance.purchased.balance_usd);
+   * } else {
+   *   console.log(balance.included.session.remaining_percent, '% of session limit left');
+   * }
+   * ```
+   */
+  balance(req = {}) {
+    return this.executeCloudRequest(
+      (http, signal) => http.request({ path: "/api/balance", method: "GET", signal }),
+      req
+    );
+  }
   /**
    * Runs `operation` against the fixed Ollama Cloud host with this client's default
    * timeout and retry policy — the same primitives `executeWithFailover` uses, minus the
@@ -3482,6 +5691,91 @@ var OllamaClient = class {
   }
 };
 
+// src/transport/fetch-with-backoff.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 503]);
+var DEFAULT_FETCH_BACKOFF_CONFIG = {
+  maxRetries: 3
+};
+function sleep2(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(
+        Object.assign(new Error("fetchWithBackoff aborted during backoff sleep"), {
+          name: "AbortError"
+        })
+      );
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(
+        Object.assign(new Error("fetchWithBackoff aborted during backoff sleep"), {
+          name: "AbortError"
+        })
+      );
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithBackoff(input, init, config = {}) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "fetchWithBackoff: no global fetch is available. Pass a fetch implementation via config.fetch, or run in Node.js >= 18 / a browser-like environment."
+    );
+  }
+  const maxRetries = config.maxRetries ?? DEFAULT_FETCH_BACKOFF_CONFIG.maxRetries;
+  const backoff = config.backoff ?? DEFAULT_BACKOFF;
+  const signal = config.signal;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    if (signal?.aborted) {
+      throw Object.assign(new Error("fetchWithBackoff aborted"), { name: "AbortError" });
+    }
+    try {
+      const response = await fetchImpl(input, {
+        ...init,
+        ...signal !== void 0 ? { signal } : {}
+      });
+      if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxRetries) {
+        const delayMs = calculateBackoff(attempt, backoff);
+        config.onRetry?.(attempt, response.status, delayMs);
+        await sleep2(delayMs, signal);
+        continue;
+      }
+      return response;
+    } catch (err) {
+      lastError = err;
+      if (signal?.aborted || err instanceof Error && err.name === "AbortError") {
+        throw err;
+      }
+      if (attempt < maxRetries) {
+        const delayMs = calculateBackoff(attempt, backoff);
+        config.onRetry?.(attempt, 0, delayMs);
+        await sleep2(delayMs, signal);
+        continue;
+      }
+    }
+  }
+  throw lastError ?? new Error("fetchWithBackoff: exhausted retry attempts");
+}
+
+// src/done-reason.ts
+var KNOWN_DONE_REASONS = /* @__PURE__ */ new Set([
+  "stop",
+  "length",
+  "load",
+  "unload"
+]);
+function isKnownDoneReason(value) {
+  return value !== void 0 && value !== null && KNOWN_DONE_REASONS.has(value);
+}
+
 // src/streaming/adapters.ts
 function toTextStream(stream) {
   const iterator = stream[Symbol.asyncIterator]();
@@ -3937,9 +6231,9 @@ function validate(value, schema, path) {
       ["exclusiveMinimum", (n, b) => n > b, "must be greater than"],
       ["exclusiveMaximum", (n, b) => n < b, "must be less than"]
     ];
-    for (const [keyword, check, phrase] of numericRules) {
+    for (const [keyword, check2, phrase] of numericRules) {
       const bound = s[keyword];
-      if (typeof bound === "number" && !check(value, bound)) issues.push({ path, message: label(path) + " " + phrase + " " + bound });
+      if (typeof bound === "number" && !check2(value, bound)) issues.push({ path, message: label(path) + " " + phrase + " " + bound });
     }
     const multipleOf = s["multipleOf"];
     if (typeof multipleOf === "number" && multipleOf > 0) {
@@ -4200,8 +6494,6 @@ var McpBridge = class _McpBridge {
     this.client = client;
     this.options = options;
   }
-  client;
-  options;
   static toOllamaTools(tools, options = {}) {
     const prefix = options.namePrefix ?? "";
     return tools.map((tool) => ({
@@ -4498,6 +6790,13 @@ var Agent = class {
   }
 };
 
+// src/system-one.ts
+var MAX_SYSTEM_ONE_IMAGES_BYTES = 32 * 1024 * 1024;
+var MAX_SYSTEM_ONE_REQUEST_BYTES = 64 * 1024;
+function estimateSystemOneRequestBytes(request) {
+  return new TextEncoder().encode(JSON.stringify(request)).byteLength;
+}
+
 exports.ATTR_GEN_AI_OPERATION_NAME = ATTR_GEN_AI_OPERATION_NAME;
 exports.ATTR_GEN_AI_REQUEST_MODEL = ATTR_GEN_AI_REQUEST_MODEL;
 exports.ATTR_GEN_AI_RESPONSE_MODEL = ATTR_GEN_AI_RESPONSE_MODEL;
@@ -4518,24 +6817,35 @@ exports.ATTR_URL_FULL = ATTR_URL_FULL;
 exports.Agent = Agent;
 exports.AnthropicCompatClient = AnthropicCompatClient;
 exports.AnthropicMessagesStream = AnthropicMessagesStream;
+exports.ConversationSession = ConversationSession;
 exports.DEFAULT_BACKOFF = DEFAULT_BACKOFF;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_CONTEXT_WARNING_THRESHOLD = DEFAULT_CONTEXT_WARNING_THRESHOLD;
 exports.DEFAULT_FAILOVER_CODES = DEFAULT_FAILOVER_CODES;
+exports.DEFAULT_FETCH_BACKOFF_CONFIG = DEFAULT_FETCH_BACKOFF_CONFIG;
 exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
 exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
 exports.EndpointRegistry = EndpointRegistry;
 exports.GEN_AI_SYSTEM_OLLAMA = GEN_AI_SYSTEM_OLLAMA;
 exports.HttpClient = HttpClient;
+exports.IMAGE_TOKEN_ESTIMATE = IMAGE_TOKEN_ESTIMATE;
+exports.KEEP_ALIVE_INDEFINITE = KEEP_ALIVE_INDEFINITE;
+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.McpBridge = McpBridge;
 exports.ModelsClient = ModelsClient;
 exports.NANOS_PER_MS = NANOS_PER_MS;
 exports.NANOS_PER_SECOND = NANOS_PER_SECOND;
 exports.NOOP_LOGGER = NOOP_LOGGER;
 exports.OLLAMA_CLOUD_BASE_URL = OLLAMA_CLOUD_BASE_URL;
+exports.OLLAMA_FALLBACK_CONTEXT_LENGTH = OLLAMA_FALLBACK_CONTEXT_LENGTH;
 exports.OllamaAbortError = OllamaAbortError;
 exports.OllamaAgentMaxIterationsError = OllamaAgentMaxIterationsError;
 exports.OllamaAgentMaxToolCallsError = OllamaAgentMaxToolCallsError;
 exports.OllamaAuthError = OllamaAuthError;
+exports.OllamaBadGatewayError = OllamaBadGatewayError;
 exports.OllamaClient = OllamaClient;
 exports.OllamaClientError = OllamaClientError;
 exports.OllamaGenericClientError = OllamaGenericClientError;
@@ -4544,13 +6854,18 @@ exports.OllamaMcpError = OllamaMcpError;
 exports.OllamaModelRoutingError = OllamaModelRoutingError;
 exports.OllamaNetworkError = OllamaNetworkError;
 exports.OllamaNotFoundError = OllamaNotFoundError;
+exports.OllamaOverloadedError = OllamaOverloadedError;
 exports.OllamaQuotaExceededError = OllamaQuotaExceededError;
 exports.OllamaRateLimitError = OllamaRateLimitError;
+exports.OllamaRequestTooLargeError = OllamaRequestTooLargeError;
 exports.OllamaRequestValidationError = OllamaRequestValidationError;
+exports.OllamaResponseValidationError = OllamaResponseValidationError;
 exports.OllamaServerError = OllamaServerError;
+exports.OllamaServerVersionUnknownError = OllamaServerVersionUnknownError;
 exports.OllamaSkillInvalidError = OllamaSkillInvalidError;
 exports.OllamaSkillNotFoundError = OllamaSkillNotFoundError;
 exports.OllamaStream = OllamaStream;
+exports.OllamaStreamError = OllamaStreamError;
 exports.OllamaTimeoutError = OllamaTimeoutError;
 exports.OllamaToolTimeoutError = OllamaToolTimeoutError;
 exports.OllamaToolValidationError = OllamaToolValidationError;
@@ -4561,26 +6876,46 @@ exports.OpenAICompletionStream = OpenAICompletionStream;
 exports.OpenAIResponsesStream = OpenAIResponsesStream;
 exports.OpenAIResponsesStreamError = OpenAIResponsesStreamError;
 exports.QuotaManager = QuotaManager;
+exports.RETRYABLE_STATUS_CODES = RETRYABLE_STATUS_CODES;
+exports.ResponsesModule = ResponsesModule;
+exports.ToolCallAccumulator = ToolCallAccumulator;
 exports.ToolRegistry = ToolRegistry;
 exports.addSpanEvent = addSpanEvent;
 exports.applySkill = applySkill;
 exports.calculateBackoff = calculateBackoff;
+exports.checkChatContext = checkChatContext;
 exports.checkEndpointHealth = checkEndpointHealth;
+exports.checkGenerateContext = checkGenerateContext;
 exports.composeMiddleware = composeMiddleware;
+exports.contextWarningMessage = contextWarningMessage;
 exports.createConsoleLogger = createConsoleLogger;
+exports.createDecision = createDecision;
 exports.createOllamaCloudFreeTierQuota = createOllamaCloudFreeTierQuota;
 exports.createTimeoutSignal = createTimeoutSignal;
 exports.defineTool = defineTool;
 exports.detectModelCapabilities = detectModelCapabilities;
 exports.encodeImage = encodeImage;
+exports.estimateChatRequestTokens = estimateChatRequestTokens;
+exports.estimateGenerateRequestTokens = estimateGenerateRequestTokens;
+exports.estimateSystemOneRequestBytes = estimateSystemOneRequestBytes;
+exports.estimateTokens = estimateTokens;
 exports.extractUsage = extractUsage;
+exports.fetchWithBackoff = fetchWithBackoff;
+exports.imageStringNeedsResolution = imageStringNeedsResolution;
 exports.inferRuntimeMode = inferRuntimeMode;
+exports.isKeepAliveSugar = isKeepAliveSugar;
+exports.isKnownDoneReason = isKnownDoneReason;
+exports.isSameToolCall = isSameToolCall;
 exports.listAllMcpTools = listAllMcpTools;
 exports.listAvailableModels = listAvailableModels;
 exports.loadMcpTools = loadMcpTools;
 exports.mapError = mapError;
+exports.mergeToolCall = mergeToolCall;
+exports.mergeToolCallArgumentsString = mergeToolCallArgumentsString;
+exports.mergeToolCallArrays = mergeToolCallArrays;
 exports.normalizeChatStream = normalizeChatStream;
 exports.normalizeGenerateStream = normalizeGenerateStream;
+exports.normalizeKeepAlive = normalizeKeepAlive;
 exports.normalizeProgressStream = normalizeProgressStream;
 exports.parseFrontmatter = parseFrontmatter;
 exports.parseNdjsonStream = parseNdjsonStream;
@@ -4588,6 +6923,7 @@ exports.parseSseStream = parseSseStream;
 exports.parseStructuredOutput = parseStructuredOutput;
 exports.registerMcpTools = registerMcpTools;
 exports.resolveCredentialEndpoints = resolveCredentialEndpoints;
+exports.resolveImageInput = resolveImageInput;
 exports.setSpanError = setSpanError;
 exports.toDataStream = toDataStream;
 exports.toResponse = toResponse;