@nemesis-oss/ollama-sdk 1.1.0 → 1.4.0

package/dist/index.cjs

@@ -5,6 +5,7 @@ var zod = require('zod');
 // src/config.ts
 var DEFAULT_BASE_URL = "http://localhost:11434";
 var DEFAULT_TIMEOUT_MS = 3e4;
+var OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
 function readEnv(name) {
   return typeof process !== "undefined" && process.env ? process.env[name] : void 0;
 }
@@ -14,6 +15,34 @@ function resolveBaseUrl(configBaseUrl) {
 function resolveApiKey(configApiKey) {
   return configApiKey ?? readEnv("OLLAMA_API_KEY");
 }
+function resolveCredentialEndpoints(config) {
+  if (config.credentials === void 0) return [];
+  const modelsByCredential = /* @__PURE__ */ new Map();
+  for (const [model, bound] of Object.entries(config.modelBindings ?? {})) {
+    for (const id of typeof bound === "string" ? [bound] : bound) {
+      if (!(id in config.credentials)) {
+        throw new Error(
+          `modelBindings["${model}"] references unknown credential "${id}" \u2014 it isn't in \`credentials\`. Known credentials: ${Object.keys(config.credentials).join(", ") || "(none)"}.`
+        );
+      }
+      const list = modelsByCredential.get(id) ?? [];
+      list.push(model);
+      modelsByCredential.set(id, list);
+    }
+  }
+  return Object.entries(config.credentials).map(([id, credential]) => {
+    const isDefault = id === config.defaultCredential;
+    const boundModels = isDefault ? void 0 : modelsByCredential.get(id);
+    return {
+      name: `credential:${id}`,
+      baseUrl: resolveBaseUrl(credential.baseUrl ?? config.baseUrl),
+      apiKey: credential.apiKey,
+      ...credential.headers !== void 0 ? { headers: credential.headers } : {},
+      ...boundModels !== void 0 ? { models: boundModels } : {},
+      priority: isDefault ? -1 : 0
+    };
+  });
+}
 var DEFAULT_FAILOVER_CODES = [
   "network_error",
   "timeout",
@@ -72,6 +101,15 @@ var OllamaRateLimitError = class extends OllamaClientError {
     this.retryAfterMs = options?.retryAfterMs;
   }
 };
+var OllamaQuotaExceededError = class extends OllamaClientError {
+  windowId;
+  resetAt;
+  constructor(message, options) {
+    super(message, { ...options, code: "quota_exceeded", retryable: false });
+    this.windowId = options.windowId;
+    this.resetAt = options.resetAt;
+  }
+};
 var OllamaServerError = class extends OllamaClientError {
   constructor(message, options) {
     super(message, { ...options, code: "server_error", retryable: true });
@@ -107,6 +145,35 @@ var OllamaUnsupportedCapabilityError = class extends OllamaClientError {
     this.capability = options.capability;
   }
 };
+var OllamaModelRoutingError = class extends OllamaClientError {
+  model;
+  availableModels;
+  constructor(message, options) {
+    super(message, { ...options, code: "model_routing_error", retryable: false });
+    this.model = options.model;
+    this.availableModels = options.availableModels;
+  }
+};
+var OllamaIncompatibleModelError = class extends OllamaClientError {
+  model;
+  capability;
+  reportedCapabilities;
+  constructor(message, options) {
+    super(message, { ...options, code: "incompatible_model", retryable: false });
+    this.model = options.model;
+    this.capability = options.capability;
+    this.reportedCapabilities = options.reportedCapabilities;
+  }
+};
+var OllamaAgentMaxToolCallsError = class extends OllamaClientError {
+  maxToolCalls;
+  toolCallsExecuted;
+  constructor(message, options) {
+    super(message, { ...options, code: "agent_max_tool_calls_exceeded", retryable: false });
+    this.maxToolCalls = options.maxToolCalls;
+    this.toolCallsExecuted = options.toolCallsExecuted;
+  }
+};
 var OllamaAgentMaxIterationsError = class extends OllamaClientError {
   maxIterations;
   constructor(message, options) {
@@ -218,17 +285,143 @@ var EndpointRegistry = class {
   failureThreshold;
   cooldownMs;
   now;
+  strategy;
+  roundRobinCounter = 0;
+  activeCounts = /* @__PURE__ */ new Map();
+  maxConcurrentPerEndpoint;
+  waiters = [];
   constructor(endpoints, options = {}) {
     this.endpoints = endpoints.length > 0 ? endpoints : [{ name: "default", baseUrl: "http://localhost:11434" }];
     this.failureThreshold = options.failureThreshold ?? 3;
     this.cooldownMs = options.cooldownMs ?? 3e4;
     this.now = options.now ?? Date.now;
+    this.strategy = options.strategy ?? "priority";
+    this.maxConcurrentPerEndpoint = options.maxConcurrentPerEndpoint;
+  }
+  /**
+   * Marks one more request as in-flight against `name`. Callers (`OllamaClient`) must
+   * pair every `acquire` with a `release` once that attempt finishes, success or not —
+   * see `OllamaClient.executeWithFailover`. Only affects candidate ordering when
+   * `strategy` is `'least-connections'`; harmless (just bookkeeping) otherwise, and
+   * always reflected in `status()`'s `activeRequests`.
+   */
+  acquire(name) {
+    this.activeCounts.set(name, (this.activeCounts.get(name) ?? 0) + 1);
+  }
+  /** Releases one in-flight request marked via `acquire`, waking one waiter for `name` if any. */
+  release(name) {
+    const next = (this.activeCounts.get(name) ?? 0) - 1;
+    if (next <= 0) {
+      this.activeCounts.delete(name);
+    } else {
+      this.activeCounts.set(name, next);
+    }
+    const idx = this.waiters.findIndex((w) => w.names.includes(name));
+    if (idx !== -1) {
+      const [waiter] = this.waiters.splice(idx, 1);
+      waiter?.cleanup();
+      waiter?.resolve();
+    }
+  }
+  /**
+   * `candidates` filtered down to those currently under `maxConcurrentPerEndpoint` (all
+   * of them, unchanged, if that option is unset).
+   */
+  filterWithCapacity(candidates) {
+    const cap = this.maxConcurrentPerEndpoint;
+    if (cap === void 0) return [...candidates];
+    return candidates.filter((ep) => (this.activeCounts.get(ep.name) ?? 0) < cap);
+  }
+  /**
+   * Resolves once any endpoint named in `names` has spare capacity under
+   * `maxConcurrentPerEndpoint` (a no-op resolve if that option is unset, or if one
+   * already does). Otherwise queues (FIFO per name) until a matching `release()` frees a
+   * slot, or rejects if `signal` aborts first — mirroring whatever aborted it
+   * (`OllamaTimeoutError`/the caller's own abort reason) so callers see the same error
+   * shape as any other in-flight request that times out or is cancelled. FIFO order is
+   * best-effort (a newly-arriving request can still win a race for a slot that just
+   * freed) — the capacity cap itself, not fairness, is the guarantee this exists for.
+   */
+  waitForCapacity(names, signal) {
+    const cap = this.maxConcurrentPerEndpoint;
+    if (cap === void 0) return Promise.resolve();
+    if (names.some((n) => (this.activeCounts.get(n) ?? 0) < cap)) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const waiter = { names, resolve, cleanup: () => void 0 };
+      const onAbort = () => {
+        const idx = this.waiters.indexOf(waiter);
+        if (idx !== -1) this.waiters.splice(idx, 1);
+        reject(
+          signal?.reason instanceof Error ? signal.reason : new OllamaAbortError("Aborted while waiting for endpoint capacity")
+        );
+      };
+      if (signal !== void 0) {
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+        waiter.cleanup = () => signal.removeEventListener("abort", onAbort);
+      }
+      this.waiters.push(waiter);
+    });
+  }
+  /**
+   * Rotates each same-`priority` group in `sorted` (already sorted highest-priority-first)
+   * by one position further per call, wrapping around within the group. Priority tiers
+   * themselves are never reordered — only candidates that were already tied.
+   */
+  applyRoundRobin(sorted) {
+    const offset = this.roundRobinCounter++;
+    const result = [];
+    let i = 0;
+    while (i < sorted.length) {
+      const priority = sorted[i]?.priority ?? 0;
+      let j = i + 1;
+      while (j < sorted.length && (sorted[j]?.priority ?? 0) === priority) j++;
+      const tier = sorted.slice(i, j);
+      const rotation = offset % tier.length;
+      result.push(...tier.slice(rotation), ...tier.slice(0, rotation));
+      i = j;
+    }
+    return result;
+  }
+  /**
+   * Reorders each same-`priority` group in `sorted` by ascending in-flight request count
+   * (from `acquire`/`release`); a stable sort, so candidates tied on active count keep
+   * their relative (priority-then-registration) order. Priority tiers themselves are
+   * never reordered.
+   */
+  applyLeastConnections(sorted) {
+    const result = [];
+    let i = 0;
+    while (i < sorted.length) {
+      const priority = sorted[i]?.priority ?? 0;
+      let j = i + 1;
+      while (j < sorted.length && (sorted[j]?.priority ?? 0) === priority) j++;
+      const tier = [...sorted.slice(i, j)].sort(
+        (a, b) => (this.activeCounts.get(a.name) ?? 0) - (this.activeCounts.get(b.name) ?? 0)
+      );
+      result.push(...tier);
+      i = j;
+    }
+    return result;
   }
-  candidates() {
+  /**
+   * Endpoints eligible for `model`, sorted healthy-first-by-priority (falling back to
+   * soonest-to-recover if every eligible endpoint is cooling down); same-priority
+   * candidates are further reordered per `options.strategy` (see
+   * `EndpointRegistryOptions.strategy`). When `model` is given, endpoints whose `models`
+   * allow-list doesn't include it are excluded entirely — see `OllamaEndpoint.models`.
+   * Omit `model` to consider every configured endpoint, regardless of any `models`
+   * restriction (used for non-model-scoped operations).
+   */
+  candidates(model) {
     const currentTime = this.now();
+    const scoped = model === void 0 ? this.endpoints : this.endpoints.filter((ep) => ep.models === void 0 || ep.models.includes(model));
     const healthy = [];
     const coolingDown = [];
-    for (const ep of this.endpoints) {
+    for (const ep of scoped) {
       const failures = this.failureCounts.get(ep.name) ?? 0;
       const lastFail = this.lastFailures.get(ep.name) ?? 0;
       const isCooling = failures >= this.failureThreshold && currentTime - lastFail < this.cooldownMs;
@@ -239,7 +432,10 @@ var EndpointRegistry = class {
       }
     }
     if (healthy.length > 0) {
-      return healthy.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+      const sorted = healthy.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+      if (this.strategy === "round-robin") return this.applyRoundRobin(sorted);
+      if (this.strategy === "least-connections") return this.applyLeastConnections(sorted);
+      return sorted;
     }
     return coolingDown.sort((a, b) => a.recoveredAt - b.recoveredAt).map((c) => c.endpoint);
   }
@@ -255,6 +451,10 @@ var EndpointRegistry = class {
   list() {
     return this.endpoints;
   }
+  /** True if any configured endpoint restricts itself to a `models` allow-list. */
+  hasModelScopedEndpoints() {
+    return this.endpoints.some((ep) => ep.models !== void 0);
+  }
   status() {
     const currentTime = this.now();
     return this.endpoints.map((ep) => {
@@ -265,12 +465,35 @@ var EndpointRegistry = class {
         endpoint: ep,
         failureCount: failures,
         ...lastFail !== void 0 ? { lastFailureTimestamp: lastFail } : {},
-        isCoolingDown
+        isCoolingDown,
+        activeRequests: this.activeCounts.get(ep.name) ?? 0
       };
     });
   }
 };
 
+// src/middleware.ts
+function composeMiddleware(middlewares, finalHandler) {
+  return function runPipeline(initialRequest) {
+    let index = -1;
+    function dispatch2(i, currentRequest) {
+      if (i <= index) {
+        return Promise.reject(new Error("next() called multiple times in middleware"));
+      }
+      index = i;
+      const fn = middlewares[i];
+      if (i === middlewares.length || !fn) {
+        return finalHandler(currentRequest);
+      }
+      return fn({
+        request: currentRequest,
+        next: () => dispatch2(i + 1, currentRequest)
+      });
+    }
+    return dispatch2(0, initialRequest);
+  };
+}
+
 // src/streaming/ndjson.ts
 async function* parseNdjsonStream(stream) {
   const reader = stream.getReader();
@@ -299,6 +522,99 @@ async function* parseNdjsonStream(stream) {
       yield JSON.parse(buffer.trim());
     }
   } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    reader.releaseLock();
+  }
+}
+
+// src/streaming/sse.ts
+function dispatch(event, data, id, retry) {
+  if (data.length === 0) return void 0;
+  const joined = data.join("\n");
+  return {
+    ...event !== void 0 ? { event } : {},
+    data: joined.endsWith("\n") ? joined.slice(0, -1) : joined,
+    ...id !== void 0 ? { id } : {},
+    ...retry !== void 0 ? { retry } : {}
+  };
+}
+async function* parseSseStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let eventType;
+  let data = [];
+  let lastEventId;
+  let retry;
+  const processLine = (line) => {
+    if (line.length === 0) {
+      const event = dispatch(eventType, data, lastEventId, retry);
+      eventType = void 0;
+      data = [];
+      retry = void 0;
+      return event;
+    }
+    if (line.startsWith(":")) return void 0;
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    let value = separator === -1 ? "" : line.slice(separator + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) lastEventId = value;
+        break;
+      case "retry": {
+        if (/^\d+$/.test(value)) {
+          const parsed = Number(value);
+          if (Number.isSafeInteger(parsed)) retry = parsed;
+        }
+        break;
+      }
+    }
+    return void 0;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const lf = buffer.indexOf("\n");
+        const cr = buffer.indexOf("\r");
+        if (lf === -1 && cr === -1) break;
+        if (cr !== -1 && lf === -1 && cr === buffer.length - 1) break;
+        const lineEnd = lf === -1 ? cr : cr === -1 ? lf : Math.min(lf, cr);
+        let separatorLength = 1;
+        if (buffer[lineEnd] === "\r" && buffer[lineEnd + 1] === "\n") {
+          separatorLength = 2;
+        }
+        const line = buffer.slice(0, lineEnd);
+        buffer = buffer.slice(lineEnd + separatorLength);
+        const event = processLine(line);
+        if (event) yield event;
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) {
+      const event = processLine(buffer);
+      if (event) yield event;
+    }
+    const terminal = dispatch(eventType, data, lastEventId, retry);
+    if (terminal) yield terminal;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
     reader.releaseLock();
   }
 }
@@ -383,16 +699,36 @@ function httpSpanAttributes(method, url) {
     [ATTR_SERVER_PORT]: target.port ? Number(target.port) : void 0
   };
 }
+var requestSequence = 0;
+function createRequestId() {
+  requestSequence += 1;
+  return `ollama-http-${requestSequence}`;
+}
+function sameHeaders(actual, expected) {
+  const actualEntries = Object.fromEntries(
+    Object.entries(actual).map(([key, value]) => [key.toLowerCase(), value])
+  );
+  const expectedEntries = Object.fromEntries(expected.entries());
+  const actualKeys = Object.keys(actualEntries);
+  const expectedKeys = Object.keys(expectedEntries);
+  return actualKeys.length === expectedKeys.length && expectedKeys.every((key) => actualEntries[key] === expectedEntries[key]);
+}
 var HttpClient = class {
   baseUrl;
   apiKey;
   defaultHeaders;
   fetchImpl;
+  middleware;
+  onLifecycleEvent;
+  requestId;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this.defaultHeaders = options.headers ?? {};
     this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.middleware = options.middleware ?? [];
+    this.onLifecycleEvent = options.onLifecycleEvent;
+    this.requestId = options.requestId;
   }
   buildHeaders(customHeaders) {
     const headers = {
@@ -405,6 +741,131 @@ var HttpClient = class {
     }
     return headers;
   }
+  async fetchWithMiddleware(request) {
+    const requestId = this.requestId ?? createRequestId();
+    const startedAt = Date.now();
+    let rawResponse;
+    this.onLifecycleEvent?.({
+      type: "start",
+      requestId,
+      method: request.method,
+      url: request.url,
+      timestamp: startedAt
+    });
+    const finalHandler = async (req) => {
+      const init = {
+        method: req.method,
+        headers: req.headers,
+        ...req.body !== void 0 ? { body: req.body } : {},
+        ...req.signal !== void 0 ? { signal: req.signal } : {}
+      };
+      const response = await this.fetchImpl(req.url, init);
+      rawResponse = response;
+      const responseHeaders = response.headers && typeof response.headers.entries === "function" ? Object.fromEntries(response.headers.entries()) : {};
+      return {
+        status: response.status,
+        headers: responseHeaders,
+        body: response
+      };
+    };
+    try {
+      if (this.middleware.length === 0) {
+        const response2 = await this.fetchImpl(request.url, {
+          method: request.method,
+          headers: request.headers,
+          ...request.body !== void 0 ? { body: request.body } : {},
+          ...request.signal !== void 0 ? { signal: request.signal } : {}
+        });
+        if (response2.status >= 200 && response2.status < 300) {
+          this.onLifecycleEvent?.({
+            type: "success",
+            requestId,
+            durationMs: Date.now() - startedAt,
+            status: response2.status,
+            timestamp: Date.now()
+          });
+        } else {
+          this.onLifecycleEvent?.({
+            type: "error",
+            requestId,
+            durationMs: Date.now() - startedAt,
+            error: mapError(new Error(`HTTP ${response2.status}`), {
+              request: { method: request.method, url: request.url },
+              response: { status: response2.status }
+            }),
+            timestamp: Date.now()
+          });
+        }
+        return response2;
+      }
+      const pipeline = composeMiddleware(this.middleware, finalHandler);
+      const context = await pipeline(request);
+      let response;
+      if (rawResponse !== void 0 && context.body === rawResponse) {
+        response = rawResponse;
+        if (context.status !== response.status || !sameHeaders(context.headers, response.headers)) {
+          const cloned = response.clone();
+          response = new Response(cloned.body, {
+            status: context.status,
+            headers: context.headers
+          });
+        }
+      } else if (context.body instanceof Response) {
+        if (context.status === context.body.status && sameHeaders(context.headers, context.body.headers)) {
+          response = context.body;
+        } else {
+          const cloned = context.body.clone();
+          response = new Response(cloned.body, {
+            status: context.status,
+            headers: context.headers
+          });
+        }
+      } else if (context.body === void 0 || typeof context.body === "string" || context.body instanceof ArrayBuffer || ArrayBuffer.isView(context.body) || context.body instanceof Blob || context.body instanceof ReadableStream) {
+        response = new Response(context.body, {
+          status: context.status,
+          headers: context.headers
+        });
+      } else {
+        response = new Response(JSON.stringify(context.body), {
+          status: context.status,
+          headers: context.headers
+        });
+      }
+      if (context.status >= 200 && context.status < 300) {
+        this.onLifecycleEvent?.({
+          type: "success",
+          requestId,
+          durationMs: Date.now() - startedAt,
+          status: context.status,
+          timestamp: Date.now()
+        });
+      } else {
+        this.onLifecycleEvent?.({
+          type: "error",
+          requestId,
+          durationMs: Date.now() - startedAt,
+          error: mapError(new Error(`HTTP ${context.status}`), {
+            request: { method: request.method, url: request.url },
+            response: { status: context.status, headers: context.headers }
+          }),
+          timestamp: Date.now()
+        });
+      }
+      return response;
+    } catch (error) {
+      const mapped = mapError(error, {
+        request: { method: request.method, url: request.url }
+      });
+      this.onLifecycleEvent?.({
+        type: "error",
+        requestId,
+        durationMs: Date.now() - startedAt,
+        error: mapped,
+        timestamp: Date.now()
+      });
+      throw mapped;
+    }
+  }
   async request(options) {
     const url = `${this.baseUrl}${options.path}`;
     const method = options.method ?? (options.body !== void 0 || options.rawBody !== void 0 ? "POST" : "GET");
@@ -418,13 +879,13 @@ var HttpClient = class {
       async (span) => {
         try {
           const bodyInit = options.rawBody !== void 0 ? options.rawBody : options.body !== void 0 ? JSON.stringify(options.body) : void 0;
-          const init = {
+          const response = await this.fetchWithMiddleware({
+            url,
             method,
             headers,
             ...bodyInit !== void 0 ? { body: bodyInit } : {},
             ...options.signal !== void 0 ? { signal: options.signal } : {}
-          };
-          const response = await this.fetchImpl(url, init);
+          });
           span?.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
           if (!response.ok) {
             let errorBody;
@@ -442,6 +903,9 @@ var HttpClient = class {
           if (options.method === "HEAD" || response.status === 204) {
             return void 0;
           }
+          if (options.raw === true) {
+            return response;
+          }
           if (typeof response.text === "function") {
             const text = await response.text();
             return text ? JSON.parse(text) : void 0;
@@ -456,6 +920,79 @@ var HttpClient = class {
       }
     );
   }
+  /**
+   * Opens an event-stream response and exposes parsed SSE events.
+   *
+   * This is intentionally schema-agnostic so OpenAI and Anthropic compatibility layers
+   * can decode their provider-specific event payloads without duplicating transport logic.
+   */
+  async requestSseStream(options) {
+    const url = `${this.baseUrl}${options.path}`;
+    const method = options.method ?? "POST";
+    const headers = {
+      ...this.buildHeaders(options.headers),
+      Accept: "text/event-stream"
+    };
+    return withSpan(
+      `${method} ${routeTemplate(options.path)}`,
+      httpSpanAttributes(method, url),
+      async (span) => {
+        try {
+          const controller = new AbortController();
+          const removeAbortListener = options.signal !== void 0 ? (() => {
+            if (options.signal.aborted) {
+              controller.abort(options.signal.reason);
+            } else {
+              const onAbort = () => controller.abort(options.signal?.reason);
+              options.signal.addEventListener("abort", onAbort, { once: true });
+              return () => options.signal?.removeEventListener("abort", onAbort);
+            }
+            return void 0;
+          })() : void 0;
+          const response = await this.fetchWithMiddleware({
+            url,
+            method,
+            headers,
+            ...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {},
+            signal: controller.signal
+          });
+          span?.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
+          if (!response.ok) {
+            removeAbortListener?.();
+            const errorText = await response.text();
+            throw mapError(new Error(errorText || `HTTP ${response.status}`), {
+              request: { method, url },
+              response: { status: response.status, body: errorText }
+            });
+          }
+          if (!response.body) {
+            removeAbortListener?.();
+            throw mapError(new Error("Response body is null, cannot stream SSE"), {
+              request: { method, url }
+            });
+          }
+          const stream = (async function* () {
+            try {
+              yield* parseSseStream(response.body);
+            } finally {
+              removeAbortListener?.();
+            }
+          })();
+          return {
+            [Symbol.asyncIterator]() {
+              return stream[Symbol.asyncIterator]();
+            },
+            abort: () => {
+              removeAbortListener?.();
+              controller.abort();
+            }
+          };
+        } catch (err) {
+          throw mapError(err, { request: { method, url } });
+        }
+      }
+    );
+  }
   async requestStream(options) {
     const url = `${this.baseUrl}${options.path}`;
     const method = options.method ?? "POST";
@@ -465,15 +1002,27 @@ var HttpClient = class {
       httpSpanAttributes(method, url),
       async (span) => {
         try {
-          const init = {
+          const controller = new AbortController();
+          const removeAbortListener = options.signal !== void 0 ? (() => {
+            if (options.signal.aborted) {
+              controller.abort(options.signal.reason);
+            } else {
+              const onAbort = () => controller.abort(options.signal?.reason);
+              options.signal.addEventListener("abort", onAbort, { once: true });
+              return () => options.signal?.removeEventListener("abort", onAbort);
+            }
+            return void 0;
+          })() : void 0;
+          const response = await this.fetchWithMiddleware({
+            url,
             method,
             headers,
             ...options.body !== void 0 ? { body: JSON.stringify(options.body) } : {},
-            ...options.signal !== void 0 ? { signal: options.signal } : {}
-          };
-          const response = await this.fetchImpl(url, init);
+            signal: controller.signal
+          });
           span?.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, response.status);
           if (!response.ok) {
+            removeAbortListener?.();
             const errorText = await response.text();
             throw mapError(new Error(errorText || `HTTP ${response.status}`), {
               request: { method, url },
@@ -481,6 +1030,7 @@ var HttpClient = class {
             });
           }
           if (!response.body) {
+            removeAbortListener?.();
             throw mapError(new Error("Response body is null, cannot stream"), {
               request: { method, url }
             });
@@ -488,7 +1038,17 @@ var HttpClient = class {
           const stream = parseNdjsonStream(response.body);
           const abortable = {
             [Symbol.asyncIterator]() {
-              return stream[Symbol.asyncIterator]();
+              return (async function* () {
+                try {
+                  yield* stream;
+                } finally {
+                  removeAbortListener?.();
+                }
+              })()[Symbol.asyncIterator]();
+            },
+            abort: () => {
+              removeAbortListener?.();
+              controller.abort();
             }
           };
           return abortable;
@@ -501,12 +1061,14 @@ var HttpClient = class {
 };
 
 // src/providers/health-check.ts
-async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3) {
+async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3, middleware, onLifecycleEvent) {
   const client = new HttpClient({
     baseUrl: endpoint.baseUrl,
     apiKey: endpoint.apiKey,
     headers: endpoint.headers,
-    fetch: fetchImpl
+    fetch: fetchImpl,
+    middleware,
+    onLifecycleEvent
   });
   const startTime = Date.now();
   const controller = new AbortController();
@@ -552,13 +1114,24 @@ function inferRuntimeMode(baseUrl) {
     return "unknown";
   }
 }
-async function detectModelCapabilities(http, model) {
+function extractContextLength(modelInfo) {
+  if (!modelInfo) return void 0;
+  for (const [key, value] of Object.entries(modelInfo)) {
+    if (key.endsWith(".context_length") && typeof value === "number" && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+async function detectModelCapabilities(http, model, signal) {
   const showRes = await http.request({
     path: "/api/show",
-    body: { model }
+    body: { model },
+    ...signal !== void 0 ? { signal } : {}
   });
   const reported = showRes.capabilities ?? [];
   const reportedSet = new Set(reported.map((c) => c.toLowerCase()));
+  const contextLength = extractContextLength(showRes.model_info);
   return {
     model,
     reported,
@@ -567,6 +1140,8 @@ async function detectModelCapabilities(http, model) {
     supportsEmbedding: reportedSet.has("embedding"),
     supportsCompletion: reportedSet.has("completion") || !reportedSet.has("embedding"),
     supportsThinking: reportedSet.has("thinking"),
+    ...showRes.thinking !== void 0 ? { thinking: showRes.thinking } : {},
+    ...contextLength !== void 0 ? { contextLength } : {},
     supportsStreaming: true,
     supportsStructuredOutputRequest: inferRuntimeMode(http.baseUrl) !== "cloud"
   };
@@ -691,6 +1266,7 @@ function extractUsage(raw) {
   }
   return {
     promptTokens,
+    ...raw.prompt_eval_cached_count !== void 0 ? { cachedPromptTokens: raw.prompt_eval_cached_count } : {},
     completionTokens,
     totalTokens,
     ...tokensPerSecond !== void 0 ? { tokensPerSecond } : {},
@@ -714,7 +1290,7 @@ function ensureToolCallIds(toolCalls) {
 
 // src/streaming/stream.ts
 var OllamaStream = class {
-  constructor(source, mapChunk, aggregate, initial) {
+  constructor(source, mapChunk, aggregate, initial, signal) {
     this.source = source;
     this.mapChunk = mapChunk;
     this.aggregate = aggregate;
@@ -723,6 +1299,15 @@ var OllamaStream = class {
       this.resolveFinal = resolve;
       this.rejectFinal = reject;
     });
+    if (signal !== void 0) {
+      const onAbort = () => this.abort();
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+      }
+    }
   }
   source;
   mapChunk;
@@ -733,11 +1318,15 @@ var OllamaStream = class {
   finalResultPromise;
   resolveFinal;
   rejectFinal;
+  removeAbortListener;
   get finalResult() {
     return this.finalResultPromise;
   }
   abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
     this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("Ollama stream aborted"));
   }
   on(type, listener) {
     if (this.mode === "iterator") {
@@ -777,7 +1366,11 @@ var OllamaStream = class {
           }
         }
       }
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
     } catch (error) {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
       const mapped = mapError(error);
       this.emit({ type: "error", data: { error: mapped } });
       this.rejectFinal(mapped);
@@ -791,12 +1384,14 @@ var OllamaStream = class {
     }
     this.mode = "iterator";
     let accumulated = this.initial;
+    let completed = false;
     try {
       for await (const chunk of this.source) {
         accumulated = this.aggregate(accumulated, chunk);
         const events = this.mapChunk(chunk, accumulated);
         for (const event of events) {
           if (event.type === "done") {
+            completed = true;
             this.resolveFinal(event.data.result);
           }
           yield event;
@@ -806,6 +1401,13 @@ var OllamaStream = class {
       const mapped = mapError(error);
       this.rejectFinal(mapped);
       yield { type: "error", data: { error: mapped } };
+    } finally {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      if (!completed) {
+        this.source.abort?.();
+        this.rejectFinal(new OllamaAbortError("Ollama stream ended before completion"));
+      }
     }
   }
 };
@@ -859,13 +1461,13 @@ function withStableToolCallIds(source) {
   }
   return Object.assign(generator(), { abort: source.abort });
 }
-function normalizeChatStream(source) {
+function normalizeChatStream(source, signal) {
   const initial = {
     message: { role: "assistant", content: "" },
     model: "",
     done: false
   };
-  return new OllamaStream(withStableToolCallIds(source), mapChatChunk, aggregateChat, initial);
+  return new OllamaStream(withStableToolCallIds(source), mapChatChunk, aggregateChat, initial, signal);
 }
 function aggregateGenerate(accumulated, chunk) {
   return {
@@ -875,6 +1477,10 @@ function aggregateGenerate(accumulated, chunk) {
     doneReason: chunk.done ? chunk.done_reason : accumulated.doneReason,
     totalDurationMs: chunk.done && chunk.total_duration !== void 0 ? chunk.total_duration / NANOS_PER_MS : accumulated.totalDurationMs,
     usage: chunk.done ? extractUsage(chunk) : accumulated.usage,
+    thinking: chunk.thinking !== void 0 ? (accumulated.thinking ?? "") + chunk.thinking : accumulated.thinking,
+    image: chunk.image ?? accumulated.image,
+    completed: chunk.completed ?? accumulated.completed,
+    total: chunk.total ?? accumulated.total,
     raw: chunk
   };
 }
@@ -892,9 +1498,9 @@ function mapGenerateChunk(chunk, aggregated) {
   }
   return events;
 }
-function normalizeGenerateStream(source) {
+function normalizeGenerateStream(source, signal) {
   const initial = { response: "", model: "", done: false };
-  return new OllamaStream(source, mapGenerateChunk, aggregateGenerate, initial);
+  return new OllamaStream(source, mapGenerateChunk, aggregateGenerate, initial, signal);
 }
 function aggregateProgress(_accumulated, chunk) {
   return {
@@ -914,9 +1520,9 @@ function mapProgressChunk(chunk, aggregated) {
   }
   return events;
 }
-function normalizeProgressStream(source) {
+function normalizeProgressStream(source, signal) {
   const initial = { status: "", done: false };
-  return new OllamaStream(source, mapProgressChunk, aggregateProgress, initial);
+  return new OllamaStream(source, mapProgressChunk, aggregateProgress, initial, signal);
 }
 
 // src/transport/backoff.ts
@@ -942,8 +1548,33 @@ function isRetryableDefault(error) {
   }
   return false;
 }
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function withRetry(operation, config = DEFAULT_RETRY_CONFIG) {
+function abortError(signal, fallbackMessage) {
+  const reason = signal?.reason;
+  if (reason instanceof OllamaClientError) return reason;
+  return new OllamaAbortError(
+    reason instanceof Error && reason.message ? reason.message : fallbackMessage,
+    { cause: reason }
+  );
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal, "Retry backoff aborted"));
+      return;
+    }
+    const timerId = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      if (timerId !== void 0) clearTimeout(timerId);
+      signal?.removeEventListener("abort", onAbort);
+      reject(abortError(signal, "Retry backoff aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function withRetry(operation, config = DEFAULT_RETRY_CONFIG, signal) {
   let attempt = 0;
   while (true) {
     try {
@@ -956,7 +1587,7 @@ async function withRetry(operation, config = DEFAULT_RETRY_CONFIG) {
       }
       const delayMs = calculateBackoff(attempt, config.backoff);
       config.onRetry?.(error, attempt, delayMs);
-      await sleep(delayMs);
+      await sleep(delayMs, signal);
       attempt += 1;
     }
   }
@@ -1022,9 +1653,9 @@ var ModelsClient = class {
             body: { ...request, stream: true },
             signal
           });
-          return normalizeProgressStream(stream);
+          return normalizeProgressStream(stream, signal);
         },
-        { ...request, singleEndpoint: true }
+        { ...request, singleEndpoint: true, holdUntil: (stream) => stream.finalResult }
       );
     }
     return this.runner(
@@ -1045,9 +1676,9 @@ var ModelsClient = class {
             body: { ...request, stream: true },
             signal
           });
-          return normalizeProgressStream(stream);
+          return normalizeProgressStream(stream, signal);
         },
-        { ...request, singleEndpoint: true }
+        { ...request, singleEndpoint: true, holdUntil: (stream) => stream.finalResult }
       );
     }
     return this.runner(
@@ -1070,7 +1701,7 @@ var ModelsClient = class {
           });
           return normalizeProgressStream(stream);
         },
-        { ...request, singleEndpoint: true }
+        { ...request, singleEndpoint: true, holdUntil: (stream) => stream.finalResult }
       );
     }
     return this.runner(
@@ -1139,58 +1770,944 @@ var ModelsClient = class {
 };
 
 // src/integrations/openai.ts
-var OpenAICompatClient = class {
-  constructor(http) {
-    this.http = http;
+var OpenAIResponsesStreamError = class extends OllamaClientError {
+  responsePayload;
+  constructor(message, responsePayload) {
+    super(message, { code: "openai_responses_stream_error", retryable: false, response: { body: responsePayload } });
+    this.responsePayload = responsePayload;
   }
-  http;
-  async createChatCompletion(request, signal) {
-    return this.http.request({
-      path: "/v1/chat/completions",
-      body: request,
-      signal
+};
+var OpenAIChatCompletionStream = class {
+  constructor(source, signal) {
+    this.source = source;
+    this.finalResultPromise = new Promise((resolve, reject) => {
+      this.resolveFinal = resolve;
+      this.rejectFinal = reject;
     });
+    if (signal !== void 0) {
+      const onAbort = () => this.abort();
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+      }
+    }
   }
-  async chatCompletions(request, signal) {
-    return this.createChatCompletion(request, signal);
-  }
-  async listModels(signal) {
-    return this.http.request({
-      path: "/v1/models",
-      method: "GET",
-      signal
-    });
+  source;
+  finalResultPromise;
+  resolveFinal;
+  rejectFinal;
+  removeAbortListener;
+  get finalResult() {
+    return this.finalResultPromise;
   }
-  async createResponses(request, signal) {
-    return this.http.request({
-      path: "/v1/responses",
-      body: request,
-      signal
-    });
+  abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
+    this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("OpenAI Chat Completion stream aborted"));
   }
-  async responses(request, signal) {
-    return this.createResponses(request, signal);
+  async *[Symbol.asyncIterator]() {
+    const choices = /* @__PURE__ */ new Map();
+    let id = "";
+    let model = "";
+    let created = 0;
+    let systemFingerprint;
+    let usage;
+    let completed = false;
+    try {
+      for await (const event of this.source) {
+        if (event.data === "[DONE]") break;
+        let chunk;
+        try {
+          chunk = JSON.parse(event.data);
+        } catch (error) {
+          throw new Error("Failed to parse OpenAI chat completion SSE payload", { cause: error });
+        }
+        id = chunk.id || id;
+        model = chunk.model || model;
+        created = chunk.created || created;
+        if (chunk.system_fingerprint !== void 0) systemFingerprint = chunk.system_fingerprint;
+        if (chunk.usage !== null && chunk.usage !== void 0) usage = chunk.usage;
+        for (const choice of chunk.choices) {
+          const existing = choices.get(choice.index);
+          const delta = choice.delta;
+          if (!existing) {
+            const toolCalls = delta.tool_calls?.map((toolCall) => ({
+              id: toolCall.id ?? "",
+              type: "function",
+              function: {
+                name: toolCall.function?.name ?? "",
+                arguments: toolCall.function?.arguments ?? ""
+              }
+            }));
+            choices.set(choice.index, {
+              message: {
+                role: delta.role ?? "assistant",
+                content: delta.content ?? "",
+                ...delta.reasoning !== void 0 && delta.reasoning !== null ? { reasoning: delta.reasoning } : {},
+                ...toolCalls?.length ? { tool_calls: toolCalls } : {}
+              },
+              finish_reason: choice.finish_reason ?? "",
+              ...choice.logprobs !== void 0 ? { logprobs: choice.logprobs } : {}
+            });
+            continue;
+          }
+          const priorToolCalls = [...existing.message.tool_calls ?? []];
+          for (const toolCall of delta.tool_calls ?? []) {
+            const position = toolCall.index;
+            const current = priorToolCalls[position];
+            if (current) {
+              priorToolCalls[position] = {
+                ...current,
+                ...toolCall.id !== void 0 ? { id: toolCall.id } : {},
+                function: {
+                  name: current.function?.name ?? toolCall.function?.name ?? "",
+                  arguments: (current.function?.arguments ?? "") + (toolCall.function?.arguments ?? "")
+                }
+              };
+            } else {
+              priorToolCalls[position] = {
+                id: toolCall.id ?? "",
+                type: "function",
+                function: {
+                  name: toolCall.function?.name ?? "",
+                  arguments: toolCall.function?.arguments ?? ""
+                }
+              };
+            }
+          }
+          choices.set(choice.index, {
+            message: {
+              ...existing.message,
+              ...delta.content !== void 0 && delta.content !== null ? { content: existing.message.content + delta.content } : {},
+              ...delta.reasoning !== void 0 && delta.reasoning !== null ? { reasoning: (existing.message.reasoning ?? "") + delta.reasoning } : {},
+              ...priorToolCalls.length ? { tool_calls: priorToolCalls } : {}
+            },
+            finish_reason: choice.finish_reason ?? existing.finish_reason,
+            ...choice.logprobs !== void 0 ? { logprobs: choice.logprobs } : {}
+          });
+        }
+        yield chunk;
+      }
+      const response = {
+        id,
+        object: "chat.completion",
+        created,
+        model,
+        ...systemFingerprint !== void 0 ? { system_fingerprint: systemFingerprint } : {},
+        choices: [...choices.entries()].sort(([a], [b]) => a - b).map(([index, choice]) => ({
+          index,
+          message: choice.message,
+          finish_reason: choice.finish_reason,
+          ...choice.logprobs !== void 0 ? { logprobs: choice.logprobs } : {}
+        })),
+        ...usage !== void 0 ? { usage } : {}
+      };
+      completed = true;
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.resolveFinal(response);
+    } catch (error) {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.rejectFinal(error);
+      throw error;
+    } finally {
+      if (!completed) {
+        this.source.abort?.();
+        this.rejectFinal(new OllamaAbortError("OpenAI Chat Completion stream ended before completion"));
+      }
+    }
   }
 };
-
-// src/integrations/anthropic.ts
-var AnthropicCompatClient = class {
-  constructor(http) {
-    this.http = http;
-  }
-  http;
-  async createMessage(request, signal) {
-    return this.http.request({
-      path: "/v1/messages",
-      body: request,
-      signal
+var OpenAICompletionStream = class {
+  constructor(source, signal) {
+    this.source = source;
+    this.finalResultPromise = new Promise((resolve, reject) => {
+      this.resolveFinal = resolve;
+      this.rejectFinal = reject;
     });
+    if (signal !== void 0) {
+      const onAbort = () => this.abort();
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+      }
+    }
+  }
+  source;
+  finalResultPromise;
+  resolveFinal;
+  rejectFinal;
+  removeAbortListener;
+  get finalResult() {
+    return this.finalResultPromise;
+  }
+  abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
+    this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("OpenAI Completion stream aborted"));
+  }
+  async *[Symbol.asyncIterator]() {
+    const texts = /* @__PURE__ */ new Map();
+    let id = "";
+    let model = "";
+    let created = 0;
+    let usage;
+    let completed = false;
+    try {
+      for await (const event of this.source) {
+        if (event.data === "[DONE]") break;
+        const chunk = JSON.parse(event.data);
+        id = chunk.id || id;
+        model = chunk.model || model;
+        created = chunk.created || created;
+        if (chunk.usage !== null && chunk.usage !== void 0) usage = chunk.usage;
+        for (const choice of chunk.choices) {
+          const existing = texts.get(choice.index);
+          texts.set(choice.index, {
+            text: (existing?.text ?? "") + (choice.text ?? ""),
+            index: choice.index,
+            finish_reason: choice.finish_reason ?? existing?.finish_reason ?? null,
+            ...choice.logprobs !== void 0 ? { logprobs: choice.logprobs } : {}
+          });
+        }
+        yield chunk;
+      }
+      const response = {
+        id,
+        object: "text_completion",
+        created,
+        model,
+        choices: [...texts.values()].sort((a, b) => a.index - b.index),
+        ...usage !== void 0 ? { usage } : {}
+      };
+      completed = true;
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.resolveFinal(response);
+    } catch (error) {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.rejectFinal(error);
+      throw error;
+    } finally {
+      if (!completed) {
+        this.source.abort?.();
+        this.rejectFinal(new OllamaAbortError("OpenAI Completion stream ended before completion"));
+      }
+    }
+  }
+};
+var OpenAIResponsesStream = class {
+  constructor(source, signal) {
+    this.source = source;
+    this.finalResultPromise = new Promise((resolve, reject) => {
+      this.resolveFinal = resolve;
+      this.rejectFinal = reject;
+    });
+    if (signal !== void 0) {
+      const onAbort = () => this.abort();
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+      }
+    }
+  }
+  source;
+  finalResultPromise;
+  resolveFinal;
+  rejectFinal;
+  removeAbortListener;
+  get finalResult() {
+    return this.finalResultPromise;
+  }
+  abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
+    this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("OpenAI Responses stream aborted"));
+  }
+  async *[Symbol.asyncIterator]() {
+    let finalResponse;
+    let responseMeta;
+    let terminalFailure;
+    let terminalIncomplete;
+    const outputs = /* @__PURE__ */ new Map();
+    const canonicalOutputItems = /* @__PURE__ */ new Map();
+    let completed = false;
+    const ensureState = (outputIndex, itemId, kind) => {
+      const existing = outputs.get(outputIndex);
+      if (existing) {
+        if (itemId) existing.itemId = itemId;
+        existing.kind = kind;
+        return existing;
+      }
+      const state = { itemId, kind, content: /* @__PURE__ */ new Map(), summary: /* @__PURE__ */ new Map(), arguments: "", reasoningText: "" };
+      outputs.set(outputIndex, state);
+      return state;
+    };
+    const applyOutputItem = (outputIndex, item) => {
+      const kind = item.type === "message" ? "message" : item.type === "function_call" ? "function_call" : "reasoning";
+      const state = ensureState(outputIndex, item.id ?? "", kind);
+      state.itemId = item.id ?? state.itemId;
+      state.status = item.status;
+      if (item.type === "message") {
+        state.role = item.role;
+        state.phase = item.phase;
+        state.content.clear();
+        item.content.forEach((p, i) => state.content.set(i, p));
+      } else if (item.type === "function_call") {
+        state.callId = item.call_id;
+        state.name = item.name;
+        state.arguments = item.arguments;
+      } else {
+        state.summary.clear();
+        item.summary?.forEach((p, i) => state.summary.set(i, p.text));
+        state.reasoningText = item.text ?? "";
+      }
+    };
+    const applyContentPart = (outputIndex, itemId, contentIndex, part) => {
+      const state = ensureState(outputIndex, itemId, "message");
+      state.content.set(contentIndex, part);
+    };
+    const reconstructedOutput = () => [...outputs.entries()].sort(([a], [b]) => a - b).map(([outputIndex, state]) => {
+      const canonical = canonicalOutputItems.get(outputIndex);
+      if (canonical) return canonical;
+      if (state.kind === "message") return { type: "message", ...state.itemId ? { id: state.itemId } : {}, ...state.status ? { status: state.status } : {}, role: state.role ?? "assistant", ...state.phase ? { phase: state.phase } : {}, content: [...state.content.entries()].sort(([a], [b]) => a - b).map(([, p]) => p) };
+      if (state.kind === "function_call") return { type: "function_call", ...state.itemId ? { id: state.itemId } : {}, ...state.callId ? { call_id: state.callId } : {}, ...state.status ? { status: state.status } : {}, name: state.name ?? "", arguments: state.arguments };
+      return { type: "reasoning", ...state.itemId ? { id: state.itemId } : {}, ...state.status ? { status: state.status } : {}, ...state.summary.size ? { summary: [...state.summary.entries()].sort(([a], [b]) => a - b).map(([, text]) => ({ type: "summary_text", text })) } : {}, ...state.reasoningText ? { text: state.reasoningText } : {} };
+    });
+    try {
+      for await (const event of this.source) {
+        if (event.data === "[DONE]") break;
+        let payload;
+        try {
+          payload = JSON.parse(event.data);
+        } catch (error) {
+          throw new Error("Failed to parse OpenAI Responses SSE payload", { cause: error });
+        }
+        switch (payload.type) {
+          case "response.created":
+          case "response.in_progress":
+          case "response.queued":
+            responseMeta = payload.response;
+            break;
+          case "response.completed":
+          case "response.done":
+            finalResponse = payload.response;
+            break;
+          case "response.failed":
+            terminalFailure = payload.response;
+            finalResponse = terminalFailure;
+            break;
+          case "response.incomplete":
+            terminalIncomplete = payload.response;
+            finalResponse = terminalIncomplete;
+            break;
+          case "response.output_item.added": {
+            const e = payload;
+            applyOutputItem(e.output_index, e.item);
+            break;
+          }
+          case "response.output_item.done": {
+            const e = payload;
+            applyOutputItem(e.output_index, e.item);
+            canonicalOutputItems.set(e.output_index, e.item);
+            break;
+          }
+          case "response.content_part.added":
+          case "response.content_part.done": {
+            const e = payload;
+            if (e.part.type === "output_text" && "text" in e.part && typeof e.part.text === "string" || e.part.type === "refusal" && "refusal" in e.part && typeof e.part.refusal === "string") {
+              applyContentPart(e.output_index, e.item_id, e.content_index, e.part);
+            }
+            break;
+          }
+          case "response.output_text.delta": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "message");
+            const p = s.content.get(e.content_index);
+            s.content.set(e.content_index, { type: "output_text", text: (p?.type === "output_text" ? p.text : "") + e.delta });
+            break;
+          }
+          case "response.output_text.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "message");
+            s.content.set(e.content_index, { type: "output_text", text: e.text });
+            break;
+          }
+          case "response.refusal.delta": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "message");
+            const p = s.content.get(e.content_index);
+            s.content.set(e.content_index, { type: "refusal", refusal: (p?.type === "refusal" ? p.refusal : "") + e.delta });
+            break;
+          }
+          case "response.refusal.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "message");
+            s.content.set(e.content_index, { type: "refusal", refusal: e.refusal });
+            break;
+          }
+          case "response.function_call_arguments.delta": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "function_call");
+            s.arguments += e.delta;
+            break;
+          }
+          case "response.function_call_arguments.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "function_call");
+            s.arguments = e.arguments;
+            if (e.name !== void 0) s.name = e.name;
+            break;
+          }
+          case "response.reasoning_summary_part.added":
+          case "response.reasoning_summary_part.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "reasoning");
+            s.summary.set(e.summary_index, e.part.text);
+            break;
+          }
+          case "response.reasoning_summary_text.delta": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "reasoning");
+            s.summary.set(e.summary_index, (s.summary.get(e.summary_index) ?? "") + e.delta);
+            break;
+          }
+          case "response.reasoning_summary_text.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "reasoning");
+            s.summary.set(e.summary_index, e.text);
+            break;
+          }
+          case "response.reasoning_text.delta": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "reasoning");
+            s.reasoningText += e.delta;
+            break;
+          }
+          case "response.reasoning_text.done": {
+            const e = payload;
+            const s = ensureState(e.output_index, e.item_id, "reasoning");
+            s.reasoningText = e.text;
+            break;
+          }
+          default:
+            break;
+        }
+        yield payload;
+      }
+      if (terminalFailure || terminalIncomplete) {
+        const response = terminalFailure ?? terminalIncomplete;
+        const status = terminalFailure ? "failed" : "incomplete";
+        const detail = response.error?.message ?? response.incomplete_details?.reason ?? "unknown error";
+        throw new OpenAIResponsesStreamError("OpenAI Responses stream " + status + ": " + detail, response);
+      }
+      if (!finalResponse) {
+        if (!responseMeta) throw new Error("OpenAI Responses stream ended without a terminal response payload");
+        if (responseMeta.status === "failed" || responseMeta.status === "incomplete") {
+          const detail = responseMeta.error?.message ?? responseMeta.incomplete_details?.reason ?? "unknown error";
+          throw new OpenAIResponsesStreamError("OpenAI Responses stream " + responseMeta.status + ": " + detail, responseMeta);
+        }
+        finalResponse = { ...responseMeta, output: reconstructedOutput(), status: "completed" };
+      } else if (finalResponse.status === "failed" || finalResponse.status === "incomplete") {
+        const detail = finalResponse.error?.message ?? finalResponse.incomplete_details?.reason ?? "unknown error";
+        throw new OpenAIResponsesStreamError("OpenAI Responses stream " + finalResponse.status + ": " + detail, finalResponse);
+      }
+      if (finalResponse.output.length === 0 && outputs.size > 0) finalResponse = { ...finalResponse, output: reconstructedOutput() };
+      completed = true;
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.resolveFinal(finalResponse);
+    } catch (error) {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.rejectFinal(error);
+      throw error;
+    } finally {
+      if (!completed) {
+        this.source.abort?.();
+        this.rejectFinal(new OllamaAbortError("OpenAI Responses stream ended before completion"));
+      }
+    }
+  }
+};
+var OpenAICompatClient = class {
+  constructor(http, runner) {
+    this.http = http;
+    this.runner = runner;
+  }
+  http;
+  runner;
+  request(operation, model, signal, holdUntil) {
+    if (this.runner) {
+      return this.runner(
+        (http, runnerSignal) => operation(http, runnerSignal),
+        {
+          ...model !== void 0 ? { model } : {},
+          ...signal !== void 0 ? { signal } : {},
+          ...holdUntil !== void 0 ? { holdUntil } : {}
+        }
+      );
+    }
+    return operation(this.http, signal);
+  }
+  async createChatCompletion(request, signal) {
+    if (request.stream) {
+      return this.request(
+        (http, requestSignal) => http.requestSseStream({
+          path: "/v1/chat/completions",
+          body: request,
+          signal: requestSignal
+        }).then((source) => new OpenAIChatCompletionStream(source, requestSignal)),
+        request.model,
+        signal,
+        (stream) => stream.finalResult
+      );
+    }
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/chat/completions",
+        body: request,
+        signal: requestSignal
+      }),
+      request.model,
+      signal
+    );
+  }
+  async chatCompletions(request, signal) {
+    return this.createChatCompletion(request, signal);
+  }
+  async listModels(signal) {
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/models",
+        method: "GET",
+        signal: requestSignal
+      }),
+      void 0,
+      signal
+    );
+  }
+  async retrieveModel(model, signal) {
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: `/v1/models/${encodeURIComponent(model)}`,
+        method: "GET",
+        signal: requestSignal
+      }),
+      model,
+      signal
+    );
+  }
+  async getModel(model, signal) {
+    return this.retrieveModel(model, signal);
+  }
+  async createCompletion(request, signal) {
+    if (request.stream) {
+      return this.request(
+        (http, requestSignal) => http.requestSseStream({
+          path: "/v1/completions",
+          body: request,
+          signal: requestSignal
+        }).then((source) => new OpenAICompletionStream(source, requestSignal)),
+        request.model,
+        signal,
+        (stream) => stream.finalResult
+      );
+    }
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/completions",
+        body: request,
+        signal: requestSignal
+      }),
+      request.model,
+      signal
+    );
+  }
+  async completions(request, signal) {
+    return this.createCompletion(request, signal);
+  }
+  async createEmbedding(request, signal) {
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/embeddings",
+        body: request,
+        signal: requestSignal
+      }),
+      request.model,
+      signal
+    );
+  }
+  async embeddings(request, signal) {
+    return this.createEmbedding(request, signal);
+  }
+  async createResponses(request, signal) {
+    if (request.stream) {
+      return this.request(
+        (http, requestSignal) => http.requestSseStream({
+          path: "/v1/responses",
+          body: request,
+          signal: requestSignal
+        }).then((source) => new OpenAIResponsesStream(source, requestSignal)),
+        request.model,
+        signal,
+        (stream) => stream.finalResult
+      );
+    }
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/responses",
+        body: request,
+        signal: requestSignal
+      }),
+      request.model,
+      signal
+    );
+  }
+  async responses(request, signal) {
+    return this.createResponses(request, signal);
+  }
+};
+
+// src/integrations/anthropic.ts
+function isAnthropicKnownStreamEvent(event) {
+  switch (event.type) {
+    case "message_start":
+    case "content_block_start":
+    case "content_block_delta":
+    case "content_block_stop":
+    case "message_delta":
+    case "message_stop":
+    case "ping":
+    case "error":
+      return true;
+    default:
+      return false;
+  }
+}
+function parseAnthropicEvent(event) {
+  return JSON.parse(event.data);
+}
+function mergeContentBlock(current, delta) {
+  if (delta.type === "text_delta" && current.type === "text") {
+    return { ...current, text: current.text + delta.text };
+  }
+  if (delta.type === "input_json_delta" && current.type === "tool_use") {
+    return current;
+  }
+  if (delta.type === "thinking_delta" && current.type === "thinking") {
+    return { ...current, thinking: current.thinking + delta.thinking };
+  }
+  if (delta.type === "signature_delta" && current.type === "thinking") {
+    return { ...current, signature: (current.signature ?? "") + delta.signature };
+  }
+  return current;
+}
+function sanitizeAnthropicTextBlock(block) {
+  if (block.cache_control === void 0) return block;
+  const { cache_control: _cacheControl, ...sanitized } = block;
+  return sanitized;
+}
+function sanitizeAnthropicContentBlock(block) {
+  if (block.type === "text") {
+    return sanitizeAnthropicTextBlock(block);
+  }
+  if (block.type === "tool_result" && Array.isArray(block.content)) {
+    return {
+      ...block,
+      content: block.content.map(sanitizeAnthropicTextBlock)
+    };
+  }
+  return block;
+}
+function sanitizeAnthropicRequest(request) {
+  const messages = request.messages.map((message) => {
+    if (typeof message.content === "string") return message;
+    return {
+      ...message,
+      content: message.content.map(sanitizeAnthropicContentBlock)
+    };
+  });
+  const system = Array.isArray(request.system) ? request.system.map(sanitizeAnthropicTextBlock) : request.system;
+  const {
+    tool_choice: _toolChoice,
+    metadata: _metadata,
+    ...sanitized
+  } = request;
+  return {
+    ...sanitized,
+    messages,
+    ...system !== void 0 ? { system } : {}
+  };
+}
+var AnthropicMessagesStream = class {
+  constructor(source, signal) {
+    this.source = source;
+    this.finalResultPromise = new Promise((resolve, reject) => {
+      this.resolveFinal = resolve;
+      this.rejectFinal = reject;
+    });
+    if (signal !== void 0) {
+      const onAbort = () => this.abort();
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+      }
+    }
+  }
+  source;
+  finalResultPromise;
+  resolveFinal;
+  rejectFinal;
+  removeAbortListener;
+  get finalResult() {
+    return this.finalResultPromise;
+  }
+  abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
+    this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("Anthropic Messages stream aborted"));
+  }
+  async *[Symbol.asyncIterator]() {
+    let message;
+    const blocks = /* @__PURE__ */ new Map();
+    const toolInputJson = /* @__PURE__ */ new Map();
+    let completed = false;
+    try {
+      for await (const rawEvent of this.source) {
+        let event;
+        try {
+          event = parseAnthropicEvent(rawEvent);
+        } catch (error) {
+          throw new Error("Failed to parse Anthropic message SSE payload", { cause: error });
+        }
+        if (!isAnthropicKnownStreamEvent(event)) {
+          yield event;
+          continue;
+        }
+        if (event.type === "error") {
+          throw new Error(event.error.message);
+        }
+        if (event.type === "message_start") {
+          message = {
+            ...event.message,
+            content: [],
+            ...event.message.usage !== void 0 ? { usage: event.message.usage } : {}
+          };
+        } else if (event.type === "content_block_start") {
+          blocks.set(event.index, event.content_block);
+        } else if (event.type === "content_block_delta") {
+          const current = blocks.get(event.index);
+          if (event.delta.type === "input_json_delta") {
+            toolInputJson.set(event.index, (toolInputJson.get(event.index) ?? "") + event.delta.partial_json);
+          }
+          if (current) blocks.set(event.index, mergeContentBlock(current, event.delta));
+        } else if (event.type === "content_block_stop") {
+          const current = blocks.get(event.index);
+          if (current?.type === "tool_use") {
+            const rawJson = toolInputJson.get(event.index);
+            if (rawJson !== void 0 && rawJson !== "") {
+              try {
+                const parsed = JSON.parse(rawJson);
+                blocks.set(event.index, { ...current, input: parsed });
+              } catch {
+                blocks.set(event.index, current);
+              }
+            }
+          }
+        } else if (event.type === "message_delta") {
+          if (message) {
+            message = {
+              ...message,
+              stop_reason: event.delta.stop_reason !== void 0 && event.delta.stop_reason !== null ? event.delta.stop_reason : message.stop_reason,
+              stop_sequence: event.delta.stop_sequence ?? message.stop_sequence,
+              ...event.usage !== void 0 ? {
+                usage: {
+                  input_tokens: event.usage.input_tokens ?? message.usage?.input_tokens ?? 0,
+                  output_tokens: event.usage.output_tokens,
+                  ...event.usage.cache_creation_input_tokens !== void 0 ? { cache_creation_input_tokens: event.usage.cache_creation_input_tokens } : message.usage?.cache_creation_input_tokens !== void 0 ? { cache_creation_input_tokens: message.usage.cache_creation_input_tokens } : {},
+                  ...event.usage.cache_read_input_tokens !== void 0 ? { cache_read_input_tokens: event.usage.cache_read_input_tokens } : message.usage?.cache_read_input_tokens !== void 0 ? { cache_read_input_tokens: message.usage.cache_read_input_tokens } : {},
+                  ...event.usage.cache_creation !== void 0 ? { cache_creation: event.usage.cache_creation } : message.usage?.cache_creation !== void 0 ? { cache_creation: message.usage.cache_creation } : {}
+                }
+              } : {}
+            };
+          }
+        } else if (event.type === "message_stop" && message) {
+          message = {
+            ...message,
+            content: [...blocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => block)
+          };
+        }
+        yield event;
+      }
+      if (!message) {
+        throw new Error("Anthropic Messages stream ended without message_start");
+      }
+      const final = {
+        ...message,
+        content: [...blocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => block)
+      };
+      completed = true;
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.resolveFinal(final);
+    } catch (error) {
+      this.removeAbortListener?.();
+      this.removeAbortListener = void 0;
+      this.rejectFinal(error);
+      throw error;
+    } finally {
+      if (!completed) {
+        this.source.abort?.();
+        this.rejectFinal(new OllamaAbortError("Anthropic Messages stream ended before completion"));
+      }
+    }
+  }
+};
+var AnthropicCompatClient = class {
+  constructor(http, runner) {
+    this.http = http;
+    this.runner = runner;
+  }
+  http;
+  runner;
+  request(operation, model, signal, holdUntil) {
+    if (this.runner) {
+      return this.runner(
+        (http, runnerSignal) => operation(http, runnerSignal),
+        {
+          model,
+          ...signal !== void 0 ? { signal } : {},
+          ...holdUntil !== void 0 ? { holdUntil } : {}
+        }
+      );
+    }
+    return operation(this.http, signal);
+  }
+  async createMessage(request, signal) {
+    if (request.stream) {
+      return this.request(
+        (http, requestSignal) => http.requestSseStream({
+          path: "/v1/messages",
+          body: sanitizeAnthropicRequest(request),
+          headers: { "anthropic-version": "2023-06-01" },
+          signal: requestSignal
+        }).then((source) => new AnthropicMessagesStream(source, requestSignal)),
+        request.model,
+        signal,
+        (stream) => stream.finalResult
+      );
+    }
+    return this.request(
+      (http, requestSignal) => http.request({
+        path: "/v1/messages",
+        body: sanitizeAnthropicRequest(request),
+        headers: { "anthropic-version": "2023-06-01" },
+        signal: requestSignal
+      }),
+      request.model,
+      signal
+    );
   }
   async messages(request, signal) {
+    if (request.stream) {
+      return this.createMessage(request, signal);
+    }
     return this.createMessage(request, signal);
   }
 };
 
+// src/generated/runtime/runtime.ts
+function compareVersions(a, b) {
+  const pa = a.split(".").map((s) => Number.parseInt(s, 10) ?? 0);
+  const pb = b.split(".").map((s) => Number.parseInt(s, 10) ?? 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va !== vb) return va - vb;
+  }
+  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}).`
+    );
+  }
+}
+function shouldStream(req) {
+  if (req.body && typeof req.body === "object" && "stream" in req.body) {
+    const explicit = req.body.stream;
+    if (typeof explicit === "boolean") return explicit;
+  }
+  return Boolean(req.streamingDefault ?? req.operation.transport.streamingDefault);
+}
+function buildBody(req) {
+  if (req.body === void 0) return void 0;
+  if (typeof req.body !== "object" || req.body === null) return req.body;
+  const body = req.body;
+  if (req.operation.transport.streaming && req.operation.transport.streamingDefault && body.stream === void 0) {
+    return { ...body, stream: true };
+  }
+  return body;
+}
+var OllamaRuntime = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /**
+   * Invoke an operation. Called by every generated API method.
+   *
+   * Returns a `Promise<T>` for non-streaming operations, or an
+   * `AsyncGenerator<T>` for streaming operations. The generated API
+   * class's overloads pick the right return type at compile time.
+   */
+  async invoke(req) {
+    assertOperationAllowed(req.operation, this.options);
+    const body = buildBody(req);
+    const streaming = shouldStream(req);
+    const httpReq = {
+      path: req.operation.path,
+      method: req.operation.method,
+      ...body !== void 0 ? { body } : {},
+      ...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 } : {}
+    };
+    if (!streaming) {
+      return await this.options.http.request(httpReq);
+    }
+    const response = await this.options.http.request(httpReq);
+    if (!response.body) {
+      throw new OllamaGenericClientError(
+        `Operation ${req.operation.operationId}: streaming response had no body.`
+      );
+    }
+    return parseNdjsonStream(response.body);
+  }
+};
+
 // src/utils.ts
 async function encodeImage(image) {
   if (typeof image === "string") return image;
@@ -1218,6 +2735,11 @@ async function withEncodedMessageImages(messages) {
 }
 
 // src/client.ts
+var logicalRequestSequence = 0;
+function createLogicalRequestId() {
+  logicalRequestSequence += 1;
+  return `ollama-request-${logicalRequestSequence}`;
+}
 var OllamaClient = class {
   registry;
   models;
@@ -1226,27 +2748,88 @@ var OllamaClient = class {
   failoverCodes;
   fetchImpl;
   logger;
+  middleware;
+  onLifecycleEvent;
+  /**
+   * API key for Ollama's hosted web tools (`webSearch`/`webFetch`), which always target
+   * `OLLAMA_CLOUD_BASE_URL` regardless of `config.endpoints` — an Ollama account API key
+   * is inherently a single global credential, not tied to any one inference endpoint.
+   * Resolved the same way as a single-endpoint `apiKey` (`config.apiKey` falling back to
+   * `OLLAMA_API_KEY`), independent of whether `config.endpoints` was used instead.
+   */
+  cloudApiKey;
   constructor(config = {}) {
     const resolvedApiKey = resolveApiKey(config.apiKey);
-    const endpoints = config.endpoints ?? [
+    this.cloudApiKey = resolvedApiKey;
+    const credentialEndpoints = resolveCredentialEndpoints(config);
+    const endpoints = config.endpoints ?? (credentialEndpoints.length > 0 ? [] : [
       {
         name: "default",
         baseUrl: resolveBaseUrl(config.baseUrl),
         ...resolvedApiKey !== void 0 ? { apiKey: resolvedApiKey } : {},
         ...config.headers !== void 0 ? { headers: config.headers } : {}
       }
-    ];
-    this.registry = new EndpointRegistry(endpoints, config.endpointHealth);
+    ]);
+    this.registry = new EndpointRegistry(
+      [...endpoints, ...credentialEndpoints],
+      config.endpointHealth
+    );
     this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.failoverCodes = new Set(config.failoverOn ?? DEFAULT_FAILOVER_CODES);
     this.fetchImpl = config.fetch ?? globalThis.fetch;
     this.logger = config.logger ?? (config.debug ? createConsoleLogger() : NOOP_LOGGER);
+    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.models = new ModelsClient((op, opts) => this.executeWithFailover(op, opts));
   }
   get modelsClient() {
     return this.models;
   }
+  /**
+   * Return a generated {@link OllamaRuntime} that shares this client's
+   * transport (HttpClient + middleware + retry + telemetry).
+   *
+   * Wave 8 (ADR 0018) bridge: lets callers mix the existing `OllamaClient`
+   * 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);
+   * ```
+   *
+   * The runtime is cached on first call — subsequent calls return the
+   * same instance.
+   */
+  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 } : {},
+        fetch: this.fetchImpl,
+        ...this.middleware !== void 0 ? { middleware: this.middleware } : {},
+        ...this.onLifecycleEvent !== void 0 ? { onLifecycleEvent: this.onLifecycleEvent } : {}
+      });
+      this._runtime = new OllamaRuntime({
+        http,
+        localMode: inferRuntimeMode(baseUrl) === "local"
+      });
+    }
+    return this._runtime;
+  }
+  _runtime;
   /**
    * 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
@@ -1264,55 +2847,128 @@ var OllamaClient = class {
   }
   async executeWithFailover(operation, options) {
     const timeout = createTimeoutSignal(options?.timeoutMs ?? this.timeoutMs, options?.signal);
+    const requestId = createLogicalRequestId();
+    let deferTimeoutCancel = false;
     try {
-      const allCandidates = this.registry.candidates();
-      const candidates = options?.singleEndpoint ? allCandidates.slice(0, 1) : allCandidates;
       let lastError;
-      for (const [attemptIndex, endpoint] of candidates.entries()) {
-        this.logger.debug(`Executing on endpoint "${endpoint.name}" (${endpoint.baseUrl})`);
-        const http = new HttpClient({
-          baseUrl: endpoint.baseUrl,
-          ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
-          ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
-          fetch: this.fetchImpl
-        });
-        try {
-          const result = await withSpan(
-            "ollama.endpoint.attempt",
-            {
-              [ATTR_OLLAMA_ENDPOINT_NAME]: endpoint.name,
-              [ATTR_OLLAMA_ENDPOINT_ATTEMPT]: attemptIndex
-            },
-            () => withRetry(() => operation(http, timeout.signal), this.retryConfig)
+      for (; ; ) {
+        const allCandidates = this.registry.candidates(options?.model);
+        if (allCandidates.length === 0 && options?.model !== void 0 && this.registry.hasModelScopedEndpoints()) {
+          const configured = this.registry.list().flatMap((ep) => ep.models ?? []).filter((m, i, arr) => arr.indexOf(m) === i);
+          throw new OllamaModelRoutingError(
+            `No configured endpoint is authorized for model "${options.model}". ` + (configured.length > 0 ? `Endpoints are scoped to: ${configured.join(", ")}.` : "No endpoint declares a `models` allow-list that includes it.") + " Add or widen an `OllamaEndpoint.models` entry to route this model.",
+            { model: options.model, availableModels: configured }
           );
-          this.registry.reportSuccess(endpoint.name);
-          return result;
-        } catch (err) {
-          const error = err instanceof Error ? err : new Error(String(err));
-          lastError = error;
-          this.registry.reportFailure(endpoint.name);
-          this.logger.warn(`Failed on "${endpoint.name}": ${error.message}`);
-          if (!(error instanceof OllamaClientError && this.failoverCodes.has(error.code)))
-            throw error;
         }
+        const candidates = options?.singleEndpoint ? allCandidates.slice(0, 1) : allCandidates;
+        const runnable = this.registry.filterWithCapacity(candidates);
+        if (runnable.length === 0 && candidates.length > 0) {
+          await this.registry.waitForCapacity(
+            candidates.map((c) => c.name),
+            timeout.signal
+          );
+          continue;
+        }
+        for (const [attemptIndex, endpoint] of runnable.entries()) {
+          this.logger.debug(`Executing on endpoint "${endpoint.name}" (${endpoint.baseUrl})`);
+          const http = new HttpClient({
+            baseUrl: endpoint.baseUrl,
+            ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
+            ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
+            fetch: this.fetchImpl,
+            middleware: this.middleware,
+            onLifecycleEvent: this.onLifecycleEvent,
+            requestId
+          });
+          this.registry.acquire(endpoint.name);
+          let holdPromise;
+          try {
+            const result = await withSpan(
+              "ollama.endpoint.attempt",
+              {
+                [ATTR_OLLAMA_ENDPOINT_NAME]: endpoint.name,
+                [ATTR_OLLAMA_ENDPOINT_ATTEMPT]: attemptIndex
+              },
+              () => withRetry(
+                () => operation(http, timeout.signal),
+                {
+                  ...this.retryConfig,
+                  onRetry: (error, attempt, delayMs) => {
+                    this.retryConfig.onRetry?.(error, attempt, delayMs);
+                    this.onLifecycleEvent?.({
+                      type: "retry",
+                      requestId,
+                      attempt: attempt + 1,
+                      error,
+                      delayMs,
+                      timestamp: Date.now()
+                    });
+                  }
+                },
+                timeout.signal
+              )
+            );
+            this.registry.reportSuccess(endpoint.name);
+            if (options?.holdUntil) {
+              holdPromise = options.holdUntil(result);
+              deferTimeoutCancel = true;
+            }
+            return result;
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            lastError = error;
+            this.registry.reportFailure(endpoint.name);
+            this.logger.warn(`Failed on "${endpoint.name}": ${error.message}`);
+            if (!(error instanceof OllamaClientError && this.failoverCodes.has(error.code)))
+              throw error;
+          } finally {
+            if (holdPromise) {
+              void holdPromise.catch(() => void 0).finally(() => {
+                timeout.cancel();
+                this.registry.release(endpoint.name);
+              });
+            } else {
+              this.registry.release(endpoint.name);
+            }
+          }
+        }
+        throw lastError ?? new Error("No healthy Ollama endpoints available");
       }
-      throw lastError ?? new Error("No healthy Ollama endpoints available");
     } finally {
-      timeout.cancel();
+      if (!deferTimeoutCancel) timeout.cancel();
     }
   }
   async chat(req) {
-    const messages = await withEncodedMessageImages(req.messages);
+    const encodedMessages = await withEncodedMessageImages(req.messages);
+    const messages = encodedMessages.map((message) => {
+      if (message.role === "tool" && message.tool_call_id !== void 0) {
+        const { tool_call_id: _toolCallId, ...nativeMessage } = message;
+        return nativeMessage;
+      }
+      return message;
+    });
     if (req.stream) {
-      return this.executeWithFailover(async (http, signal) => {
-        if (req.format !== void 0) this.assertStructuredOutputSupported(http.baseUrl, req.model);
-        const stream = await http.requestStream({
-          path: "/api/chat",
-          body: { ...req, messages, stream: true },
-          signal
-        });
-        return normalizeChatStream(stream);
-      }, req);
+      return this.executeWithFailover(
+        async (http, signal) => {
+          if (req.format !== void 0)
+            this.assertStructuredOutputSupported(http.baseUrl, req.model);
+          const stream = await http.requestStream({
+            path: "/api/chat",
+            body: { ...req, messages, stream: true },
+            signal
+          });
+          return normalizeChatStream(stream, signal);
+        },
+        {
+          signal: req.signal,
+          timeoutMs: req.timeoutMs,
+          model: req.model,
+          // The endpoint's concurrency slot must stay held for as long as the stream is
+          // actually being consumed, not just until the initial response/headers arrive
+          // — see `executeWithFailover`'s `holdUntil` doc.
+          holdUntil: (stream) => stream.finalResult
+        }
+      );
     }
     return withSpan(
       `chat ${req.model}`,
@@ -1356,16 +3012,24 @@ var OllamaClient = class {
   async generate(req) {
     const encodedReq = await withEncodedImages(req);
     if (encodedReq.stream) {
-      return this.executeWithFailover(async (http, signal) => {
-        if (encodedReq.format !== void 0)
-          this.assertStructuredOutputSupported(http.baseUrl, encodedReq.model);
-        const stream = await http.requestStream({
-          path: "/api/generate",
-          body: { ...encodedReq, stream: true },
-          signal
-        });
-        return normalizeGenerateStream(stream);
-      }, encodedReq);
+      return this.executeWithFailover(
+        async (http, signal) => {
+          if (encodedReq.format !== void 0)
+            this.assertStructuredOutputSupported(http.baseUrl, encodedReq.model);
+          const stream = await http.requestStream({
+            path: "/api/generate",
+            body: { ...encodedReq, stream: true },
+            signal
+          });
+          return normalizeGenerateStream(stream, signal);
+        },
+        {
+          signal: encodedReq.signal,
+          timeoutMs: encodedReq.timeoutMs,
+          model: encodedReq.model,
+          holdUntil: (stream) => stream.finalResult
+        }
+      );
     }
     return withSpan(
       `text_completion ${encodedReq.model}`,
@@ -1439,30 +3103,97 @@ var OllamaClient = class {
   createBlob = (digest, data) => this.models.createBlob(digest, data);
   checkBlob = (digest) => this.models.checkBlob(digest);
   // --- Web Endpoints ---
-  webSearch(req) {
-    return this.executeWithFailover(
-      (http, signal) => http.request({ path: "/api/websearch", body: req, signal }),
+  /**
+   * Ollama's hosted web search tool (`POST https://ollama.com/api/web_search`) — a fixed
+   * Ollama Cloud service, unrelated to `config.endpoints`/`baseUrl` and not proxied
+   * through a local server. Requires an Ollama account API key: pass `apiKey` to the
+   * client constructor or set `OLLAMA_API_KEY`. Applies the same default `timeoutMs` and
+   * retry policy as inference calls, but never cross-endpoint-fails-over — there is only
+   * ever the one cloud endpoint to call.
+   */
+  async webSearch(req) {
+    const { count, max_results, ...rest } = req;
+    const res = await this.executeCloudRequest(
+      (http, signal) => http.request({
+        path: "/api/web_search",
+        body: { ...rest, max_results: max_results ?? count },
+        signal
+      }),
       req
     );
+    return { results: res.results.map((r) => ({ ...r, snippet: r.content })) };
   }
+  /**
+   * Ollama's hosted web fetch tool (`POST https://ollama.com/api/web_fetch`) — see
+   * {@link OllamaClient.webSearch} for the cloud-endpoint/auth/timeout/retry behavior,
+   * which applies identically here.
+   */
   webFetch(req) {
-    return this.executeWithFailover(
-      (http, signal) => http.request({ path: "/api/webfetch", body: req, signal }),
+    return this.executeCloudRequest(
+      (http, signal) => http.request({ path: "/api/web_fetch", body: req, 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
+   * multi-candidate loop, since `webSearch`/`webFetch` only ever have the one endpoint.
+   */
+  async executeCloudRequest(operation, options) {
+    const timeout = createTimeoutSignal(options.timeoutMs ?? this.timeoutMs, options.signal);
+    const requestId = createLogicalRequestId();
+    try {
+      const http = new HttpClient({
+        baseUrl: OLLAMA_CLOUD_BASE_URL,
+        apiKey: this.cloudApiKey,
+        fetch: this.fetchImpl,
+        middleware: this.middleware,
+        onLifecycleEvent: this.onLifecycleEvent,
+        requestId
+      });
+      return await withRetry(
+        () => operation(http, timeout.signal),
+        {
+          ...this.retryConfig,
+          onRetry: (error, attempt, delayMs) => {
+            this.retryConfig.onRetry?.(error, attempt, delayMs);
+            this.onLifecycleEvent?.({
+              type: "retry",
+              requestId,
+              attempt: attempt + 1,
+              error,
+              delayMs,
+              timestamp: Date.now()
+            });
+          }
+        },
+        timeout.signal
+      );
+    } finally {
+      timeout.cancel();
+    }
+  }
   // --- Capabilities & Health ---
-  capabilities(model) {
-    return this.executeWithFailover((http) => detectModelCapabilities(http, model), {
-      singleEndpoint: true
-    });
+  capabilities(model, signal) {
+    return this.executeWithFailover(
+      (http, runnerSignal) => detectModelCapabilities(http, model, runnerSignal),
+      {
+        singleEndpoint: true,
+        model,
+        ...signal !== void 0 ? { signal } : {}
+      }
+    );
   }
   runtimeMode() {
     const ep = this.registry.candidates()[0];
     return inferRuntimeMode(ep?.baseUrl ?? DEFAULT_BASE_URL);
   }
   healthCheck() {
-    return Promise.all(this.registry.list().map((ep) => checkEndpointHealth(ep, this.fetchImpl)));
+    return Promise.all(
+      this.registry.list().map(
+        (ep) => checkEndpointHealth(ep, this.fetchImpl, 5e3, this.middleware, this.onLifecycleEvent)
+      )
+    );
   }
   endpointStatus() {
     return this.registry.status();
@@ -1475,8 +3206,11 @@ var OllamaClient = class {
         baseUrl: ep?.baseUrl ?? DEFAULT_BASE_URL,
         apiKey: ep?.apiKey,
         headers: ep?.headers,
-        fetch: this.fetchImpl
-      })
+        fetch: this.fetchImpl,
+        middleware: this.middleware,
+        onLifecycleEvent: this.onLifecycleEvent
+      }),
+      (op, opts) => this.executeWithFailover(op, opts)
     );
   }
   get anthropic() {
@@ -1486,34 +3220,15 @@ var OllamaClient = class {
         baseUrl: ep?.baseUrl ?? DEFAULT_BASE_URL,
         apiKey: ep?.apiKey,
         headers: ep?.headers,
-        fetch: this.fetchImpl
-      })
+        fetch: this.fetchImpl,
+        middleware: this.middleware,
+        onLifecycleEvent: this.onLifecycleEvent
+      }),
+      (op, opts) => this.executeWithFailover(op, opts)
     );
   }
 };
 
-// src/middleware.ts
-function composeMiddleware(middlewares, finalHandler) {
-  return function runPipeline(initialRequest) {
-    let index = -1;
-    function dispatch(i, currentRequest) {
-      if (i <= index) {
-        return Promise.reject(new Error("next() called multiple times in middleware"));
-      }
-      index = i;
-      const fn = middlewares[i];
-      if (i === middlewares.length || !fn) {
-        return finalHandler(currentRequest);
-      }
-      return fn({
-        request: currentRequest,
-        next: () => dispatch(i + 1, currentRequest)
-      });
-    }
-    return dispatch(0, initialRequest);
-  };
-}
-
 // src/streaming/adapters.ts
 function toTextStream(stream) {
   const iterator = stream[Symbol.asyncIterator]();
@@ -1572,6 +3287,117 @@ function toResponse(stream, init = {}) {
   return new Response(body, { ...init, headers });
 }
 
+// src/quota.ts
+var QuotaManager = class {
+  now;
+  windows;
+  constructor(options) {
+    if (options.windows.length === 0) {
+      throw new Error("QuotaManager requires at least one window configuration.");
+    }
+    this.now = options.now ?? Date.now;
+    this.windows = options.windows.map((config) => ({
+      config,
+      tokensUsed: 0,
+      requestsMade: 0,
+      windowStartedAt: this.now()
+    }));
+  }
+  rollover(state) {
+    if (this.now() - state.windowStartedAt >= state.config.windowMs) {
+      state.tokensUsed = 0;
+      state.requestsMade = 0;
+      state.windowStartedAt = this.now();
+    }
+  }
+  /** Current usage, budgets, and reset time for every configured window. */
+  status() {
+    return this.windows.map((state) => {
+      this.rollover(state);
+      const { config } = state;
+      return {
+        ...config,
+        tokensUsed: state.tokensUsed,
+        requestsMade: state.requestsMade,
+        windowStartedAt: state.windowStartedAt,
+        windowResetAt: state.windowStartedAt + config.windowMs,
+        ...config.maxTokens !== void 0 ? { remainingTokens: Math.max(0, config.maxTokens - state.tokensUsed) } : {},
+        ...config.maxRequests !== void 0 ? { remainingRequests: Math.max(0, config.maxRequests - state.requestsMade) } : {}
+      };
+    });
+  }
+  /**
+   * True if one more request — optionally estimated at `estimatedTokens` — would stay
+   * within every configured window's budget. Read-only; does not record usage.
+   */
+  canProceed(estimatedTokens = 0) {
+    return this.windows.every((state) => {
+      this.rollover(state);
+      const { config } = state;
+      if (config.maxRequests !== void 0 && state.requestsMade + 1 > config.maxRequests) {
+        return false;
+      }
+      return !(config.maxTokens !== void 0 && state.tokensUsed + estimatedTokens > config.maxTokens);
+    });
+  }
+  /**
+   * Throws `OllamaQuotaExceededError` for the first window that `canProceed(estimatedTokens)`
+   * would fail on; otherwise a no-op. Call before issuing a request.
+   */
+  assertCanProceed(estimatedTokens = 0) {
+    for (const state of this.windows) {
+      this.rollover(state);
+      const { config } = state;
+      if (config.maxRequests !== void 0 && state.requestsMade + 1 > config.maxRequests) {
+        throw new OllamaQuotaExceededError(
+          `Client-side quota window "${config.id}" would exceed its request budget (${state.requestsMade}/${config.maxRequests} requests used).`,
+          { windowId: config.id, resetAt: state.windowStartedAt + config.windowMs }
+        );
+      }
+      if (config.maxTokens !== void 0 && state.tokensUsed + estimatedTokens > config.maxTokens) {
+        throw new OllamaQuotaExceededError(
+          `Client-side quota window "${config.id}" would exceed its token budget (${state.tokensUsed}/${config.maxTokens} tokens used).`,
+          { windowId: config.id, resetAt: state.windowStartedAt + config.windowMs }
+        );
+      }
+    }
+  }
+  /** Records one request's actual usage — a raw API response or a pre-normalized `TokenUsage` — against every window. */
+  recordUsage(usage) {
+    const normalized = "totalTokens" in usage ? usage : extractUsage(usage);
+    for (const state of this.windows) {
+      this.rollover(state);
+      state.tokensUsed += normalized.totalTokens;
+      state.requestsMade += 1;
+    }
+  }
+  /** Resets one window (by `id`) or, if omitted, all windows — zeroing usage and restarting their clocks. */
+  reset(windowId) {
+    for (const state of this.windows) {
+      if (windowId === void 0 || state.config.id === windowId) {
+        state.tokensUsed = 0;
+        state.requestsMade = 0;
+        state.windowStartedAt = this.now();
+      }
+    }
+  }
+};
+function createOllamaCloudFreeTierQuota(budgets) {
+  const windows = [];
+  if (budgets.session !== void 0) {
+    windows.push({ id: "session", windowMs: 5 * 60 * 60 * 1e3, ...budgets.session });
+  }
+  if (budgets.weekly !== void 0) {
+    windows.push({ id: "weekly", windowMs: 7 * 24 * 60 * 60 * 1e3, ...budgets.weekly });
+  }
+  if (windows.length === 0) {
+    throw new Error(
+      "createOllamaCloudFreeTierQuota requires at least a `session` or `weekly` budget."
+    );
+  }
+  return new QuotaManager({ windows, ...budgets.now !== void 0 ? { now: budgets.now } : {} });
+}
+
 // src/tools/define-tool.ts
 function defineTool(options) {
   const jsonSchema = zodToJsonSchema(options.schema);
@@ -1766,28 +3592,234 @@ var ToolRegistry = class {
     };
   }
 };
-function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "") {
+
+// src/mcp/json-schema.ts
+function label(path) {
+  return path.length === 0 ? "value" : "value" + path.map((part) => typeof part === "number" ? "[" + part + "]" : "." + part).join("");
+}
+function equalJson(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, i) => equalJson(item, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ar = a;
+    const br = b;
+    const ak = Object.keys(ar).sort();
+    const bk = Object.keys(br).sort();
+    return ak.length === bk.length && ak.every((key, i) => key === bk[i] && equalJson(ar[key], br[key]));
+  }
+  return false;
+}
+function matchesType(value, type) {
+  switch (type) {
+    case "null":
+      return value === null;
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    default:
+      return true;
+  }
+}
+function validate(value, schema, path) {
+  if (schema === true || schema === void 0) return [];
+  if (schema === false) return [{ path, message: label(path) + " is not allowed by the schema" }];
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) return [];
+  const s = schema;
+  const issues = [];
+  if (s["nullable"] === true && value === null) return issues;
+  const type = s["type"];
+  if (typeof type === "string" && !matchesType(value, type)) {
+    return [{ path, message: label(path) + " must be " + type }];
+  }
+  if (Array.isArray(type) && !type.some((t) => typeof t === "string" && matchesType(value, t))) {
+    return [{ path, message: label(path) + " must match one of: " + type.join(", ") }];
+  }
+  if ("const" in s && !equalJson(value, s["const"])) issues.push({ path, message: label(path) + " must equal the schema const value" });
+  const enumValues = s["enum"];
+  if (Array.isArray(enumValues) && !enumValues.some((item) => equalJson(value, item))) issues.push({ path, message: label(path) + " must be one of the allowed enum values" });
+  const anyOf = s["anyOf"];
+  if (Array.isArray(anyOf) && !anyOf.some((candidate) => validate(value, candidate, path).length === 0)) issues.push({ path, message: label(path) + " must satisfy at least one anyOf schema" });
+  const oneOf = s["oneOf"];
+  if (Array.isArray(oneOf)) {
+    const matches = oneOf.filter((candidate) => validate(value, candidate, path).length === 0).length;
+    if (matches !== 1) issues.push({ path, message: label(path) + " must satisfy exactly one oneOf schema" });
+  }
+  const allOf = s["allOf"];
+  if (Array.isArray(allOf)) for (const candidate of allOf) issues.push(...validate(value, candidate, path));
+  if ("not" in s && validate(value, s["not"], path).length === 0) issues.push({ path, message: label(path) + " must not satisfy the not schema" });
+  if (typeof value === "string") {
+    const min = s["minLength"];
+    const max = s["maxLength"];
+    if (typeof min === "number" && value.length < min) issues.push({ path, message: label(path) + " must have at least " + min + " characters" });
+    if (typeof max === "number" && value.length > max) issues.push({ path, message: label(path) + " must have at most " + max + " characters" });
+    if (typeof s["pattern"] === "string") {
+      try {
+        if (!new RegExp(s["pattern"]).test(value)) issues.push({ path, message: label(path) + " does not match the required pattern" });
+      } catch {
+      }
+    }
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const numericRules = [
+      ["minimum", (n, b) => n >= b, "must be greater than or equal to"],
+      ["maximum", (n, b) => n <= b, "must be less than or equal to"],
+      ["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) {
+      const bound = s[keyword];
+      if (typeof bound === "number" && !check(value, bound)) issues.push({ path, message: label(path) + " " + phrase + " " + bound });
+    }
+    const multipleOf = s["multipleOf"];
+    if (typeof multipleOf === "number" && multipleOf > 0) {
+      const quotient = value / multipleOf;
+      if (Math.abs(quotient - Math.round(quotient)) > 1e-12) issues.push({ path, message: label(path) + " must be a multiple of " + multipleOf });
+    }
+  }
+  if (Array.isArray(value)) {
+    const min = s["minItems"];
+    const max = s["maxItems"];
+    if (typeof min === "number" && value.length < min) issues.push({ path, message: label(path) + " must contain at least " + min + " items" });
+    if (typeof max === "number" && value.length > max) issues.push({ path, message: label(path) + " must contain at most " + max + " items" });
+    if (s["uniqueItems"] === true) {
+      for (let i = 0; i < value.length; i += 1) if (value.slice(0, i).some((previous) => equalJson(previous, value[i]))) {
+        issues.push({ path: [...path, i], message: label([...path, i]) + " must be unique" });
+        break;
+      }
+    }
+    if ("items" in s) value.forEach((item, i) => issues.push(...validate(item, s["items"], [...path, i])));
+    if (Array.isArray(s["prefixItems"])) s["prefixItems"].forEach((itemSchema, i) => {
+      if (i < value.length) issues.push(...validate(value[i], itemSchema, [...path, i]));
+    });
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const object = value;
+    const required = s["required"];
+    if (Array.isArray(required)) {
+      for (const key of required) if (typeof key === "string" && !(key in object)) issues.push({ path: [...path, key], message: label([...path, key]) + " is required" });
+    }
+    const properties = s["properties"];
+    if (typeof properties === "object" && properties !== null && !Array.isArray(properties)) {
+      const propertySchemas = properties;
+      for (const [key, propertySchema] of Object.entries(propertySchemas)) if (key in object) issues.push(...validate(object[key], propertySchema, [...path, key]));
+      const additional = s["additionalProperties"];
+      for (const key of Object.keys(object)) {
+        if (key in propertySchemas) continue;
+        if (additional === false) issues.push({ path: [...path, key], message: label([...path, key]) + " is not allowed" });
+        else if (additional !== true && additional !== void 0) issues.push(...validate(object[key], additional, [...path, key]));
+      }
+    }
+    const min = s["minProperties"];
+    const max = s["maxProperties"];
+    if (typeof min === "number" && Object.keys(object).length < min) issues.push({ path, message: label(path) + " must contain at least " + min + " properties" });
+    if (typeof max === "number" && Object.keys(object).length > max) issues.push({ path, message: label(path) + " must contain at most " + max + " properties" });
+  }
+  return issues;
+}
+function validateJsonSchema(value, schema) {
+  return validate(value, schema, []);
+}
+
+// src/mcp/mcp-tools.ts
+function resolveMaxPages(options) {
+  const maxPages = options.maxPages ?? 64;
+  if (!Number.isInteger(maxPages) || maxPages <= 0) {
+    throw new RangeError("MCP maxPages must be a positive integer");
+  }
+  return maxPages;
+}
+async function listAllMcpTools(mcpClient, options = {}, signal) {
+  const maxPages = resolveMaxPages(options);
+  const tools = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (let pageNumber = 1; pageNumber <= maxPages; pageNumber += 1) {
+    const params = cursor !== void 0 ? { cursor } : void 0;
+    const requestOptions = signal !== void 0 ? { signal } : void 0;
+    const page = await mcpClient.listTools(params, requestOptions);
+    tools.push(...page.tools);
+    if (page.nextCursor === void 0) {
+      return tools;
+    }
+    if (seenCursors.has(page.nextCursor)) {
+      throw new Error("MCP tools/list returned a repeated nextCursor");
+    }
+    seenCursors.add(page.nextCursor);
+    cursor = page.nextCursor;
+  }
+  throw new Error("MCP tools/list exceeded maxPages (" + maxPages + ")");
+}
+function formatMcpToolResult(result) {
+  const parts = result.content.map((block) => {
+    if (block.type === "text" && typeof block.text === "string") {
+      return block.text;
+    }
+    try {
+      return JSON.stringify(block);
+    } catch {
+      return `[${block.type}]`;
+    }
+  });
+  if (result.structuredContent !== void 0) {
+    try {
+      parts.push(JSON.stringify(result.structuredContent));
+    } catch {
+    }
+  }
+  if (result.isError) {
+    parts.unshift("[MCP tool error]");
+  }
+  return parts.join("\n");
+}
+function createInputValidator(inputSchema) {
+  return zod.z.custom().superRefine((value, ctx) => {
+    const issues = validateJsonSchema(value, inputSchema);
+    for (const issue of issues) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        path: [...issue.path],
+        message: issue.message
+      });
+    }
+  });
+}
+function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "", resultMode = "text") {
   const toolName = `${namePrefix}${descriptor.name}`;
-  const inputSchema = descriptor.inputSchema ?? { properties: {} };
+  const inputSchema = descriptor.inputSchema ?? { type: "object", properties: {} };
   const properties = inputSchema["properties"] ?? {};
   const required = inputSchema["required"] ?? [];
+  const parameters = {
+    ...inputSchema,
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
   return {
     name: toolName,
     description: descriptor.description ?? "",
-    schema: zod.z.record(zod.z.string(), zod.z.unknown()),
-    execute: async (args) => {
+    schema: createInputValidator(inputSchema),
+    execute: async (args, context) => {
       try {
-        const result = await mcpClient.callTool({
-          name: descriptor.name,
-          arguments: args
-        });
-        if (result.isError) {
-          throw new OllamaMcpError(`MCP tool "${descriptor.name}" returned error`, {
-            mcpMethod: "callTool",
-            toolName: descriptor.name
-          });
-        }
-        return result.content.map((b) => b.type === "text" && b.text ? b.text : `[${b.type}]`).join("\n");
+        const result = await mcpClient.callTool(
+          {
+            name: descriptor.name,
+            arguments: args
+          },
+          context.signal !== void 0 ? { signal: context.signal } : void 0
+        );
+        return resultMode === "structured" ? result : formatMcpToolResult(result);
       } catch (err) {
         if (err instanceof OllamaMcpError) throw err;
         throw new OllamaMcpError(`Failed calling MCP tool "${descriptor.name}"`, {
@@ -1802,19 +3834,15 @@ function convertMcpDescriptorToTool(descriptor, mcpClient, namePrefix = "") {
       function: {
         name: toolName,
         description: descriptor.description ?? "",
-        parameters: {
-          type: "object",
-          properties,
-          ...required.length > 0 ? { required } : {}
-        }
+        parameters
       }
     }
   };
 }
-async function loadMcpTools(mcpClient, options = {}) {
+async function loadMcpTools(mcpClient, options = {}, signal) {
   try {
-    const { tools } = await mcpClient.listTools();
-    return tools.map((t) => convertMcpDescriptorToTool(t, mcpClient, options.namePrefix));
+    const tools = await listAllMcpTools(mcpClient, options, signal);
+    return tools.map((t) => convertMcpDescriptorToTool(t, mcpClient, options.namePrefix, options.resultMode));
   } catch (err) {
     throw new OllamaMcpError("Failed listing MCP tools from client", {
       mcpMethod: "listTools",
@@ -1822,11 +3850,48 @@ async function loadMcpTools(mcpClient, options = {}) {
     });
   }
 }
-async function registerMcpTools(registry, mcpClient, options = {}) {
-  const tools = await loadMcpTools(mcpClient, options);
+async function registerMcpTools(registry, mcpClient, options = {}, signal) {
+  const tools = await loadMcpTools(mcpClient, options, signal);
   registry.registerMany(tools);
 }
 
+// src/mcp/bridge.ts
+var McpBridge = class _McpBridge {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  client;
+  options;
+  static toOllamaTools(tools, options = {}) {
+    const prefix = options.namePrefix ?? "";
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: prefix + tool.name,
+        description: tool.description ?? "",
+        parameters: {
+          ...tool.inputSchema ?? { type: "object", properties: {} },
+          type: "object",
+          properties: (tool.inputSchema ?? {})["properties"] ?? {}
+        }
+      }
+    }));
+  }
+  async listTools(signal) {
+    return listAllMcpTools(this.client, this.options, signal);
+  }
+  async definitions(signal) {
+    return _McpBridge.toOllamaTools(await this.listTools(signal), this.options);
+  }
+  async loadTools(signal) {
+    return loadMcpTools(this.client, this.options, signal);
+  }
+  async register(registry, signal) {
+    await registry.registerMany(await this.loadTools(signal));
+  }
+};
+
 // src/skills/frontmatter.ts
 function parseYamlValue(raw) {
   const trimmed = raw.trim();
@@ -1928,12 +3993,24 @@ var Agent = class {
   client;
   tools;
   maxIterations;
+  maxToolCalls;
   hooks;
+  validateToolCapability;
+  toolContextSize;
   constructor(client, config = {}) {
     this.client = client;
     this.tools = config.tools;
     this.maxIterations = config.maxIterations ?? 10;
+    this.maxToolCalls = config.maxToolCalls;
     this.hooks = config.hooks;
+    if (this.maxToolCalls !== void 0 && (!Number.isInteger(this.maxToolCalls) || this.maxToolCalls < 0)) {
+      throw new RangeError("Agent maxToolCalls must be a non-negative integer");
+    }
+    this.validateToolCapability = config.validateToolCapability ?? true;
+    this.toolContextSize = config.toolContextSize ?? 32768;
+    if (!Number.isInteger(this.toolContextSize) || this.toolContextSize <= 0) {
+      throw new RangeError("Agent toolContextSize must be a positive integer");
+    }
   }
   run(input) {
     return withSpan(
@@ -1951,6 +4028,30 @@ var Agent = class {
     const history = [...input.messages];
     const turns = [];
     const toolDefs = this.tools?.definitions();
+    const hasTools = toolDefs !== void 0 && toolDefs.length > 0;
+    let capabilities;
+    if (hasTools && this.validateToolCapability && this.client.capabilities) {
+      capabilities = await this.client.capabilities(input.model, input.signal);
+      if (!capabilities.supportsTools) {
+        throw new OllamaIncompatibleModelError(
+          `Model "${input.model}" does not advertise the "tools" capability.`,
+          {
+            model: input.model,
+            capability: "tools",
+            reportedCapabilities: capabilities.reported
+          }
+        );
+      }
+    }
+    const shouldAutoSizeContext = hasTools && this.validateToolCapability && capabilities !== void 0 && input.options?.num_ctx === void 0;
+    const effectiveOptions = shouldAutoSizeContext ? {
+      ...input.options ?? {},
+      num_ctx: Math.min(
+        this.toolContextSize,
+        capabilities?.contextLength ?? this.toolContextSize
+      )
+    } : input.options;
+    let toolCallsExecuted = 0;
     for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
       const outcome = await withSpan(
         "ollama.agent.turn",
@@ -1961,7 +4062,7 @@ var Agent = class {
             model: input.model,
             messages: history,
             ...toolDefs !== void 0 ? { tools: toolDefs } : {},
-            ...input.options !== void 0 ? { options: input.options } : {},
+            ...effectiveOptions !== void 0 ? { options: effectiveOptions } : {},
             ...input.think !== void 0 ? { think: input.think } : {},
             stream: false,
             ...input.signal !== void 0 ? { signal: input.signal } : {}
@@ -1976,17 +4077,24 @@ var Agent = class {
             this.hooks?.onTurnEnd?.(finalTurn);
             return { done: true, finalMessage: assistantMessage };
           }
+          if (this.maxToolCalls !== void 0 && toolCallsExecuted + toolCalls.length > this.maxToolCalls) {
+            throw new OllamaAgentMaxToolCallsError(
+              `Agent exceeded max tool calls (${this.maxToolCalls})`,
+              { maxToolCalls: this.maxToolCalls, toolCallsExecuted }
+            );
+          }
           for (const tc of toolCalls) {
             this.hooks?.onToolCallStart?.(tc);
           }
           const toolResults = await this.tools.executeToolCalls(toolCalls, {
             signal: input.signal
           });
+          toolCallsExecuted += toolCalls.length;
           for (const res of toolResults) {
             this.hooks?.onToolCallEnd?.(res);
             history.push({
               role: "tool",
-              ...res.toolCallId !== void 0 ? { tool_call_id: res.toolCallId } : {},
+              tool_name: res.toolName,
               content: res.outputString
             });
           }
@@ -2026,6 +4134,7 @@ exports.ATTR_SERVER_PORT = ATTR_SERVER_PORT;
 exports.ATTR_URL_FULL = ATTR_URL_FULL;
 exports.Agent = Agent;
 exports.AnthropicCompatClient = AnthropicCompatClient;
+exports.AnthropicMessagesStream = AnthropicMessagesStream;
 exports.DEFAULT_BACKOFF = DEFAULT_BACKOFF;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
 exports.DEFAULT_FAILOVER_CODES = DEFAULT_FAILOVER_CODES;
@@ -2034,19 +4143,25 @@ exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
 exports.EndpointRegistry = EndpointRegistry;
 exports.GEN_AI_SYSTEM_OLLAMA = GEN_AI_SYSTEM_OLLAMA;
 exports.HttpClient = HttpClient;
+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.OllamaAbortError = OllamaAbortError;
 exports.OllamaAgentMaxIterationsError = OllamaAgentMaxIterationsError;
+exports.OllamaAgentMaxToolCallsError = OllamaAgentMaxToolCallsError;
 exports.OllamaAuthError = OllamaAuthError;
 exports.OllamaClient = OllamaClient;
 exports.OllamaClientError = OllamaClientError;
 exports.OllamaGenericClientError = OllamaGenericClientError;
+exports.OllamaIncompatibleModelError = OllamaIncompatibleModelError;
 exports.OllamaMcpError = OllamaMcpError;
+exports.OllamaModelRoutingError = OllamaModelRoutingError;
 exports.OllamaNetworkError = OllamaNetworkError;
 exports.OllamaNotFoundError = OllamaNotFoundError;
+exports.OllamaQuotaExceededError = OllamaQuotaExceededError;
 exports.OllamaRateLimitError = OllamaRateLimitError;
 exports.OllamaServerError = OllamaServerError;
 exports.OllamaSkillInvalidError = OllamaSkillInvalidError;
@@ -2056,7 +4171,12 @@ exports.OllamaTimeoutError = OllamaTimeoutError;
 exports.OllamaToolTimeoutError = OllamaToolTimeoutError;
 exports.OllamaToolValidationError = OllamaToolValidationError;
 exports.OllamaUnsupportedCapabilityError = OllamaUnsupportedCapabilityError;
+exports.OpenAIChatCompletionStream = OpenAIChatCompletionStream;
 exports.OpenAICompatClient = OpenAICompatClient;
+exports.OpenAICompletionStream = OpenAICompletionStream;
+exports.OpenAIResponsesStream = OpenAIResponsesStream;
+exports.OpenAIResponsesStreamError = OpenAIResponsesStreamError;
+exports.QuotaManager = QuotaManager;
 exports.ToolRegistry = ToolRegistry;
 exports.addSpanEvent = addSpanEvent;
 exports.applySkill = applySkill;
@@ -2064,12 +4184,14 @@ exports.calculateBackoff = calculateBackoff;
 exports.checkEndpointHealth = checkEndpointHealth;
 exports.composeMiddleware = composeMiddleware;
 exports.createConsoleLogger = createConsoleLogger;
+exports.createOllamaCloudFreeTierQuota = createOllamaCloudFreeTierQuota;
 exports.createTimeoutSignal = createTimeoutSignal;
 exports.defineTool = defineTool;
 exports.detectModelCapabilities = detectModelCapabilities;
 exports.encodeImage = encodeImage;
 exports.extractUsage = extractUsage;
 exports.inferRuntimeMode = inferRuntimeMode;
+exports.listAllMcpTools = listAllMcpTools;
 exports.listAvailableModels = listAvailableModels;
 exports.loadMcpTools = loadMcpTools;
 exports.mapError = mapError;
@@ -2078,8 +4200,10 @@ exports.normalizeGenerateStream = normalizeGenerateStream;
 exports.normalizeProgressStream = normalizeProgressStream;
 exports.parseFrontmatter = parseFrontmatter;
 exports.parseNdjsonStream = parseNdjsonStream;
+exports.parseSseStream = parseSseStream;
 exports.parseStructuredOutput = parseStructuredOutput;
 exports.registerMcpTools = registerMcpTools;
+exports.resolveCredentialEndpoints = resolveCredentialEndpoints;
 exports.setSpanError = setSpanError;
 exports.toDataStream = toDataStream;
 exports.toResponse = toResponse;