@nemesis-oss/ollama-sdk 1.3.0 → 1.4.1

package/dist/index.cjs

@@ -2,6 +2,52 @@
 
 var zod = require('zod');
 
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
 // src/config.ts
 var DEFAULT_BASE_URL = "http://localhost:11434";
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -154,6 +200,26 @@ var OllamaModelRoutingError = class extends OllamaClientError {
     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) {
@@ -452,12 +518,87 @@ var EndpointRegistry = class {
   }
 };
 
+// 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/utils.ts
+async function encodeImage(image) {
+  if (typeof image === "string") return image;
+  const bufferCtor = globalThis.Buffer;
+  if (bufferCtor !== void 0) return bufferCtor.from(image).toString("base64");
+  const CHUNK_SIZE = 32768;
+  let binary = "";
+  for (let i = 0; i < image.length; i += CHUNK_SIZE) {
+    binary += String.fromCharCode(...image.subarray(i, i + CHUNK_SIZE));
+  }
+  return btoa(binary);
+}
+async function encodeImages(images) {
+  if (images === void 0) return void 0;
+  return Promise.all(images.map((image) => encodeImage(image)));
+}
+async function withEncodedImages(req) {
+  if (!req.images?.some((image) => image instanceof Uint8Array)) return req;
+  return { ...req, images: await encodeImages(req.images) };
+}
+async function withEncodedMessageImages(messages) {
+  if (!messages.some((message) => message.images?.some((image) => image instanceof Uint8Array)))
+    return messages;
+  return Promise.all(messages.map((message) => withEncodedImages(message)));
+}
+function disposableTimer(timer) {
+  return {
+    [Symbol.dispose]() {
+      clearTimeout(timer);
+    }
+  };
+}
+function disposableReader(reader) {
+  return {
+    async [Symbol.asyncDispose]() {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      reader.releaseLock();
+    }
+  };
+}
+function disposableSpan(span) {
+  return {
+    [Symbol.dispose]() {
+      span.end();
+    }
+  };
+}
+
 // src/streaming/ndjson.ts
 async function* parseNdjsonStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+  var _stack = [];
   try {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const _reader = __using(_stack, disposableReader(reader), true);
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -479,8 +620,103 @@ async function* parseNdjsonStream(stream) {
     if (buffer.trim()) {
       yield JSON.parse(buffer.trim());
     }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
+  }
+}
+
+// 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) {
+  var _stack = [];
+  try {
+    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;
+        }
+        default:
+          break;
+      }
+      return void 0;
+    };
+    const _reader = __using(_stack, disposableReader(reader), true);
+    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;
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    reader.releaseLock();
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
   }
 }
 
@@ -508,16 +744,22 @@ async function withSpan(name, attributes, fn) {
   }
   const tracer = api.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
   return tracer.startActiveSpan(name, async (span) => {
-    span.setAttributes(cleanAttributes(attributes));
+    var _stack = [];
     try {
-      return await fn(span);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      span.recordException(error);
-      span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
-      throw error;
+      span.setAttributes(cleanAttributes(attributes));
+      const _span = __using(_stack, disposableSpan(span));
+      try {
+        return await fn(span);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        span.recordException(error);
+        span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
+        throw error;
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      span.end();
+      __callDispose(_stack, _error, _hasError);
     }
   });
 }
@@ -564,16 +806,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 = {
@@ -586,6 +848,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");
@@ -599,13 +986,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;
@@ -623,6 +1010,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;
@@ -637,6 +1027,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";
@@ -646,15 +1109,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 },
@@ -662,6 +1137,7 @@ var HttpClient = class {
             });
           }
           if (!response.body) {
+            removeAbortListener?.();
             throw mapError(new Error("Response body is null, cannot stream"), {
               request: { method, url }
             });
@@ -669,7 +1145,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;
@@ -682,41 +1168,49 @@ var HttpClient = class {
 };
 
 // src/providers/health-check.ts
-async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3) {
-  const client = new HttpClient({
-    baseUrl: endpoint.baseUrl,
-    apiKey: endpoint.apiKey,
-    headers: endpoint.headers,
-    fetch: fetchImpl
-  });
-  const startTime = Date.now();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3, middleware, onLifecycleEvent) {
+  var _stack = [];
   try {
-    const res = await client.request({
-      path: "/api/version",
-      method: "GET",
-      signal: controller.signal
-    });
-    const latencyMs = Date.now() - startTime;
-    return {
-      name: endpoint.name,
+    const client = new HttpClient({
       baseUrl: endpoint.baseUrl,
-      reachable: true,
-      latencyMs,
-      version: res.version
-    };
-  } catch (err) {
-    const latencyMs = Date.now() - startTime;
-    return {
-      name: endpoint.name,
-      baseUrl: endpoint.baseUrl,
-      reachable: false,
-      latencyMs,
-      error: err instanceof Error ? err.message : String(err)
-    };
+      apiKey: endpoint.apiKey,
+      headers: endpoint.headers,
+      fetch: fetchImpl,
+      middleware,
+      onLifecycleEvent
+    });
+    const startTime = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const _timer = __using(_stack, disposableTimer(timer));
+    try {
+      const res = await client.request({
+        path: "/api/version",
+        method: "GET",
+        signal: controller.signal
+      });
+      const latencyMs = Date.now() - startTime;
+      return {
+        name: endpoint.name,
+        baseUrl: endpoint.baseUrl,
+        reachable: true,
+        latencyMs,
+        version: res.version
+      };
+    } catch (err) {
+      const latencyMs = Date.now() - startTime;
+      return {
+        name: endpoint.name,
+        baseUrl: endpoint.baseUrl,
+        reachable: false,
+        latencyMs,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    clearTimeout(timer);
+    __callDispose(_stack, _error, _hasError);
   }
 }
 
@@ -733,13 +1227,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,
@@ -748,6 +1253,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"
   };
@@ -872,6 +1379,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 } : {},
@@ -895,7 +1403,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;
@@ -904,6 +1412,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;
@@ -914,11 +1431,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") {
@@ -958,7 +1479,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);
@@ -972,12 +1497,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;
@@ -987,6 +1514,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"));
+      }
     }
   }
 };
@@ -1040,13 +1574,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 {
@@ -1056,6 +1590,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
   };
 }
@@ -1073,9 +1611,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 {
@@ -1095,9 +1633,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
@@ -1123,8 +1661,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 {
@@ -1137,7 +1700,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;
     }
   }
@@ -1203,7 +1766,7 @@ var ModelsClient = class {
             body: { ...request, stream: true },
             signal
           });
-          return normalizeProgressStream(stream);
+          return normalizeProgressStream(stream, signal);
         },
         { ...request, singleEndpoint: true, holdUntil: (stream) => stream.finalResult }
       );
@@ -1226,7 +1789,7 @@ var ModelsClient = class {
             body: { ...request, stream: true },
             signal
           });
-          return normalizeProgressStream(stream);
+          return normalizeProgressStream(stream, signal);
         },
         { ...request, singleEndpoint: true, holdUntil: (stream) => stream.finalResult }
       );
@@ -1320,34 +1883,607 @@ 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;
+  }
+  abort() {
+    this.removeAbortListener?.();
+    this.removeAbortListener = void 0;
+    this.source.abort?.();
+    this.rejectFinal(new OllamaAbortError("OpenAI Chat Completion stream aborted"));
+  }
+  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"));
+      }
+    }
+  }
+};
+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) {
-    return this.http.request({
-      path: "/v1/responses",
-      body: request,
+    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);
@@ -1355,50 +2491,342 @@ var OpenAICompatClient = class {
 };
 
 // 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) {
+  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) {
-    return this.http.request({
-      path: "/v1/messages",
-      body: request,
+    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/utils.ts
-async function encodeImage(image) {
-  if (typeof image === "string") return image;
-  const bufferCtor = globalThis.Buffer;
-  if (bufferCtor !== void 0) return bufferCtor.from(image).toString("base64");
-  const CHUNK_SIZE = 32768;
-  let binary = "";
-  for (let i = 0; i < image.length; i += CHUNK_SIZE) {
-    binary += String.fromCharCode(...image.subarray(i, i + CHUNK_SIZE));
-  }
-  return btoa(binary);
+// 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;
 }
-async function encodeImages(images) {
-  if (images === void 0) return void 0;
-  return Promise.all(images.map((image) => encodeImage(image)));
+function assertOperationAllowed(operation, options) {
+  const localMode = options.localMode ?? true;
+  if (!localMode && !operation.environment.cloud) {
+    throw new OllamaGenericClientError(
+      `Operation ${operation.operationId} (${operation.method} ${operation.path}) is local-only and not supported in cloud mode.`
+    );
+  }
+  if (operation.constraints?.minOllamaVersion && options.serverVersion && compareVersions(options.serverVersion, operation.constraints.minOllamaVersion) < 0) {
+    throw new OllamaGenericClientError(
+      `Operation ${operation.operationId} (${operation.method} ${operation.path}) requires Ollama >= ${operation.constraints.minOllamaVersion} (server reports ${options.serverVersion}).`
+    );
+  }
 }
-async function withEncodedImages(req) {
-  if (!req.images?.some((image) => image instanceof Uint8Array)) return req;
-  return { ...req, images: await encodeImages(req.images) };
+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);
 }
-async function withEncodedMessageImages(messages) {
-  if (!messages.some((message) => message.images?.some((image) => image instanceof Uint8Array)))
-    return messages;
-  return Promise.all(messages.map((message) => withEncodedImages(message)));
+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/client.ts
+var logicalRequestSequence = 0;
+function createLogicalRequestId() {
+  logicalRequestSequence += 1;
+  return `ollama-request-${logicalRequestSequence}`;
+}
 var OllamaClient = class {
   registry;
   models;
@@ -1407,6 +2835,8 @@ 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
@@ -1427,17 +2857,66 @@ var OllamaClient = class {
         ...config.headers !== void 0 ? { headers: config.headers } : {}
       }
     ]);
-    this.registry = new EndpointRegistry([...endpoints, ...credentialEndpoints], 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
@@ -1455,6 +2934,8 @@ var OllamaClient = class {
   }
   async executeWithFailover(operation, options) {
     const timeout = createTimeoutSignal(options?.timeoutMs ?? this.timeoutMs, options?.signal);
+    const requestId = createLogicalRequestId();
+    let deferTimeoutCancel = false;
     try {
       let lastError;
       for (; ; ) {
@@ -1481,7 +2962,10 @@ var OllamaClient = class {
             baseUrl: endpoint.baseUrl,
             ...endpoint.apiKey !== void 0 ? { apiKey: endpoint.apiKey } : {},
             ...endpoint.headers !== void 0 ? { headers: endpoint.headers } : {},
-            fetch: this.fetchImpl
+            fetch: this.fetchImpl,
+            middleware: this.middleware,
+            onLifecycleEvent: this.onLifecycleEvent,
+            requestId
           });
           this.registry.acquire(endpoint.name);
           let holdPromise;
@@ -1492,10 +2976,30 @@ var OllamaClient = class {
                 [ATTR_OLLAMA_ENDPOINT_NAME]: endpoint.name,
                 [ATTR_OLLAMA_ENDPOINT_ATTEMPT]: attemptIndex
               },
-              () => withRetry(() => operation(http, timeout.signal), this.retryConfig)
+              () => 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);
+            if (options?.holdUntil) {
+              holdPromise = options.holdUntil(result);
+              deferTimeoutCancel = true;
+            }
             return result;
           } catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
@@ -1506,7 +3010,10 @@ var OllamaClient = class {
               throw error;
           } finally {
             if (holdPromise) {
-              void holdPromise.catch(() => void 0).finally(() => this.registry.release(endpoint.name));
+              void holdPromise.catch(() => void 0).finally(() => {
+                timeout.cancel();
+                this.registry.release(endpoint.name);
+              });
             } else {
               this.registry.release(endpoint.name);
             }
@@ -1515,11 +3022,18 @@ var OllamaClient = class {
         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) => {
@@ -1530,7 +3044,7 @@ var OllamaClient = class {
             body: { ...req, messages, stream: true },
             signal
           });
-          return normalizeChatStream(stream);
+          return normalizeChatStream(stream, signal);
         },
         {
           signal: req.signal,
@@ -1594,7 +3108,7 @@ var OllamaClient = class {
             body: { ...encodedReq, stream: true },
             signal
           });
-          return normalizeGenerateStream(stream);
+          return normalizeGenerateStream(stream, signal);
         },
         {
           signal: encodedReq.signal,
@@ -1713,31 +3227,68 @@ var OllamaClient = class {
    * 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);
+    var _stack = [];
     try {
+      const timeout = createTimeoutSignal(options.timeoutMs ?? this.timeoutMs, options.signal);
+      const _timeout = __using(_stack, {
+        [Symbol.dispose]() {
+          timeout.cancel();
+        }
+      });
+      const requestId = createLogicalRequestId();
       const http = new HttpClient({
         baseUrl: OLLAMA_CLOUD_BASE_URL,
         apiKey: this.cloudApiKey,
-        fetch: this.fetchImpl
+        fetch: this.fetchImpl,
+        middleware: this.middleware,
+        onLifecycleEvent: this.onLifecycleEvent,
+        requestId
       });
-      return await withRetry(() => operation(http, timeout.signal), this.retryConfig);
+      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
+      );
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      timeout.cancel();
+      __callDispose(_stack, _error, _hasError);
     }
   }
   // --- Capabilities & Health ---
-  capabilities(model) {
-    return this.executeWithFailover((http) => detectModelCapabilities(http, model), {
-      singleEndpoint: true,
-      model
-    });
+  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();
@@ -1750,8 +3301,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() {
@@ -1761,34 +3315,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]();
@@ -2091,25 +3626,32 @@ var ToolRegistry = class {
     return results;
   }
   async runWithTimeout(tool, params, ctx, toolName) {
-    const timeoutMs = tool.timeoutMs ?? this.defaultTimeoutMs;
-    if (!timeoutMs || timeoutMs <= 0) {
-      return tool.execute(params, ctx);
-    }
-    const controller = new AbortController();
-    const onParentAbort = () => controller.abort(ctx.signal?.reason);
-    if (ctx.signal) {
-      if (ctx.signal.aborted) {
-        controller.abort(ctx.signal.reason);
-      } else {
-        ctx.signal.addEventListener("abort", onParentAbort, { once: true });
-      }
-    }
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      controller.abort();
-    }, timeoutMs);
+    var _stack = [];
     try {
+      const timeoutMs = tool.timeoutMs ?? this.defaultTimeoutMs;
+      if (!timeoutMs || timeoutMs <= 0) {
+        return tool.execute(params, ctx);
+      }
+      const controller = new AbortController();
+      const onParentAbort = () => controller.abort(ctx.signal?.reason);
+      if (ctx.signal) {
+        if (ctx.signal.aborted) {
+          controller.abort(ctx.signal.reason);
+        } else {
+          ctx.signal.addEventListener("abort", onParentAbort, { once: true });
+        }
+      }
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, timeoutMs);
+      const _timer = __using(_stack, disposableTimer(timer));
+      const _listener = __using(_stack, {
+        [Symbol.dispose]() {
+          ctx.signal?.removeEventListener("abort", onParentAbort);
+        }
+      });
       const executePromise = Promise.resolve(
         tool.execute(params, { ...ctx, signal: controller.signal })
       );
@@ -2126,11 +3668,10 @@ var ToolRegistry = class {
           });
         })
       ]);
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      clearTimeout(timer);
-      if (ctx.signal) {
-        ctx.signal.removeEventListener("abort", onParentAbort);
-      }
+      __callDispose(_stack, _error, _hasError);
     }
   }
   truncateOutput(output) {
@@ -2152,28 +3693,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}"`, {
@@ -2188,19 +3935,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",
@@ -2208,11 +3951,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();
@@ -2314,12 +4094,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(
@@ -2337,6 +4129,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",
@@ -2347,7 +4163,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 } : {}
@@ -2362,17 +4178,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
             });
           }
@@ -2412,6 +4235,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;
@@ -2420,6 +4244,7 @@ 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;
@@ -2427,10 +4252,12 @@ 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;
@@ -2445,7 +4272,11 @@ 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;
@@ -2461,6 +4292,7 @@ exports.detectModelCapabilities = detectModelCapabilities;
 exports.encodeImage = encodeImage;
 exports.extractUsage = extractUsage;
 exports.inferRuntimeMode = inferRuntimeMode;
+exports.listAllMcpTools = listAllMcpTools;
 exports.listAvailableModels = listAvailableModels;
 exports.loadMcpTools = loadMcpTools;
 exports.mapError = mapError;
@@ -2469,6 +4301,7 @@ exports.normalizeGenerateStream = normalizeGenerateStream;
 exports.normalizeProgressStream = normalizeProgressStream;
 exports.parseFrontmatter = parseFrontmatter;
 exports.parseNdjsonStream = parseNdjsonStream;
+exports.parseSseStream = parseSseStream;
 exports.parseStructuredOutput = parseStructuredOutput;
 exports.registerMcpTools = registerMcpTools;
 exports.resolveCredentialEndpoints = resolveCredentialEndpoints;