@reactive-agents/llm-provider 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,9 +1,1124 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/whatwg-fetch/fetch.js
+function isDataView(obj) {
+  return obj && DataView.prototype.isPrototypeOf(obj);
+}
+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();
+}
+function normalizeValue(value) {
+  if (typeof value !== "string") {
+    value = String(value);
+  }
+  return value;
+}
+function iteratorFor(items) {
+  var iterator = {
+    next: function() {
+      var value = items.shift();
+      return { done: value === void 0, value };
+    }
+  };
+  if (support.iterable) {
+    iterator[Symbol.iterator] = function() {
+      return iterator;
+    };
+  }
+  return iterator;
+}
+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);
+  }
+}
+function consumed(body) {
+  if (body._noBody) return;
+  if (body.bodyUsed) {
+    return Promise.reject(new TypeError("Already read"));
+  }
+  body.bodyUsed = true;
+}
+function fileReaderReady(reader) {
+  return new Promise(function(resolve2, reject) {
+    reader.onload = function() {
+      resolve2(reader.result);
+    };
+    reader.onerror = function() {
+      reject(reader.error);
+    };
+  });
+}
+function readBlobAsArrayBuffer(blob) {
+  var reader = new FileReader();
+  var promise = fileReaderReady(reader);
+  reader.readAsArrayBuffer(blob);
+  return promise;
+}
+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;
+}
+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("");
+}
+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;
+  }
+}
+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;
+}
+function normalizeMethod(method) {
+  var upcased = method.toUpperCase();
+  return methods.indexOf(upcased) > -1 ? upcased : method;
+}
+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();
+      }
+    }
+  }
+}
+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;
+}
+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;
+}
+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);
+}
+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 DOMException("Aborted", "AbortError"));
+    }
+    var xhr = new XMLHttpRequest();
+    function abortXhr() {
+      xhr.abort();
+    }
+    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 DOMException("Aborted", "AbortError"));
+      }, 0);
+    };
+    function fixUrl(url) {
+      try {
+        return url === "" && g.location.href ? g.location.href : url;
+      } catch (e) {
+        return url;
+      }
+    }
+    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);
+  });
+}
+var g, support, viewClasses, isArrayBufferView, methods, redirectStatuses, DOMException;
+var init_fetch = __esm({
+  "../../node_modules/whatwg-fetch/fetch.js"() {
+    "use strict";
+    g = typeof globalThis !== "undefined" && globalThis || typeof self !== "undefined" && self || // eslint-disable-next-line no-undef
+    typeof global !== "undefined" && global || {};
+    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
+    };
+    if (support.arrayBuffer) {
+      viewClasses = [
+        "[object Int8Array]",
+        "[object Uint8Array]",
+        "[object Uint8ClampedArray]",
+        "[object Int16Array]",
+        "[object Uint16Array]",
+        "[object Int32Array]",
+        "[object Uint32Array]",
+        "[object Float32Array]",
+        "[object Float64Array]"
+      ];
+      isArrayBufferView = ArrayBuffer.isView || function(obj) {
+        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+      };
+    }
+    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;
+    }
+    methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
+    Request.prototype.clone = function() {
+      return new Request(this, { body: this._bodyInit });
+    };
+    Body.call(Request.prototype);
+    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;
+    };
+    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 } });
+    };
+    DOMException = g.DOMException;
+    try {
+      new DOMException();
+    } catch (err) {
+      DOMException = function(message, name) {
+        this.message = message;
+        this.name = name;
+        var error = Error(message);
+        this.stack = error.stack;
+      };
+      DOMException.prototype = Object.create(Error.prototype);
+      DOMException.prototype.constructor = DOMException;
+    }
+    fetch2.polyfill = true;
+    if (!g.fetch) {
+      g.fetch = fetch2;
+      g.Headers = Headers2;
+      g.Request = Request;
+      g.Response = Response;
+    }
+  }
+});
+
+// ../../node_modules/ollama/dist/browser.mjs
+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 "";
+}
+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 || {};
+  }
+}
+var defaultPort, defaultHost, version, __defProp$1, __defNormalProp$1, __publicField$1, ResponseError, AbortableAsyncIterator, checkOk, readEnvVar, fetchWithHeaders, get, post, del, parseJSON, formatHost, __defProp2, __defNormalProp, __publicField, Ollama$1, browser;
+var init_browser = __esm({
+  "../../node_modules/ollama/dist/browser.mjs"() {
+    "use strict";
+    init_fetch();
+    defaultPort = "11434";
+    defaultHost = `http://127.0.0.1:${defaultPort}`;
+    version = "0.6.3";
+    __defProp$1 = Object.defineProperty;
+    __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField$1 = (obj, key, value) => {
+      __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+      return value;
+    };
+    ResponseError = class _ResponseError extends Error {
+      constructor(error, status_code) {
+        super(error);
+        this.error = error;
+        this.status_code = status_code;
+        this.name = "ResponseError";
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _ResponseError);
+        }
+      }
+    };
+    AbortableAsyncIterator = class {
+      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.");
+      }
+    };
+    checkOk = 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);
+    };
+    readEnvVar = (obj, key) => {
+      return obj[key];
+    };
+    fetchWithHeaders = async (fetch3, url, options = {}) => {
+      const defaultHeaders = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": `ollama-js/${version} (${getPlatform()})`
+      };
+      options.headers = normalizeHeaders(options.headers);
+      try {
+        const parsed = new URL(url);
+        if (parsed.protocol === "https:" && parsed.hostname === "ollama.com") {
+          const apiKey = typeof process === "object" && process !== null && typeof process.env === "object" && process.env !== null ? readEnvVar(process.env, "OLLAMA_API_KEY") : void 0;
+          const authorization = options.headers["authorization"] || options.headers["Authorization"];
+          if (!authorization && apiKey) {
+            options.headers["Authorization"] = `Bearer ${apiKey}`;
+          }
+        }
+      } catch (error) {
+        console.error("error parsing url", error);
+      }
+      const customHeaders = Object.fromEntries(
+        Object.entries(options.headers).filter(
+          ([key]) => !Object.keys(defaultHeaders).some(
+            (defaultKey) => defaultKey.toLowerCase() === key.toLowerCase()
+          )
+        )
+      );
+      options.headers = {
+        ...defaultHeaders,
+        ...customHeaders
+      };
+      return fetch3(url, options);
+    };
+    get = async (fetch3, host, options) => {
+      const response = await fetchWithHeaders(fetch3, host, {
+        headers: options?.headers
+      });
+      await checkOk(response);
+      return response;
+    };
+    post = async (fetch3, host, data, options) => {
+      const isRecord = (input) => {
+        return input !== null && typeof input === "object" && !Array.isArray(input);
+      };
+      const formattedData = isRecord(data) ? JSON.stringify(data) : data;
+      const response = await fetchWithHeaders(fetch3, host, {
+        method: "POST",
+        body: formattedData,
+        signal: options?.signal,
+        headers: options?.headers
+      });
+      await checkOk(response);
+      return response;
+    };
+    del = async (fetch3, host, data, options) => {
+      const response = await fetchWithHeaders(fetch3, host, {
+        method: "DELETE",
+        body: JSON.stringify(data),
+        headers: options?.headers
+      });
+      await checkOk(response);
+      return response;
+    };
+    parseJSON = 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, { stream: true });
+        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);
+          }
+        }
+      }
+      buffer += decoder.decode();
+      for (const part of buffer.split("\n").filter((p) => p !== "")) {
+        try {
+          yield JSON.parse(part);
+        } catch (error) {
+          console.warn("invalid json: ", part);
+        }
+      }
+    };
+    formatHost = (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;
+    };
+    __defProp2 = Object.defineProperty;
+    __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField = (obj, key, value) => {
+      __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+      return value;
+    };
+    Ollama$1 = class 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();
+      }
+      /**
+       * Returns the Ollama server version.
+       * @returns {Promise<VersionResponse>} - The server version object.
+       */
+      async version() {
+        const response = await get(this.fetch, `${this.config.host}/api/version`, {
+          headers: this.config.headers
+        });
+        return await response.json();
+      }
+      /**
+       * Performs web search using the Ollama web search API
+       * @param request {WebSearchRequest} - The search request containing query and options
+       * @returns {Promise<WebSearchResponse>} - The search results
+       * @throws {Error} - If the request is invalid or the server returns an error
+       */
+      async webSearch(request) {
+        if (!request.query || request.query.length === 0) {
+          throw new Error("Query is required");
+        }
+        const response = await post(this.fetch, `https://ollama.com/api/web_search`, { ...request }, {
+          headers: this.config.headers
+        });
+        return await response.json();
+      }
+      /**
+       * Fetches a single page using the Ollama web fetch API
+       * @param request {WebFetchRequest} - The fetch request containing a URL
+       * @returns {Promise<WebFetchResponse>} - The fetch result
+       * @throws {Error} - If the request is invalid or the server returns an error
+       */
+      async webFetch(request) {
+        if (!request.url || request.url.length === 0) {
+          throw new Error("URL is required");
+        }
+        const response = await post(this.fetch, `https://ollama.com/api/web_fetch`, { ...request }, { headers: this.config.headers });
+        return await response.json();
+      }
+    };
+    browser = new Ollama$1();
+  }
+});
+
+// ../../node_modules/ollama/dist/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  Ollama: () => Ollama2,
+  default: () => index
+});
+import fs, { promises } from "fs";
+import { resolve } from "path";
+var Ollama2, index;
+var init_dist = __esm({
+  "../../node_modules/ollama/dist/index.mjs"() {
+    "use strict";
+    init_browser();
+    init_fetch();
+    Ollama2 = class extends Ollama$1 {
+      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);
+        }
+      }
+    };
+    index = new Ollama2();
+  }
+});
 
 // src/types.ts
 import { Schema } from "effect";
@@ -192,28 +1307,26 @@ var LLMService = class extends Context.Tag("LLMService")() {
 import { Context as Context2, Layer } from "effect";
 var LLMConfig = class extends Context2.Tag("LLMConfig")() {
 };
-var LLMConfigFromEnv = Layer.succeed(
-  LLMConfig,
-  LLMConfig.of({
-    defaultProvider: "anthropic",
-    defaultModel: process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514",
-    anthropicApiKey: process.env.ANTHROPIC_API_KEY,
-    openaiApiKey: process.env.OPENAI_API_KEY,
-    googleApiKey: process.env.GOOGLE_API_KEY,
-    ollamaEndpoint: process.env.OLLAMA_ENDPOINT ?? "http://localhost:11434",
-    embeddingConfig: {
-      model: process.env.EMBEDDING_MODEL ?? "text-embedding-3-small",
-      dimensions: Number(process.env.EMBEDDING_DIMENSIONS ?? 1536),
-      provider: process.env.EMBEDDING_PROVIDER ?? "openai",
-      batchSize: 100
-    },
-    supportsPromptCaching: (process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514").startsWith("claude"),
-    maxRetries: Number(process.env.LLM_MAX_RETRIES ?? 3),
-    timeoutMs: Number(process.env.LLM_TIMEOUT_MS ?? 3e4),
-    defaultMaxTokens: 4096,
-    defaultTemperature: Number(process.env.LLM_DEFAULT_TEMPERATURE ?? 0.7)
-  })
-);
+var llmConfigFromEnv = LLMConfig.of({
+  defaultProvider: "anthropic",
+  defaultModel: process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514",
+  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+  openaiApiKey: process.env.OPENAI_API_KEY,
+  googleApiKey: process.env.GOOGLE_API_KEY,
+  ollamaEndpoint: process.env.OLLAMA_ENDPOINT ?? "http://localhost:11434",
+  embeddingConfig: {
+    model: process.env.EMBEDDING_MODEL ?? "text-embedding-3-small",
+    dimensions: Number(process.env.EMBEDDING_DIMENSIONS ?? 1536),
+    provider: process.env.EMBEDDING_PROVIDER ?? "openai",
+    batchSize: 100
+  },
+  supportsPromptCaching: (process.env.LLM_DEFAULT_MODEL ?? "claude-sonnet-4-20250514").startsWith("claude"),
+  maxRetries: Number(process.env.LLM_MAX_RETRIES ?? 3),
+  timeoutMs: Number(process.env.LLM_TIMEOUT_MS ?? 3e4),
+  defaultMaxTokens: 4096,
+  defaultTemperature: Number(process.env.LLM_DEFAULT_TEMPERATURE ?? 0.7)
+});
+var LLMConfigFromEnv = Layer.succeed(LLMConfig, llmConfigFromEnv);
 
 // src/prompt-manager.ts
 import { Effect as Effect3, Context as Context3, Layer as Layer2 } from "effect";
@@ -669,6 +1782,14 @@ var toEffectError2 = (error, provider) => {
     cause: error
   });
 };
+var toOpenAITool = (tool) => ({
+  type: "function",
+  function: {
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema
+  }
+});
 var OpenAIProviderLive = Layer4.effect(
   LLMService,
   Effect5.gen(function* () {
@@ -687,14 +1808,22 @@ var OpenAIProviderLive = Layer4.effect(
       complete: (request) => Effect5.gen(function* () {
         const client = getClient();
         const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
+        const messages = toOpenAIMessages(request.messages);
+        if (request.systemPrompt) {
+          messages.unshift({ role: "system", content: request.systemPrompt });
+        }
+        const requestBody = {
+          model,
+          max_tokens: request.maxTokens ?? config.defaultMaxTokens,
+          temperature: request.temperature ?? config.defaultTemperature,
+          messages,
+          stop: request.stopSequences ? [...request.stopSequences] : void 0
+        };
+        if (request.tools && request.tools.length > 0) {
+          requestBody.tools = request.tools.map(toOpenAITool);
+        }
         const response = yield* Effect5.tryPromise({
-          try: () => client.chat.completions.create({
-            model,
-            max_tokens: request.maxTokens ?? config.defaultMaxTokens,
-            temperature: request.temperature ?? config.defaultTemperature,
-            messages: toOpenAIMessages(request.messages),
-            stop: request.stopSequences ? [...request.stopSequences] : void 0
-          }),
+          try: () => client.chat.completions.create(requestBody),
           catch: (error) => toEffectError2(error, "openai")
         });
         return mapOpenAIResponse(response, model);
@@ -722,7 +1851,13 @@ var OpenAIProviderLive = Layer4.effect(
                 model,
                 max_tokens: request.maxTokens ?? config.defaultMaxTokens,
                 temperature: request.temperature ?? config.defaultTemperature,
-                messages: toOpenAIMessages(request.messages),
+                messages: (() => {
+                  const msgs = toOpenAIMessages(request.messages);
+                  if (request.systemPrompt) {
+                    msgs.unshift({ role: "system", content: request.systemPrompt });
+                  }
+                  return msgs;
+                })(),
                 stream: true
               });
               let fullContent = "";
@@ -873,8 +2008,24 @@ No markdown, no code fences, just raw JSON.`
   })
 );
 var mapOpenAIResponse = (response, model) => {
-  const content = response.choices[0]?.message?.content ?? "";
-  const stopReason = response.choices[0]?.finish_reason === "stop" ? "end_turn" : response.choices[0]?.finish_reason === "length" ? "max_tokens" : "end_turn";
+  const message = response.choices[0]?.message;
+  const content = message?.content ?? "";
+  const rawToolCalls = message?.tool_calls;
+  const hasToolCalls = rawToolCalls && rawToolCalls.length > 0;
+  const stopReason = response.choices[0]?.finish_reason === "tool_calls" || hasToolCalls ? "tool_use" : response.choices[0]?.finish_reason === "stop" ? "end_turn" : response.choices[0]?.finish_reason === "length" ? "max_tokens" : "end_turn";
+  const toolCalls = hasToolCalls ? rawToolCalls.map((tc) => {
+    let input;
+    try {
+      input = JSON.parse(tc.function.arguments);
+    } catch {
+      input = { raw: tc.function.arguments };
+    }
+    return {
+      id: tc.id,
+      name: tc.function.name,
+      input
+    };
+  }) : void 0;
   return {
     content,
     stopReason,
@@ -888,7 +2039,8 @@ var mapOpenAIResponse = (response, model) => {
         model
       )
     },
-    model: response.model ?? model
+    model: response.model ?? model,
+    toolCalls
   };
 };
 
@@ -900,37 +2052,57 @@ var toOllamaMessages = (messages) => messages.map((m) => ({
     (b) => b.type === "text"
   ).map((b) => b.text).join("")
 }));
+var toOllamaTools = (tools) => {
+  if (!tools || tools.length === 0) return void 0;
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+};
+var parseToolCalls = (toolCalls) => {
+  if (!toolCalls || toolCalls.length === 0) return void 0;
+  return toolCalls.map((tc, i) => ({
+    id: `ollama-tc-${Date.now()}-${i}`,
+    name: tc.function.name,
+    input: tc.function.arguments
+  }));
+};
 var LocalProviderLive = Layer5.effect(
   LLMService,
   Effect6.gen(function* () {
     const config = yield* LLMConfig;
     const endpoint = config.ollamaEndpoint ?? "http://localhost:11434";
     const defaultModel = config.defaultModel.startsWith("claude") || config.defaultModel.startsWith("gpt") ? "llama3" : config.defaultModel;
+    const getClient = async () => {
+      const { Ollama: Ollama3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      return new Ollama3({ host: endpoint });
+    };
     return LLMService.of({
       complete: (request) => Effect6.gen(function* () {
         const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
         const response = yield* Effect6.tryPromise({
           try: async () => {
-            const res = await fetch(`${endpoint}/api/chat`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                model,
-                messages: toOllamaMessages(request.messages),
-                stream: false,
-                options: {
-                  temperature: request.temperature ?? config.defaultTemperature,
-                  num_predict: request.maxTokens ?? config.defaultMaxTokens,
-                  stop: request.stopSequences ? [...request.stopSequences] : void 0
-                }
-              })
-            });
-            if (!res.ok) {
-              throw new Error(
-                `Ollama request failed: ${res.status} ${res.statusText}`
-              );
+            const client = await getClient();
+            const msgs = toOllamaMessages(request.messages);
+            if (request.systemPrompt) {
+              msgs.unshift({ role: "system", content: request.systemPrompt });
             }
-            return await res.json();
+            return client.chat({
+              model,
+              messages: msgs,
+              tools: toOllamaTools(request.tools),
+              stream: false,
+              keep_alive: "5m",
+              options: {
+                temperature: request.temperature ?? config.defaultTemperature,
+                num_predict: request.maxTokens ?? config.defaultMaxTokens,
+                stop: request.stopSequences ? [...request.stopSequences] : void 0
+              }
+            });
           },
           catch: (error) => new LLMError({
             message: `Ollama request failed: ${error}`,
@@ -941,9 +2113,13 @@ var LocalProviderLive = Layer5.effect(
         const content = response.message?.content ?? "";
         const inputTokens = response.prompt_eval_count ?? 0;
         const outputTokens = response.eval_count ?? 0;
+        const toolCalls = parseToolCalls(
+          response.message?.tool_calls
+        );
+        const hasToolCalls = toolCalls && toolCalls.length > 0;
         return {
           content,
-          stopReason: response.done_reason === "stop" ? "end_turn" : response.done_reason === "length" ? "max_tokens" : "end_turn",
+          stopReason: hasToolCalls ? "tool_use" : response.done_reason === "stop" ? "end_turn" : response.done_reason === "length" ? "max_tokens" : "end_turn",
           usage: {
             inputTokens,
             outputTokens,
@@ -951,18 +2127,19 @@ var LocalProviderLive = Layer5.effect(
             estimatedCost: 0
             // Local models are free
           },
-          model: response.model ?? model
+          model: response.model ?? model,
+          toolCalls
         };
       }).pipe(
         Effect6.retry(retryPolicy),
-        Effect6.timeout("60 seconds"),
+        Effect6.timeout("120 seconds"),
         Effect6.catchTag(
           "TimeoutException",
           () => Effect6.fail(
             new LLMTimeoutError({
               message: "Local LLM request timed out",
               provider: "ollama",
-              timeoutMs: 6e4
+              timeoutMs: 12e4
             })
           )
         )
@@ -972,54 +2149,46 @@ var LocalProviderLive = Layer5.effect(
         return Stream3.async((emit) => {
           const doStream = async () => {
             try {
-              const res = await fetch(`${endpoint}/api/chat`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                  model,
-                  messages: toOllamaMessages(request.messages),
-                  stream: true,
-                  options: {
-                    temperature: request.temperature ?? config.defaultTemperature,
-                    num_predict: request.maxTokens ?? config.defaultMaxTokens
-                  }
-                })
-              });
-              if (!res.ok || !res.body) {
-                throw new Error(`Ollama stream failed: ${res.status}`);
+              const client = await getClient();
+              const msgs = toOllamaMessages(request.messages);
+              if (request.systemPrompt) {
+                msgs.unshift({ role: "system", content: request.systemPrompt });
               }
-              const reader = res.body.getReader();
-              const decoder = new TextDecoder();
+              const stream = await client.chat({
+                model,
+                messages: msgs,
+                tools: toOllamaTools(request.tools),
+                stream: true,
+                keep_alive: "5m",
+                options: {
+                  temperature: request.temperature ?? config.defaultTemperature,
+                  num_predict: request.maxTokens ?? config.defaultMaxTokens
+                }
+              });
               let fullContent = "";
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                const lines = decoder.decode(value, { stream: true }).split("\n").filter(Boolean);
-                for (const line of lines) {
-                  const parsed = JSON.parse(line);
-                  if (parsed.message?.content) {
-                    fullContent += parsed.message.content;
-                    emit.single({
-                      type: "text_delta",
-                      text: parsed.message.content
-                    });
-                  }
-                  if (parsed.done) {
-                    emit.single({
-                      type: "content_complete",
-                      content: fullContent
-                    });
-                    emit.single({
-                      type: "usage",
-                      usage: {
-                        inputTokens: parsed.prompt_eval_count ?? 0,
-                        outputTokens: parsed.eval_count ?? 0,
-                        totalTokens: (parsed.prompt_eval_count ?? 0) + (parsed.eval_count ?? 0),
-                        estimatedCost: 0
-                      }
-                    });
-                    emit.end();
-                  }
+              for await (const chunk of stream) {
+                if (chunk.message?.content) {
+                  fullContent += chunk.message.content;
+                  emit.single({
+                    type: "text_delta",
+                    text: chunk.message.content
+                  });
+                }
+                if (chunk.done) {
+                  emit.single({
+                    type: "content_complete",
+                    content: fullContent
+                  });
+                  emit.single({
+                    type: "usage",
+                    usage: {
+                      inputTokens: chunk.prompt_eval_count ?? 0,
+                      outputTokens: chunk.eval_count ?? 0,
+                      totalTokens: (chunk.prompt_eval_count ?? 0) + (chunk.eval_count ?? 0),
+                      estimatedCost: 0
+                    }
+                  });
+                  emit.end();
                 }
               }
             } catch (error) {
@@ -1042,79 +2211,68 @@ var LocalProviderLive = Layer5.effect(
           null,
           2
         );
-        const messagesWithFormat = [
-          ...request.messages,
-          {
-            role: "user",
-            content: `
+        const model = typeof request.model === "string" ? request.model : request.model?.model ?? defaultModel;
+        let lastError = null;
+        const maxRetries = request.maxParseRetries ?? 2;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          const msgs = toOllamaMessages(
+            attempt === 0 ? [
+              ...request.messages,
+              {
+                role: "user",
+                content: `
+Respond with ONLY valid JSON matching this schema:
+${schemaStr}
+
+No markdown, no code fences, just raw JSON.`
+              }
+            ] : [
+              ...request.messages,
+              {
+                role: "user",
+                content: `
 Respond with ONLY valid JSON matching this schema:
 ${schemaStr}
 
 No markdown, no code fences, just raw JSON.`
-          }
-        ];
-        let lastError = null;
-        const maxRetries = request.maxParseRetries ?? 2;
-        const llm = {
-          complete: (req) => Effect6.gen(function* () {
-            const model = req.model?.model ?? defaultModel;
-            const res = yield* Effect6.tryPromise({
-              try: async () => {
-                const resp = await fetch(`${endpoint}/api/chat`, {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({
-                    model,
-                    messages: toOllamaMessages(req.messages),
-                    stream: false,
-                    options: {
-                      temperature: req.temperature ?? config.defaultTemperature,
-                      num_predict: req.maxTokens ?? config.defaultMaxTokens
-                    }
-                  })
-                });
-                return await resp.json();
               },
-              catch: (error) => new LLMError({
-                message: `Ollama request failed: ${error}`,
-                provider: "ollama",
-                cause: error
-              })
-            });
-            const content = res.message?.content ?? "";
-            const inputTokens = res.prompt_eval_count ?? 0;
-            const outputTokens = res.eval_count ?? 0;
-            return {
-              content,
-              stopReason: "end_turn",
-              usage: {
-                inputTokens,
-                outputTokens,
-                totalTokens: inputTokens + outputTokens,
-                estimatedCost: 0
+              {
+                role: "assistant",
+                content: String(lastError)
               },
-              model: res.model ?? model
-            };
-          })
-        };
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-          const msgs = attempt === 0 ? messagesWithFormat : [
-            ...messagesWithFormat,
-            {
-              role: "assistant",
-              content: String(lastError)
+              {
+                role: "user",
+                content: `That response was not valid JSON. The parse error was: ${String(lastError)}. Please try again with valid JSON only.`
+              }
+            ]
+          );
+          if (request.systemPrompt) {
+            msgs.unshift({ role: "system", content: request.systemPrompt });
+          }
+          const response = yield* Effect6.tryPromise({
+            try: async () => {
+              const client = await getClient();
+              return client.chat({
+                model,
+                messages: msgs,
+                stream: false,
+                format: "json",
+                keep_alive: "5m",
+                options: {
+                  temperature: request.temperature ?? config.defaultTemperature,
+                  num_predict: request.maxTokens ?? config.defaultMaxTokens
+                }
+              });
             },
-            {
-              role: "user",
-              content: `That response was not valid JSON. The parse error was: ${String(lastError)}. Please try again with valid JSON only.`
-            }
-          ];
-          const response = yield* llm.complete({
-            ...request,
-            messages: msgs
+            catch: (error) => new LLMError({
+              message: `Ollama request failed: ${error}`,
+              provider: "ollama",
+              cause: error
+            })
           });
+          const content = response.message?.content ?? "";
           try {
-            const parsed = JSON.parse(response.content);
+            const parsed = JSON.parse(content);
             const decoded = Schema4.decodeUnknownEither(
               request.outputSchema
             )(parsed);
@@ -1136,21 +2294,13 @@ No markdown, no code fences, just raw JSON.`
       }),
       embed: (texts, model) => Effect6.tryPromise({
         try: async () => {
+          const client = await getClient();
           const embeddingModel = model ?? config.embeddingConfig.model ?? "nomic-embed-text";
-          return Promise.all(
-            [...texts].map(async (text) => {
-              const res = await fetch(`${endpoint}/api/embed`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                  model: embeddingModel,
-                  input: text
-                })
-              });
-              const data = await res.json();
-              return data.embeddings[0];
-            })
-          );
+          const response = await client.embed({
+            model: embeddingModel,
+            input: [...texts]
+          });
+          return response.embeddings;
         },
         catch: (error) => new LLMError({
           message: `Embedding failed: ${error}`,
@@ -1622,14 +2772,14 @@ var ComplexityAnalysisSchema = Schema7.Struct({
 
 // src/runtime.ts
 import { Layer as Layer8 } from "effect";
-var createLLMProviderLayer = (provider = "anthropic", testResponses) => {
+var createLLMProviderLayer = (provider = "anthropic", testResponses, model) => {
   if (provider === "test") {
     return Layer8.mergeAll(
       TestLLMServiceLayer(testResponses ?? {}),
       PromptManagerLive
     );
   }
-  const configLayer = LLMConfigFromEnv;
+  const configLayer = model ? Layer8.succeed(LLMConfig, LLMConfig.of({ ...llmConfigFromEnv, defaultModel: model })) : LLMConfigFromEnv;
   const providerLayer = provider === "anthropic" ? AnthropicProviderLive : provider === "openai" ? OpenAIProviderLive : provider === "gemini" ? GeminiProviderLive : LocalProviderLive;
   return Layer8.mergeAll(
     providerLayer.pipe(Layer8.provide(configLayer)),
@@ -1687,6 +2837,7 @@ export {
   createLLMProviderLayer,
   createLLMProviderLayerWithConfig,
   estimateTokenCount,
+  llmConfigFromEnv,
   makeCacheable,
   retryPolicy
 };