@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/dist-EY3OJBQH.js

@@ -0,0 +1,1339 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  ProviderRegistry,
+  assertThinkingUnsupported,
+  isCallerAbortError,
+  isProviderRequestError,
+  providerVendorError,
+  toolResultToText
+} from "./chunk-EWKJGHRO.js";
+import {
+  __commonJS,
+  __name,
+  __toESM
+} from "./chunk-76FLAFCG.js";
+
+// ../../node_modules/.pnpm/whatwg-fetch@3.6.20/node_modules/whatwg-fetch/dist/fetch.umd.js
+var require_fetch_umd = __commonJS({
+  "../../node_modules/.pnpm/whatwg-fetch@3.6.20/node_modules/whatwg-fetch/dist/fetch.umd.js"(exports, module) {
+    "use strict";
+    (function(global2, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.WHATWGFetch = {});
+    })(exports, (function(exports2) {
+      "use strict";
+      var g = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
+      typeof global !== "undefined" && global || {};
+      var support = {
+        searchParams: "URLSearchParams" in g,
+        iterable: "Symbol" in g && "iterator" in Symbol,
+        blob: "FileReader" in g && "Blob" in g && (function() {
+          try {
+            new Blob();
+            return true;
+          } catch (e) {
+            return false;
+          }
+        })(),
+        formData: "FormData" in g,
+        arrayBuffer: "ArrayBuffer" in g
+      };
+      function isDataView(obj) {
+        return obj && DataView.prototype.isPrototypeOf(obj);
+      }
+      __name(isDataView, "isDataView");
+      if (support.arrayBuffer) {
+        var viewClasses = [
+          "[object Int8Array]",
+          "[object Uint8Array]",
+          "[object Uint8ClampedArray]",
+          "[object Int16Array]",
+          "[object Uint16Array]",
+          "[object Int32Array]",
+          "[object Uint32Array]",
+          "[object Float32Array]",
+          "[object Float64Array]"
+        ];
+        var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+          return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+        };
+      }
+      function normalizeName(name) {
+        if (typeof name !== "string") {
+          name = String(name);
+        }
+        if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "") {
+          throw new TypeError('Invalid character in header field name: "' + name + '"');
+        }
+        return name.toLowerCase();
+      }
+      __name(normalizeName, "normalizeName");
+      function normalizeValue(value) {
+        if (typeof value !== "string") {
+          value = String(value);
+        }
+        return value;
+      }
+      __name(normalizeValue, "normalizeValue");
+      function iteratorFor(items) {
+        var iterator = {
+          next: /* @__PURE__ */ __name(function() {
+            var value = items.shift();
+            return { done: value === void 0, value };
+          }, "next")
+        };
+        if (support.iterable) {
+          iterator[Symbol.iterator] = function() {
+            return iterator;
+          };
+        }
+        return iterator;
+      }
+      __name(iteratorFor, "iteratorFor");
+      function Headers2(headers) {
+        this.map = {};
+        if (headers instanceof Headers2) {
+          headers.forEach(function(value, name) {
+            this.append(name, value);
+          }, this);
+        } else if (Array.isArray(headers)) {
+          headers.forEach(function(header) {
+            if (header.length != 2) {
+              throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
+            }
+            this.append(header[0], header[1]);
+          }, this);
+        } else if (headers) {
+          Object.getOwnPropertyNames(headers).forEach(function(name) {
+            this.append(name, headers[name]);
+          }, this);
+        }
+      }
+      __name(Headers2, "Headers");
+      Headers2.prototype.append = function(name, value) {
+        name = normalizeName(name);
+        value = normalizeValue(value);
+        var oldValue = this.map[name];
+        this.map[name] = oldValue ? oldValue + ", " + value : value;
+      };
+      Headers2.prototype["delete"] = function(name) {
+        delete this.map[normalizeName(name)];
+      };
+      Headers2.prototype.get = function(name) {
+        name = normalizeName(name);
+        return this.has(name) ? this.map[name] : null;
+      };
+      Headers2.prototype.has = function(name) {
+        return this.map.hasOwnProperty(normalizeName(name));
+      };
+      Headers2.prototype.set = function(name, value) {
+        this.map[normalizeName(name)] = normalizeValue(value);
+      };
+      Headers2.prototype.forEach = function(callback, thisArg) {
+        for (var name in this.map) {
+          if (this.map.hasOwnProperty(name)) {
+            callback.call(thisArg, this.map[name], name, this);
+          }
+        }
+      };
+      Headers2.prototype.keys = function() {
+        var items = [];
+        this.forEach(function(value, name) {
+          items.push(name);
+        });
+        return iteratorFor(items);
+      };
+      Headers2.prototype.values = function() {
+        var items = [];
+        this.forEach(function(value) {
+          items.push(value);
+        });
+        return iteratorFor(items);
+      };
+      Headers2.prototype.entries = function() {
+        var items = [];
+        this.forEach(function(value, name) {
+          items.push([name, value]);
+        });
+        return iteratorFor(items);
+      };
+      if (support.iterable) {
+        Headers2.prototype[Symbol.iterator] = Headers2.prototype.entries;
+      }
+      function consumed(body) {
+        if (body._noBody) return;
+        if (body.bodyUsed) {
+          return Promise.reject(new TypeError("Already read"));
+        }
+        body.bodyUsed = true;
+      }
+      __name(consumed, "consumed");
+      function fileReaderReady(reader) {
+        return new Promise(function(resolve2, reject) {
+          reader.onload = function() {
+            resolve2(reader.result);
+          };
+          reader.onerror = function() {
+            reject(reader.error);
+          };
+        });
+      }
+      __name(fileReaderReady, "fileReaderReady");
+      function readBlobAsArrayBuffer(blob) {
+        var reader = new FileReader();
+        var promise = fileReaderReady(reader);
+        reader.readAsArrayBuffer(blob);
+        return promise;
+      }
+      __name(readBlobAsArrayBuffer, "readBlobAsArrayBuffer");
+      function readBlobAsText(blob) {
+        var reader = new FileReader();
+        var promise = fileReaderReady(reader);
+        var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+        var encoding = match ? match[1] : "utf-8";
+        reader.readAsText(blob, encoding);
+        return promise;
+      }
+      __name(readBlobAsText, "readBlobAsText");
+      function readArrayBufferAsText(buf) {
+        var view = new Uint8Array(buf);
+        var chars = new Array(view.length);
+        for (var i = 0; i < view.length; i++) {
+          chars[i] = String.fromCharCode(view[i]);
+        }
+        return chars.join("");
+      }
+      __name(readArrayBufferAsText, "readArrayBufferAsText");
+      function bufferClone(buf) {
+        if (buf.slice) {
+          return buf.slice(0);
+        } else {
+          var view = new Uint8Array(buf.byteLength);
+          view.set(new Uint8Array(buf));
+          return view.buffer;
+        }
+      }
+      __name(bufferClone, "bufferClone");
+      function Body() {
+        this.bodyUsed = false;
+        this._initBody = function(body) {
+          this.bodyUsed = this.bodyUsed;
+          this._bodyInit = body;
+          if (!body) {
+            this._noBody = true;
+            this._bodyText = "";
+          } else if (typeof body === "string") {
+            this._bodyText = body;
+          } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+            this._bodyBlob = body;
+          } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+            this._bodyFormData = body;
+          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this._bodyText = body.toString();
+          } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+            this._bodyArrayBuffer = bufferClone(body.buffer);
+            this._bodyInit = new Blob([this._bodyArrayBuffer]);
+          } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+            this._bodyArrayBuffer = bufferClone(body);
+          } else {
+            this._bodyText = body = Object.prototype.toString.call(body);
+          }
+          if (!this.headers.get("content-type")) {
+            if (typeof body === "string") {
+              this.headers.set("content-type", "text/plain;charset=UTF-8");
+            } else if (this._bodyBlob && this._bodyBlob.type) {
+              this.headers.set("content-type", this._bodyBlob.type);
+            } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+              this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+            }
+          }
+        };
+        if (support.blob) {
+          this.blob = function() {
+            var rejected = consumed(this);
+            if (rejected) {
+              return rejected;
+            }
+            if (this._bodyBlob) {
+              return Promise.resolve(this._bodyBlob);
+            } else if (this._bodyArrayBuffer) {
+              return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+            } else if (this._bodyFormData) {
+              throw new Error("could not read FormData body as blob");
+            } else {
+              return Promise.resolve(new Blob([this._bodyText]));
+            }
+          };
+        }
+        this.arrayBuffer = function() {
+          if (this._bodyArrayBuffer) {
+            var isConsumed = consumed(this);
+            if (isConsumed) {
+              return isConsumed;
+            } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+              return Promise.resolve(
+                this._bodyArrayBuffer.buffer.slice(
+                  this._bodyArrayBuffer.byteOffset,
+                  this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+                )
+              );
+            } else {
+              return Promise.resolve(this._bodyArrayBuffer);
+            }
+          } else if (support.blob) {
+            return this.blob().then(readBlobAsArrayBuffer);
+          } else {
+            throw new Error("could not read as ArrayBuffer");
+          }
+        };
+        this.text = function() {
+          var rejected = consumed(this);
+          if (rejected) {
+            return rejected;
+          }
+          if (this._bodyBlob) {
+            return readBlobAsText(this._bodyBlob);
+          } else if (this._bodyArrayBuffer) {
+            return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+          } else if (this._bodyFormData) {
+            throw new Error("could not read FormData body as text");
+          } else {
+            return Promise.resolve(this._bodyText);
+          }
+        };
+        if (support.formData) {
+          this.formData = function() {
+            return this.text().then(decode);
+          };
+        }
+        this.json = function() {
+          return this.text().then(JSON.parse);
+        };
+        return this;
+      }
+      __name(Body, "Body");
+      var methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+      function normalizeMethod(method) {
+        var upcased = method.toUpperCase();
+        return methods.indexOf(upcased) > -1 ? upcased : method;
+      }
+      __name(normalizeMethod, "normalizeMethod");
+      function Request(input, options) {
+        if (!(this instanceof Request)) {
+          throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+        }
+        options = options || {};
+        var body = options.body;
+        if (input instanceof Request) {
+          if (input.bodyUsed) {
+            throw new TypeError("Already read");
+          }
+          this.url = input.url;
+          this.credentials = input.credentials;
+          if (!options.headers) {
+            this.headers = new Headers2(input.headers);
+          }
+          this.method = input.method;
+          this.mode = input.mode;
+          this.signal = input.signal;
+          if (!body && input._bodyInit != null) {
+            body = input._bodyInit;
+            input.bodyUsed = true;
+          }
+        } else {
+          this.url = String(input);
+        }
+        this.credentials = options.credentials || this.credentials || "same-origin";
+        if (options.headers || !this.headers) {
+          this.headers = new Headers2(options.headers);
+        }
+        this.method = normalizeMethod(options.method || this.method || "GET");
+        this.mode = options.mode || this.mode || null;
+        this.signal = options.signal || this.signal || (function() {
+          if ("AbortController" in g) {
+            var ctrl = new AbortController();
+            return ctrl.signal;
+          }
+        })();
+        this.referrer = null;
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+          throw new TypeError("Body not allowed for GET or HEAD requests");
+        }
+        this._initBody(body);
+        if (this.method === "GET" || this.method === "HEAD") {
+          if (options.cache === "no-store" || options.cache === "no-cache") {
+            var reParamSearch = /([?&])_=[^&]*/;
+            if (reParamSearch.test(this.url)) {
+              this.url = this.url.replace(reParamSearch, "$1_=" + (/* @__PURE__ */ new Date()).getTime());
+            } else {
+              var reQueryString = /\?/;
+              this.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (/* @__PURE__ */ new Date()).getTime();
+            }
+          }
+        }
+      }
+      __name(Request, "Request");
+      Request.prototype.clone = function() {
+        return new Request(this, { body: this._bodyInit });
+      };
+      function decode(body) {
+        var form = new FormData();
+        body.trim().split("&").forEach(function(bytes) {
+          if (bytes) {
+            var split = bytes.split("=");
+            var name = split.shift().replace(/\+/g, " ");
+            var value = split.join("=").replace(/\+/g, " ");
+            form.append(decodeURIComponent(name), decodeURIComponent(value));
+          }
+        });
+        return form;
+      }
+      __name(decode, "decode");
+      function parseHeaders(rawHeaders) {
+        var headers = new Headers2();
+        var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+        preProcessedHeaders.split("\r").map(function(header) {
+          return header.indexOf("\n") === 0 ? header.substr(1, header.length) : header;
+        }).forEach(function(line) {
+          var parts = line.split(":");
+          var key = parts.shift().trim();
+          if (key) {
+            var value = parts.join(":").trim();
+            try {
+              headers.append(key, value);
+            } catch (error) {
+              console.warn("Response " + error.message);
+            }
+          }
+        });
+        return headers;
+      }
+      __name(parseHeaders, "parseHeaders");
+      Body.call(Request.prototype);
+      function Response(bodyInit, options) {
+        if (!(this instanceof Response)) {
+          throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+        }
+        if (!options) {
+          options = {};
+        }
+        this.type = "default";
+        this.status = options.status === void 0 ? 200 : options.status;
+        if (this.status < 200 || this.status > 599) {
+          throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+        }
+        this.ok = this.status >= 200 && this.status < 300;
+        this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
+        this.headers = new Headers2(options.headers);
+        this.url = options.url || "";
+        this._initBody(bodyInit);
+      }
+      __name(Response, "Response");
+      Body.call(Response.prototype);
+      Response.prototype.clone = function() {
+        return new Response(this._bodyInit, {
+          status: this.status,
+          statusText: this.statusText,
+          headers: new Headers2(this.headers),
+          url: this.url
+        });
+      };
+      Response.error = function() {
+        var response = new Response(null, { status: 200, statusText: "" });
+        response.ok = false;
+        response.status = 0;
+        response.type = "error";
+        return response;
+      };
+      var redirectStatuses = [301, 302, 303, 307, 308];
+      Response.redirect = function(url, status) {
+        if (redirectStatuses.indexOf(status) === -1) {
+          throw new RangeError("Invalid status code");
+        }
+        return new Response(null, { status, headers: { location: url } });
+      };
+      exports2.DOMException = g.DOMException;
+      try {
+        new exports2.DOMException();
+      } catch (err) {
+        exports2.DOMException = function(message, name) {
+          this.message = message;
+          this.name = name;
+          var error = Error(message);
+          this.stack = error.stack;
+        };
+        exports2.DOMException.prototype = Object.create(Error.prototype);
+        exports2.DOMException.prototype.constructor = exports2.DOMException;
+      }
+      function fetch2(input, init) {
+        return new Promise(function(resolve2, reject) {
+          var request = new Request(input, init);
+          if (request.signal && request.signal.aborted) {
+            return reject(new exports2.DOMException("Aborted", "AbortError"));
+          }
+          var xhr = new XMLHttpRequest();
+          function abortXhr() {
+            xhr.abort();
+          }
+          __name(abortXhr, "abortXhr");
+          xhr.onload = function() {
+            var options = {
+              statusText: xhr.statusText,
+              headers: parseHeaders(xhr.getAllResponseHeaders() || "")
+            };
+            if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+              options.status = 200;
+            } else {
+              options.status = xhr.status;
+            }
+            options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
+            var body = "response" in xhr ? xhr.response : xhr.responseText;
+            setTimeout(function() {
+              resolve2(new Response(body, options));
+            }, 0);
+          };
+          xhr.onerror = function() {
+            setTimeout(function() {
+              reject(new TypeError("Network request failed"));
+            }, 0);
+          };
+          xhr.ontimeout = function() {
+            setTimeout(function() {
+              reject(new TypeError("Network request timed out"));
+            }, 0);
+          };
+          xhr.onabort = function() {
+            setTimeout(function() {
+              reject(new exports2.DOMException("Aborted", "AbortError"));
+            }, 0);
+          };
+          function fixUrl(url) {
+            try {
+              return url === "" && g.location.href ? g.location.href : url;
+            } catch (e) {
+              return url;
+            }
+          }
+          __name(fixUrl, "fixUrl");
+          xhr.open(request.method, fixUrl(request.url), true);
+          if (request.credentials === "include") {
+            xhr.withCredentials = true;
+          } else if (request.credentials === "omit") {
+            xhr.withCredentials = false;
+          }
+          if ("responseType" in xhr) {
+            if (support.blob) {
+              xhr.responseType = "blob";
+            } else if (support.arrayBuffer) {
+              xhr.responseType = "arraybuffer";
+            }
+          }
+          if (init && typeof init.headers === "object" && !(init.headers instanceof Headers2 || g.Headers && init.headers instanceof g.Headers)) {
+            var names = [];
+            Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+              names.push(normalizeName(name));
+              xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+            });
+            request.headers.forEach(function(value, name) {
+              if (names.indexOf(name) === -1) {
+                xhr.setRequestHeader(name, value);
+              }
+            });
+          } else {
+            request.headers.forEach(function(value, name) {
+              xhr.setRequestHeader(name, value);
+            });
+          }
+          if (request.signal) {
+            request.signal.addEventListener("abort", abortXhr);
+            xhr.onreadystatechange = function() {
+              if (xhr.readyState === 4) {
+                request.signal.removeEventListener("abort", abortXhr);
+              }
+            };
+          }
+          xhr.send(typeof request._bodyInit === "undefined" ? null : request._bodyInit);
+        });
+      }
+      __name(fetch2, "fetch");
+      fetch2.polyfill = true;
+      if (!g.fetch) {
+        g.fetch = fetch2;
+        g.Headers = Headers2;
+        g.Request = Request;
+        g.Response = Response;
+      }
+      exports2.Headers = Headers2;
+      exports2.Request = Request;
+      exports2.Response = Response;
+      exports2.fetch = fetch2;
+      Object.defineProperty(exports2, "__esModule", { value: true });
+    }));
+  }
+});
+
+// ../providers/ollama/dist/client.js
+import { randomUUID } from "node:crypto";
+
+// ../../node_modules/.pnpm/ollama@0.5.18/node_modules/ollama/dist/index.mjs
+import fs, { promises } from "node:fs";
+import { resolve } from "node:path";
+
+// ../../node_modules/.pnpm/ollama@0.5.18/node_modules/ollama/dist/browser.mjs
+var import_whatwg_fetch = __toESM(require_fetch_umd(), 1);
+var defaultPort = "11434";
+var defaultHost = `http://127.0.0.1:${defaultPort}`;
+var version = "0.5.18";
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp$1");
+var __publicField$1 = /* @__PURE__ */ __name((obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+}, "__publicField$1");
+var ResponseError = class _ResponseError extends Error {
+  static {
+    __name(this, "ResponseError");
+  }
+  constructor(error, status_code) {
+    super(error);
+    this.error = error;
+    this.status_code = status_code;
+    this.name = "ResponseError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ResponseError);
+    }
+  }
+};
+var AbortableAsyncIterator = class {
+  static {
+    __name(this, "AbortableAsyncIterator");
+  }
+  constructor(abortController, itr, doneCallback) {
+    __publicField$1(this, "abortController");
+    __publicField$1(this, "itr");
+    __publicField$1(this, "doneCallback");
+    this.abortController = abortController;
+    this.itr = itr;
+    this.doneCallback = doneCallback;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const message of this.itr) {
+      if ("error" in message) {
+        throw new Error(message.error);
+      }
+      yield message;
+      if (message.done || message.status === "success") {
+        this.doneCallback();
+        return;
+      }
+    }
+    throw new Error("Did not receive done or success response in stream.");
+  }
+};
+var checkOk = /* @__PURE__ */ __name(async (response) => {
+  if (response.ok) {
+    return;
+  }
+  let message = `Error ${response.status}: ${response.statusText}`;
+  let errorData = null;
+  if (response.headers.get("content-type")?.includes("application/json")) {
+    try {
+      errorData = await response.json();
+      message = errorData.error || message;
+    } catch (error) {
+      console.log("Failed to parse error response as JSON");
+    }
+  } else {
+    try {
+      console.log("Getting text from response");
+      const textResponse = await response.text();
+      message = textResponse || message;
+    } catch (error) {
+      console.log("Failed to get text from error response");
+    }
+  }
+  throw new ResponseError(message, response.status);
+}, "checkOk");
+function getPlatform() {
+  if (typeof window !== "undefined" && window.navigator) {
+    const nav = navigator;
+    if ("userAgentData" in nav && nav.userAgentData?.platform) {
+      return `${nav.userAgentData.platform.toLowerCase()} Browser/${navigator.userAgent};`;
+    }
+    if (navigator.platform) {
+      return `${navigator.platform.toLowerCase()} Browser/${navigator.userAgent};`;
+    }
+    return `unknown Browser/${navigator.userAgent};`;
+  } else if (typeof process !== "undefined") {
+    return `${process.arch} ${process.platform} Node.js/${process.version}`;
+  }
+  return "";
+}
+__name(getPlatform, "getPlatform");
+function normalizeHeaders(headers) {
+  if (headers instanceof Headers) {
+    const obj = {};
+    headers.forEach((value, key) => {
+      obj[key] = value;
+    });
+    return obj;
+  } else if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  } else {
+    return headers || {};
+  }
+}
+__name(normalizeHeaders, "normalizeHeaders");
+var fetchWithHeaders = /* @__PURE__ */ __name(async (fetch2, url, options = {}) => {
+  const defaultHeaders = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": `ollama-js/${version} (${getPlatform()})`
+  };
+  options.headers = normalizeHeaders(options.headers);
+  const customHeaders = Object.fromEntries(
+    Object.entries(options.headers).filter(([key]) => !Object.keys(defaultHeaders).some((defaultKey) => defaultKey.toLowerCase() === key.toLowerCase()))
+  );
+  options.headers = {
+    ...defaultHeaders,
+    ...customHeaders
+  };
+  return fetch2(url, options);
+}, "fetchWithHeaders");
+var get = /* @__PURE__ */ __name(async (fetch2, host, options) => {
+  const response = await fetchWithHeaders(fetch2, host, {
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+}, "get");
+var post = /* @__PURE__ */ __name(async (fetch2, host, data, options) => {
+  const isRecord = /* @__PURE__ */ __name((input) => {
+    return input !== null && typeof input === "object" && !Array.isArray(input);
+  }, "isRecord");
+  const formattedData = isRecord(data) ? JSON.stringify(data) : data;
+  const response = await fetchWithHeaders(fetch2, host, {
+    method: "POST",
+    body: formattedData,
+    signal: options?.signal,
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+}, "post");
+var del = /* @__PURE__ */ __name(async (fetch2, host, data, options) => {
+  const response = await fetchWithHeaders(fetch2, host, {
+    method: "DELETE",
+    body: JSON.stringify(data),
+    headers: options?.headers
+  });
+  await checkOk(response);
+  return response;
+}, "del");
+var parseJSON = /* @__PURE__ */ __name(async function* (itr) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  const reader = itr.getReader();
+  while (true) {
+    const { done, value: chunk } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffer += decoder.decode(chunk);
+    const parts = buffer.split("\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      try {
+        yield JSON.parse(part);
+      } catch (error) {
+        console.warn("invalid json: ", part);
+      }
+    }
+  }
+  for (const part of buffer.split("\n").filter((p) => p !== "")) {
+    try {
+      yield JSON.parse(part);
+    } catch (error) {
+      console.warn("invalid json: ", part);
+    }
+  }
+}, "parseJSON");
+var formatHost = /* @__PURE__ */ __name((host) => {
+  if (!host) {
+    return defaultHost;
+  }
+  let isExplicitProtocol = host.includes("://");
+  if (host.startsWith(":")) {
+    host = `http://127.0.0.1${host}`;
+    isExplicitProtocol = true;
+  }
+  if (!isExplicitProtocol) {
+    host = `http://${host}`;
+  }
+  const url = new URL(host);
+  let port = url.port;
+  if (!port) {
+    if (!isExplicitProtocol) {
+      port = defaultPort;
+    } else {
+      port = url.protocol === "https:" ? "443" : "80";
+    }
+  }
+  let auth = "";
+  if (url.username) {
+    auth = url.username;
+    if (url.password) {
+      auth += `:${url.password}`;
+    }
+    auth += "@";
+  }
+  let formattedHost = `${url.protocol}//${auth}${url.hostname}:${port}${url.pathname}`;
+  if (formattedHost.endsWith("/")) {
+    formattedHost = formattedHost.slice(0, -1);
+  }
+  return formattedHost;
+}, "formatHost");
+var __defProp = Object.defineProperty;
+var __defNormalProp = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp");
+var __publicField = /* @__PURE__ */ __name((obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+}, "__publicField");
+var Ollama$1 = class Ollama {
+  static {
+    __name(this, "Ollama");
+  }
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "fetch");
+    __publicField(this, "ongoingStreamedRequests", []);
+    this.config = {
+      host: "",
+      headers: config?.headers
+    };
+    if (!config?.proxy) {
+      this.config.host = formatHost(config?.host ?? defaultHost);
+    }
+    this.fetch = config?.fetch ?? fetch;
+  }
+  // Abort any ongoing streamed requests to Ollama
+  abort() {
+    for (const request of this.ongoingStreamedRequests) {
+      request.abort();
+    }
+    this.ongoingStreamedRequests.length = 0;
+  }
+  /**
+   * Processes a request to the Ollama server. If the request is streamable, it will return a
+   * AbortableAsyncIterator that yields the response messages. Otherwise, it will return the response
+   * object.
+   * @param endpoint {string} - The endpoint to send the request to.
+   * @param request {object} - The request object to send to the endpoint.
+   * @protected {T | AbortableAsyncIterator<T>} - The response object or a AbortableAsyncIterator that yields
+   * response messages.
+   * @throws {Error} - If the response body is missing or if the response is an error.
+   * @returns {Promise<T | AbortableAsyncIterator<T>>} - The response object or a AbortableAsyncIterator that yields the streamed response.
+   */
+  async processStreamableRequest(endpoint, request) {
+    request.stream = request.stream ?? false;
+    const host = `${this.config.host}/api/${endpoint}`;
+    if (request.stream) {
+      const abortController = new AbortController();
+      const response2 = await post(this.fetch, host, request, {
+        signal: abortController.signal,
+        headers: this.config.headers
+      });
+      if (!response2.body) {
+        throw new Error("Missing body");
+      }
+      const itr = parseJSON(response2.body);
+      const abortableAsyncIterator = new AbortableAsyncIterator(
+        abortController,
+        itr,
+        () => {
+          const i = this.ongoingStreamedRequests.indexOf(abortableAsyncIterator);
+          if (i > -1) {
+            this.ongoingStreamedRequests.splice(i, 1);
+          }
+        }
+      );
+      this.ongoingStreamedRequests.push(abortableAsyncIterator);
+      return abortableAsyncIterator;
+    }
+    const response = await post(this.fetch, host, request, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Encodes an image to base64 if it is a Uint8Array.
+   * @param image {Uint8Array | string} - The image to encode.
+   * @returns {Promise<string>} - The base64 encoded image.
+   */
+  async encodeImage(image) {
+    if (typeof image !== "string") {
+      const uint8Array = new Uint8Array(image);
+      let byteString = "";
+      const len = uint8Array.byteLength;
+      for (let i = 0; i < len; i++) {
+        byteString += String.fromCharCode(uint8Array[i]);
+      }
+      return btoa(byteString);
+    }
+    return image;
+  }
+  /**
+   * Generates a response from a text prompt.
+   * @param request {GenerateRequest} - The request object.
+   * @returns {Promise<GenerateResponse | AbortableAsyncIterator<GenerateResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async generate(request) {
+    if (request.images) {
+      request.images = await Promise.all(request.images.map(this.encodeImage.bind(this)));
+    }
+    return this.processStreamableRequest("generate", request);
+  }
+  /**
+   * Chats with the model. The request object can contain messages with images that are either
+   * Uint8Arrays or base64 encoded strings. The images will be base64 encoded before sending the
+   * request.
+   * @param request {ChatRequest} - The request object.
+   * @returns {Promise<ChatResponse | AbortableAsyncIterator<ChatResponse>>} - The response object or an
+   * AbortableAsyncIterator that yields response messages.
+   */
+  async chat(request) {
+    if (request.messages) {
+      for (const message of request.messages) {
+        if (message.images) {
+          message.images = await Promise.all(
+            message.images.map(this.encodeImage.bind(this))
+          );
+        }
+      }
+    }
+    return this.processStreamableRequest("chat", request);
+  }
+  /**
+   * Creates a new model from a stream of data.
+   * @param request {CreateRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or a stream of progress responses.
+   */
+  async create(request) {
+    return this.processStreamableRequest("create", {
+      ...request
+    });
+  }
+  /**
+   * Pulls a model from the Ollama registry. The request object can contain a stream flag to indicate if the
+   * response should be streamed.
+   * @param request {PullRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async pull(request) {
+    return this.processStreamableRequest("pull", {
+      name: request.model,
+      stream: request.stream,
+      insecure: request.insecure
+    });
+  }
+  /**
+   * Pushes a model to the Ollama registry. The request object can contain a stream flag to indicate if the
+   * response should be streamed.
+   * @param request {PushRequest} - The request object.
+   * @returns {Promise<ProgressResponse | AbortableAsyncIterator<ProgressResponse>>} - The response object or
+   * an AbortableAsyncIterator that yields response messages.
+   */
+  async push(request) {
+    return this.processStreamableRequest("push", {
+      name: request.model,
+      stream: request.stream,
+      insecure: request.insecure
+    });
+  }
+  /**
+   * Deletes a model from the server. The request object should contain the name of the model to
+   * delete.
+   * @param request {DeleteRequest} - The request object.
+   * @returns {Promise<StatusResponse>} - The response object.
+   */
+  async delete(request) {
+    await del(
+      this.fetch,
+      `${this.config.host}/api/delete`,
+      { name: request.model },
+      { headers: this.config.headers }
+    );
+    return { status: "success" };
+  }
+  /**
+   * Copies a model from one name to another. The request object should contain the name of the
+   * model to copy and the new name.
+   * @param request {CopyRequest} - The request object.
+   * @returns {Promise<StatusResponse>} - The response object.
+   */
+  async copy(request) {
+    await post(this.fetch, `${this.config.host}/api/copy`, { ...request }, {
+      headers: this.config.headers
+    });
+    return { status: "success" };
+  }
+  /**
+   * Lists the models on the server.
+   * @returns {Promise<ListResponse>} - The response object.
+   * @throws {Error} - If the response body is missing.
+   */
+  async list() {
+    const response = await get(this.fetch, `${this.config.host}/api/tags`, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Shows the metadata of a model. The request object should contain the name of the model.
+   * @param request {ShowRequest} - The request object.
+   * @returns {Promise<ShowResponse>} - The response object.
+   */
+  async show(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/show`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Embeds text input into vectors.
+   * @param request {EmbedRequest} - The request object.
+   * @returns {Promise<EmbedResponse>} - The response object.
+   */
+  async embed(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/embed`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Embeds a text prompt into a vector.
+   * @param request {EmbeddingsRequest} - The request object.
+   * @returns {Promise<EmbeddingsResponse>} - The response object.
+   */
+  async embeddings(request) {
+    const response = await post(this.fetch, `${this.config.host}/api/embeddings`, {
+      ...request
+    }, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+  /**
+   * Lists the running models on the server
+   * @returns {Promise<ListResponse>} - The response object.
+   * @throws {Error} - If the response body is missing.
+   */
+  async ps() {
+    const response = await get(this.fetch, `${this.config.host}/api/ps`, {
+      headers: this.config.headers
+    });
+    return await response.json();
+  }
+};
+var browser = new Ollama$1();
+
+// ../../node_modules/.pnpm/ollama@0.5.18/node_modules/ollama/dist/index.mjs
+var import_whatwg_fetch2 = __toESM(require_fetch_umd(), 1);
+var Ollama2 = class extends Ollama$1 {
+  static {
+    __name(this, "Ollama");
+  }
+  async encodeImage(image) {
+    if (typeof image !== "string") {
+      return Buffer.from(image).toString("base64");
+    }
+    try {
+      if (fs.existsSync(image)) {
+        const fileBuffer = await promises.readFile(resolve(image));
+        return Buffer.from(fileBuffer).toString("base64");
+      }
+    } catch {
+    }
+    return image;
+  }
+  /**
+   * checks if a file exists
+   * @param path {string} - The path to the file
+   * @private @internal
+   * @returns {Promise<boolean>} - Whether the file exists or not
+   */
+  async fileExists(path) {
+    try {
+      await promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async create(request) {
+    if (request.from && await this.fileExists(resolve(request.from))) {
+      throw Error("Creating with a local path is not currently supported from ollama-js");
+    }
+    if (request.stream) {
+      return super.create(request);
+    } else {
+      return super.create(request);
+    }
+  }
+};
+var index = new Ollama2();
+
+// ../providers/ollama/dist/request-timeout.js
+function withRequestTimeout(base, timeoutMs) {
+  if (timeoutMs === void 0)
+    return base;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error(`Ollama timeout must be a positive number of milliseconds, got ${timeoutMs}. A zero or negative deadline would abort every request before it was sent.`);
+  }
+  const inner = base ?? fetch;
+  return async (input, init) => {
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const signal = init?.signal ? AbortSignal.any([init.signal, deadline]) : deadline;
+    return inner(input, { ...init, signal });
+  };
+}
+__name(withRequestTimeout, "withRequestTimeout");
+
+// ../providers/ollama/dist/client.js
+var OLLAMA_CAPABILITIES = {
+  supportsTools: false,
+  supportsStreaming: true,
+  supportsFunctionCalling: false,
+  supportsVision: false,
+  // Images only. A document degrades to a named placeholder.
+  supportsDocuments: false,
+  supportsToolResultImages: false,
+  supportsToolResultDocuments: false
+};
+var DEFAULT_HOST = "http://localhost:11434";
+function resolveHost(config) {
+  if (config.host)
+    return config.host;
+  const envHost = process.env.OLLAMA_HOST;
+  if (envHost && envHost.length > 0)
+    return envHost;
+  return DEFAULT_HOST;
+}
+__name(resolveHost, "resolveHost");
+function toOllamaMessages(messages) {
+  return messages.map((msg) => ({
+    role: msg.role,
+    // A tool result can be content BLOCKS now; this wire takes text, so
+    // flatten rather than hand it an array it cannot read.
+    content: typeof msg.content === "string" ? msg.content : toolResultToText(msg.content ?? "")
+  }));
+}
+__name(toOllamaMessages, "toOllamaMessages");
+function mapDoneReason(reason) {
+  switch (reason) {
+    case "length":
+      return "length";
+    case "stop":
+      return "stop";
+    default:
+      return "stop";
+  }
+}
+__name(mapDoneReason, "mapDoneReason");
+function buildUsage(resp) {
+  const promptTokens = resp.prompt_eval_count ?? 0;
+  const completionTokens = resp.eval_count ?? 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens,
+    cachedTokens: 0,
+    cacheWriteTokens: 0
+  };
+}
+__name(buildUsage, "buildUsage");
+async function awaitStreamStart(operation, signal) {
+  if (!signal)
+    return operation;
+  let onAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    onAbort = /* @__PURE__ */ __name(() => reject(signal.reason), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  void operation.then((stream) => {
+    if (signal.aborted)
+      stream.abort();
+  }, () => void 0);
+  try {
+    return await Promise.race([operation, aborted]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+__name(awaitStreamStart, "awaitStreamStart");
+var OllamaProvider = class {
+  static {
+    __name(this, "OllamaProvider");
+  }
+  id = "ollama";
+  name = "Ollama";
+  capabilities = OLLAMA_CAPABILITIES;
+  client;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.client = new Ollama2({
+      host: resolveHost(config),
+      fetch: withRequestTimeout(config.fetch, config.timeout)
+    });
+  }
+  buildOptions(params) {
+    const options = {};
+    if (params.temperature !== void 0)
+      options.temperature = params.temperature;
+    if (params.topP !== void 0)
+      options.top_p = params.topP;
+    if (params.topK !== void 0)
+      options.top_k = params.topK;
+    if (params.maxTokens !== void 0)
+      options.num_predict = params.maxTokens;
+    if (params.stop)
+      options.stop = params.stop;
+    return options;
+  }
+  resolveModel(params) {
+    const model = params.model || this.config.model;
+    if (!model) {
+      throw new Error("OllamaProvider: no model specified. Pass `model` on the chat params or set a default via config.");
+    }
+    return model;
+  }
+  async *chatStream(params) {
+    assertThinkingUnsupported("OllamaProvider", params);
+    const model = this.resolveModel(params);
+    const messages = toOllamaMessages(params.messages);
+    const options = this.buildOptions(params);
+    let stream;
+    try {
+      params.signal?.throwIfAborted();
+      stream = await awaitStreamStart(this.client.chat({
+        model,
+        messages,
+        stream: true,
+        ...Object.keys(options).length > 0 ? { options } : {}
+      }), params.signal);
+    } catch (err) {
+      if (isCallerAbortError(err, params.signal))
+        throw params.signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "ollama", error: err });
+    }
+    const signal = params.signal;
+    const onAbort = /* @__PURE__ */ __name(() => stream.abort(), "onAbort");
+    if (signal?.aborted)
+      stream.abort();
+    else
+      signal?.addEventListener("abort", onAbort, { once: true });
+    const id = randomUUID();
+    try {
+      for await (const chunk of stream) {
+        signal?.throwIfAborted();
+        const content = chunk.message?.content;
+        if (content && content.length > 0) {
+          yield {
+            id,
+            delta: { content }
+          };
+        }
+        if (chunk.done === true) {
+          const usage = buildUsage(chunk);
+          yield {
+            id,
+            delta: {},
+            // `done_reason` was ignored and every finish reported as 'stop', so a
+            // length-truncated answer was indistinguishable from a finished one.
+            // The consumer that starves on this is real: the iteration loop's
+            // auto-continuation only fires on `finishReason === 'length'`, so it
+            // could never fire for Ollama. The field is in the vendor's own
+            // typings, so this needs no cast.
+            finishReason: mapDoneReason(chunk.done_reason),
+            usage
+          };
+        }
+      }
+    } catch (err) {
+      if (isCallerAbortError(err, signal))
+        throw signal?.reason ?? err;
+      if (isProviderRequestError(err))
+        throw err;
+      throw providerVendorError({ providerId: "ollama", error: err });
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  /**
+   * A local server takes no credential, so this establishes reachability
+   * rather than authorisation — which is the whole of what "does this work?"
+   * can mean here. Declared so the answer comes from the driver rather than
+   * from a listing call that happened to throw.
+   */
+  async probeCredential(signal) {
+    signal?.throwIfAborted();
+    await this.client.list();
+    signal?.throwIfAborted();
+  }
+  async listModels(signal) {
+    signal?.throwIfAborted();
+    const resp = await this.client.list();
+    signal?.throwIfAborted();
+    return resp.models.map((m) => ({
+      id: m.name,
+      name: m.name,
+      // A price this driver KNOWS, not a placeholder for one it does not.
+      // Ollama serves a server the operator runs locally and bills per
+      // token exactly never, so zero is the true rate. Absence would say
+      // "nobody knows" — the one thing that is untrue of it — and a
+      // consumer is right to read `0` here as free. See
+      // `ModelInfo.inputPrice`.
+      inputPrice: 0,
+      outputPrice: 0,
+      supportsToolUse: false,
+      supportsStreaming: true
+    }));
+  }
+  async healthCheck() {
+    try {
+      await this.client.list();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../providers/ollama/dist/index.js
+function registerOllama(options) {
+  ProviderRegistry.register("ollama", OllamaProvider, OLLAMA_CAPABILITIES, options);
+}
+__name(registerOllama, "registerOllama");
+export {
+  OLLAMA_CAPABILITIES,
+  OllamaProvider,
+  registerOllama
+};
+//# sourceMappingURL=dist-EY3OJBQH.js.map