@nemesis-oss/ollama-sdk 1.4.0 → 1.4.1

package/dist/index.js

@@ -1,5 +1,51 @@
 import { z } from '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;
@@ -492,12 +538,65 @@ function composeMiddleware(middlewares, finalHandler) {
   };
 }
 
+// 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;
@@ -519,12 +618,11 @@ async function* parseNdjsonStream(stream) {
     if (buffer.trim()) {
       yield JSON.parse(buffer.trim());
     }
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-    reader.releaseLock();
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
   }
 }
 
@@ -540,47 +638,51 @@ function dispatch(event, data, id, retry) {
   };
 }
 async function* parseSseStream(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let eventType;
-  let data = [];
-  let lastEventId;
-  let retry;
-  const processLine = (line) => {
-    if (line.length === 0) {
-      const event = dispatch(eventType, data, lastEventId, retry);
-      eventType = void 0;
-      data = [];
-      retry = void 0;
-      return event;
-    }
-    if (line.startsWith(":")) return void 0;
-    const separator = line.indexOf(":");
-    const field = separator === -1 ? line : line.slice(0, separator);
-    let value = separator === -1 ? "" : line.slice(separator + 1);
-    if (value.startsWith(" ")) value = value.slice(1);
-    switch (field) {
-      case "event":
-        eventType = value;
-        break;
-      case "data":
-        data.push(value);
-        break;
-      case "id":
-        if (!value.includes("\0")) lastEventId = value;
-        break;
-      case "retry": {
-        if (/^\d+$/.test(value)) {
-          const parsed = Number(value);
-          if (Number.isSafeInteger(parsed)) retry = parsed;
+  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;
         }
-        break;
+        default:
+          break;
       }
-    }
-    return void 0;
-  };
-  try {
+      return void 0;
+    };
+    const _reader = __using(_stack, disposableReader(reader), true);
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -608,12 +710,11 @@ async function* parseSseStream(stream) {
     }
     const terminal = dispatch(eventType, data, lastEventId, retry);
     if (terminal) yield terminal;
+  } catch (_) {
+    var _error = _, _hasError = true;
   } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-    reader.releaseLock();
+    var _promise = __callDispose(_stack, _error, _hasError);
+    _promise && await _promise;
   }
 }
 
@@ -641,16 +742,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);
     }
   });
 }
@@ -1060,42 +1167,48 @@ var HttpClient = class {
 
 // src/providers/health-check.ts
 async function checkEndpointHealth(endpoint, fetchImpl, timeoutMs = 5e3, middleware, onLifecycleEvent) {
-  const client = new HttpClient({
-    baseUrl: endpoint.baseUrl,
-    apiKey: endpoint.apiKey,
-    headers: endpoint.headers,
-    fetch: fetchImpl,
-    middleware,
-    onLifecycleEvent
-  });
-  const startTime = Date.now();
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  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);
   }
 }
 
@@ -2706,32 +2819,6 @@ var OllamaRuntime = class {
   }
 };
 
-// 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)));
-}
-
 // src/client.ts
 var logicalRequestSequence = 0;
 function createLogicalRequestId() {
@@ -3138,9 +3225,15 @@ 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);
-    const requestId = createLogicalRequestId();
+    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,
@@ -3167,8 +3260,10 @@ var OllamaClient = class {
         },
         timeout.signal
       );
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      timeout.cancel();
+      __callDispose(_stack, _error, _hasError);
     }
   }
   // --- Capabilities & Health ---
@@ -3529,25 +3624,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 })
       );
@@ -3564,11 +3666,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) {