osagent 0.1.91 → 0.1.93

package/cli.js

@@ -23059,250 +23059,6 @@ var require_utils2 = __commonJS({
   }
 });
 
-// node_modules/punycode/punycode.js
-var require_punycode = __commonJS({
-  "node_modules/punycode/punycode.js"(exports2, module2) {
-    "use strict";
-    init_esbuild_shims();
-    var maxInt = 2147483647;
-    var base = 36;
-    var tMin = 1;
-    var tMax = 26;
-    var skew = 38;
-    var damp = 700;
-    var initialBias = 72;
-    var initialN = 128;
-    var delimiter2 = "-";
-    var regexPunycode = /^xn--/;
-    var regexNonASCII = /[^\0-\x7F]/;
-    var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
-    var errors = {
-      "overflow": "Overflow: input needs wider integers to process",
-      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
-      "invalid-input": "Invalid input"
-    };
-    var baseMinusTMin = base - tMin;
-    var floor = Math.floor;
-    var stringFromCharCode = String.fromCharCode;
-    function error2(type) {
-      throw new RangeError(errors[type]);
-    }
-    __name(error2, "error");
-    function map2(array2, callback) {
-      const result = [];
-      let length = array2.length;
-      while (length--) {
-        result[length] = callback(array2[length]);
-      }
-      return result;
-    }
-    __name(map2, "map");
-    function mapDomain(domain, callback) {
-      const parts = domain.split("@");
-      let result = "";
-      if (parts.length > 1) {
-        result = parts[0] + "@";
-        domain = parts[1];
-      }
-      domain = domain.replace(regexSeparators, ".");
-      const labels = domain.split(".");
-      const encoded = map2(labels, callback).join(".");
-      return result + encoded;
-    }
-    __name(mapDomain, "mapDomain");
-    function ucs2decode(string4) {
-      const output = [];
-      let counter = 0;
-      const length = string4.length;
-      while (counter < length) {
-        const value = string4.charCodeAt(counter++);
-        if (value >= 55296 && value <= 56319 && counter < length) {
-          const extra = string4.charCodeAt(counter++);
-          if ((extra & 64512) == 56320) {
-            output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
-          } else {
-            output.push(value);
-            counter--;
-          }
-        } else {
-          output.push(value);
-        }
-      }
-      return output;
-    }
-    __name(ucs2decode, "ucs2decode");
-    var ucs2encode = /* @__PURE__ */ __name((codePoints) => String.fromCodePoint(...codePoints), "ucs2encode");
-    var basicToDigit = /* @__PURE__ */ __name(function(codePoint) {
-      if (codePoint >= 48 && codePoint < 58) {
-        return 26 + (codePoint - 48);
-      }
-      if (codePoint >= 65 && codePoint < 91) {
-        return codePoint - 65;
-      }
-      if (codePoint >= 97 && codePoint < 123) {
-        return codePoint - 97;
-      }
-      return base;
-    }, "basicToDigit");
-    var digitToBasic = /* @__PURE__ */ __name(function(digit, flag) {
-      return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-    }, "digitToBasic");
-    var adapt = /* @__PURE__ */ __name(function(delta, numPoints, firstTime) {
-      let k = 0;
-      delta = firstTime ? floor(delta / damp) : delta >> 1;
-      delta += floor(delta / numPoints);
-      for (; delta > baseMinusTMin * tMax >> 1; k += base) {
-        delta = floor(delta / baseMinusTMin);
-      }
-      return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
-    }, "adapt");
-    var decode2 = /* @__PURE__ */ __name(function(input) {
-      const output = [];
-      const inputLength = input.length;
-      let i = 0;
-      let n2 = initialN;
-      let bias = initialBias;
-      let basic = input.lastIndexOf(delimiter2);
-      if (basic < 0) {
-        basic = 0;
-      }
-      for (let j = 0; j < basic; ++j) {
-        if (input.charCodeAt(j) >= 128) {
-          error2("not-basic");
-        }
-        output.push(input.charCodeAt(j));
-      }
-      for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
-        const oldi = i;
-        for (let w = 1, k = base; ; k += base) {
-          if (index >= inputLength) {
-            error2("invalid-input");
-          }
-          const digit = basicToDigit(input.charCodeAt(index++));
-          if (digit >= base) {
-            error2("invalid-input");
-          }
-          if (digit > floor((maxInt - i) / w)) {
-            error2("overflow");
-          }
-          i += digit * w;
-          const t3 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-          if (digit < t3) {
-            break;
-          }
-          const baseMinusT = base - t3;
-          if (w > floor(maxInt / baseMinusT)) {
-            error2("overflow");
-          }
-          w *= baseMinusT;
-        }
-        const out = output.length + 1;
-        bias = adapt(i - oldi, out, oldi == 0);
-        if (floor(i / out) > maxInt - n2) {
-          error2("overflow");
-        }
-        n2 += floor(i / out);
-        i %= out;
-        output.splice(i++, 0, n2);
-      }
-      return String.fromCodePoint(...output);
-    }, "decode");
-    var encode4 = /* @__PURE__ */ __name(function(input) {
-      const output = [];
-      input = ucs2decode(input);
-      const inputLength = input.length;
-      let n2 = initialN;
-      let delta = 0;
-      let bias = initialBias;
-      for (const currentValue of input) {
-        if (currentValue < 128) {
-          output.push(stringFromCharCode(currentValue));
-        }
-      }
-      const basicLength = output.length;
-      let handledCPCount = basicLength;
-      if (basicLength) {
-        output.push(delimiter2);
-      }
-      while (handledCPCount < inputLength) {
-        let m = maxInt;
-        for (const currentValue of input) {
-          if (currentValue >= n2 && currentValue < m) {
-            m = currentValue;
-          }
-        }
-        const handledCPCountPlusOne = handledCPCount + 1;
-        if (m - n2 > floor((maxInt - delta) / handledCPCountPlusOne)) {
-          error2("overflow");
-        }
-        delta += (m - n2) * handledCPCountPlusOne;
-        n2 = m;
-        for (const currentValue of input) {
-          if (currentValue < n2 && ++delta > maxInt) {
-            error2("overflow");
-          }
-          if (currentValue === n2) {
-            let q = delta;
-            for (let k = base; ; k += base) {
-              const t3 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-              if (q < t3) {
-                break;
-              }
-              const qMinusT = q - t3;
-              const baseMinusT = base - t3;
-              output.push(
-                stringFromCharCode(digitToBasic(t3 + qMinusT % baseMinusT, 0))
-              );
-              q = floor(qMinusT / baseMinusT);
-            }
-            output.push(stringFromCharCode(digitToBasic(q, 0)));
-            bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
-            delta = 0;
-            ++handledCPCount;
-          }
-        }
-        ++delta;
-        ++n2;
-      }
-      return output.join("");
-    }, "encode");
-    var toUnicode = /* @__PURE__ */ __name(function(input) {
-      return mapDomain(input, function(string4) {
-        return regexPunycode.test(string4) ? decode2(string4.slice(4).toLowerCase()) : string4;
-      });
-    }, "toUnicode");
-    var toASCII = /* @__PURE__ */ __name(function(input) {
-      return mapDomain(input, function(string4) {
-        return regexNonASCII.test(string4) ? "xn--" + encode4(string4) : string4;
-      });
-    }, "toASCII");
-    var punycode = {
-      /**
-       * A string representing the current Punycode.js version number.
-       * @memberOf punycode
-       * @type String
-       */
-      "version": "2.3.1",
-      /**
-       * An object of methods to convert from JavaScript's internal character
-       * representation (UCS-2) to Unicode code points, and back.
-       * @see <https://mathiasbynens.be/notes/javascript-encoding>
-       * @memberOf punycode
-       * @type Object
-       */
-      "ucs2": {
-        "decode": ucs2decode,
-        "encode": ucs2encode
-      },
-      "decode": decode2,
-      "encode": encode4,
-      "toASCII": toASCII,
-      "toUnicode": toUnicode
-    };
-    module2.exports = punycode;
-  }
-});
-
 // node_modules/node-fetch/node_modules/tr46/lib/mappingTable.json
 var require_mappingTable = __commonJS({
   "node_modules/node-fetch/node_modules/tr46/lib/mappingTable.json"(exports2, module2) {
@@ -23315,7 +23071,7 @@ var require_tr46 = __commonJS({
   "node_modules/node-fetch/node_modules/tr46/index.js"(exports2, module2) {
     "use strict";
     init_esbuild_shims();
-    var punycode = require_punycode();
+    var punycode = __require("punycode");
     var mappingTable = require_mappingTable();
     var PROCESSING_OPTIONS = {
       TRANSITIONAL: 0,
@@ -23483,7 +23239,7 @@ var require_url_state_machine = __commonJS({
   "node_modules/node-fetch/node_modules/whatwg-url/lib/url-state-machine.js"(exports2, module2) {
     "use strict";
     init_esbuild_shims();
-    var punycode = require_punycode();
+    var punycode = __require("punycode");
     var tr46 = require_tr46();
     var specialSchemes = {
       ftp: 21,
@@ -145605,13 +145361,492 @@ ${[...baseTips, ...streamingSpecificTips].join("\n")}`;
   }
 });
 
+// node_modules/tiktoken/tiktoken_bg.cjs
+var require_tiktoken_bg = __commonJS({
+  "node_modules/tiktoken/tiktoken_bg.cjs"(exports2, module2) {
+    init_esbuild_shims();
+    var wasm2;
+    module2.exports.__wbg_set_wasm = function(val) {
+      wasm2 = val;
+    };
+    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module2.require)("util").TextDecoder : TextDecoder;
+    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    var cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm2.memory.buffer);
+      }
+      return cachedUint8ArrayMemory0;
+    }
+    __name(getUint8ArrayMemory0, "getUint8ArrayMemory0");
+    function getStringFromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+    __name(getStringFromWasm0, "getStringFromWasm0");
+    var heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    var heap_next = heap.length;
+    function addHeapObject(obj) {
+      if (heap_next === heap.length) heap.push(heap.length + 1);
+      const idx = heap_next;
+      heap_next = heap[idx];
+      heap[idx] = obj;
+      return idx;
+    }
+    __name(addHeapObject, "addHeapObject");
+    function handleError2(f, args) {
+      try {
+        return f.apply(this, args);
+      } catch (e2) {
+        wasm2.__wbindgen_export_0(addHeapObject(e2));
+      }
+    }
+    __name(handleError2, "handleError");
+    function getObject2(idx) {
+      return heap[idx];
+    }
+    __name(getObject2, "getObject");
+    function dropObject(idx) {
+      if (idx < 132) return;
+      heap[idx] = heap_next;
+      heap_next = idx;
+    }
+    __name(dropObject, "dropObject");
+    function takeObject(idx) {
+      const ret = getObject2(idx);
+      dropObject(idx);
+      return ret;
+    }
+    __name(takeObject, "takeObject");
+    var WASM_VECTOR_LEN = 0;
+    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module2.require)("util").TextEncoder : TextEncoder;
+    var cachedTextEncoder = new lTextEncoder("utf-8");
+    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+      return cachedTextEncoder.encodeInto(arg, view);
+    } : function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+    function passStringToWasm0(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory0();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code2 = arg.charCodeAt(offset);
+        if (code2 > 127) break;
+        mem[ptr + offset] = code2;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN = offset;
+      return ptr;
+    }
+    __name(passStringToWasm0, "passStringToWasm0");
+    function isLikeNone(x) {
+      return x === void 0 || x === null;
+    }
+    __name(isLikeNone, "isLikeNone");
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm2.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm2.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    __name(getDataViewMemory0, "getDataViewMemory0");
+    var cachedUint32ArrayMemory0 = null;
+    function getUint32ArrayMemory0() {
+      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm2.memory.buffer);
+      }
+      return cachedUint32ArrayMemory0;
+    }
+    __name(getUint32ArrayMemory0, "getUint32ArrayMemory0");
+    function getArrayU32FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    }
+    __name(getArrayU32FromWasm0, "getArrayU32FromWasm0");
+    function passArray8ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 1, 1) >>> 0;
+      getUint8ArrayMemory0().set(arg, ptr / 1);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    __name(passArray8ToWasm0, "passArray8ToWasm0");
+    function passArray32ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 4, 4) >>> 0;
+      getUint32ArrayMemory0().set(arg, ptr / 4);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    __name(passArray32ToWasm0, "passArray32ToWasm0");
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+    __name(getArrayU8FromWasm0, "getArrayU8FromWasm0");
+    module2.exports.get_encoding = function(encoding, extend_special_tokens) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(encoding, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r22) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.encoding_for_model = function(model, extend_special_tokens) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r22) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.get_encoding_name_for_model = function(model) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      let deferred3_0;
+      let deferred3_1;
+      try {
+        const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm2.get_encoding_name_for_model(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+          ptr2 = 0;
+          len2 = 0;
+          throw takeObject(r22);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+      } finally {
+        wasm2.__wbindgen_add_to_stack_pointer(16);
+        wasm2.__wbindgen_export_3(deferred3_0, deferred3_1, 1);
+      }
+    };
+    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: /* @__PURE__ */ __name(() => {
+    }, "register"), unregister: /* @__PURE__ */ __name(() => {
+    }, "unregister") } : new FinalizationRegistry((ptr) => wasm2.__wbg_tiktoken_free(ptr >>> 0, 1));
+    var Tiktoken = class _Tiktoken {
+      static {
+        __name(this, "Tiktoken");
+      }
+      /**
+       * @param {string} tiktoken_bfe
+       * @param {any} special_tokens
+       * @param {string} pat_str
+       */
+      constructor(tiktoken_bfe, special_tokens, pat_str) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pat_str, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm2.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        TiktokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /** @returns {string | undefined} */
+      get name() {
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          wasm2.tiktoken_name(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          let v12;
+          if (r0 !== 0) {
+            v12 = getStringFromWasm0(r0, r1).slice();
+            wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          }
+          return v12;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Tiktoken.prototype);
+        obj.__wbg_ptr = ptr;
+        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TiktokenFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr = this.__destroy_into_raw();
+        wasm2.__wbg_tiktoken_free(ptr, 0);
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {Uint32Array}
+       */
+      encode(text, allowed_special, disallowed_special) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          if (r3) {
+            throw takeObject(r22);
+          }
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @returns {Uint32Array}
+       */
+      encode_ordinary(text) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {any}
+       */
+      encode_with_unstable(text, allowed_special, disallowed_special) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r22 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r22) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {Uint8Array} bytes
+       * @returns {number}
+       */
+      encode_single_token(bytes) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passArray8ToWasm0(bytes, wasm2.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm2.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+      }
+      /**
+       * @param {Uint32Array} tokens
+       * @returns {Uint8Array}
+       */
+      decode(tokens) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArray32ToWasm0(tokens, wasm2.__wbindgen_export_1);
+          const len0 = WASM_VECTOR_LEN;
+          wasm2.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v2;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {number} token
+       * @returns {Uint8Array}
+       */
+      decode_single_token_bytes(token2) {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm2.__wbindgen_add_to_stack_pointer(-16);
+          wasm2.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token2);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v12 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm2.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v12;
+        } finally {
+          wasm2.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /** @returns {any} */
+      token_byte_values() {
+        if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ret = wasm2.tiktoken_token_byte_values(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+    };
+    module2.exports.Tiktoken = Tiktoken;
+    module2.exports.__wbg_parse_def2e24ef1252aff = function() {
+      return handleError2(function(arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
+      return handleError2(function(arg0) {
+        const ret = JSON.stringify(getObject2(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbindgen_error_new = function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    };
+    module2.exports.__wbindgen_is_undefined = function(arg0) {
+      const ret = getObject2(arg0) === void 0;
+      return ret;
+    };
+    module2.exports.__wbindgen_object_drop_ref = function(arg0) {
+      takeObject(arg0);
+    };
+    module2.exports.__wbindgen_string_get = function(arg0, arg1) {
+      if (wasm2 == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      const obj = getObject2(arg1);
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm2.__wbindgen_export_1, wasm2.__wbindgen_export_2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    module2.exports.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+  }
+});
+
+// node_modules/tiktoken/tiktoken.cjs
+var require_tiktoken = __commonJS({
+  "node_modules/tiktoken/tiktoken.cjs"(exports2) {
+    init_esbuild_shims();
+    var wasm2 = require_tiktoken_bg();
+    var imports = {};
+    imports["./tiktoken_bg.js"] = wasm2;
+    var path119 = __require("path");
+    var fs106 = __require("fs");
+    var candidates = __dirname.split(path119.sep).reduce((memo, _, index, array2) => {
+      const prefix = array2.slice(0, index + 1).join(path119.sep) + path119.sep;
+      if (!prefix.includes("node_modules" + path119.sep)) {
+        memo.unshift(
+          path119.join(
+            prefix,
+            "node_modules",
+            "tiktoken",
+            "",
+            "./tiktoken_bg.wasm"
+          )
+        );
+      }
+      return memo;
+    }, []);
+    candidates.unshift(path119.join(__dirname, "./tiktoken_bg.wasm"));
+    var bytes = null;
+    for (const candidate of candidates) {
+      try {
+        bytes = fs106.readFileSync(candidate);
+        break;
+      } catch {
+      }
+    }
+    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
+    var wasmModule = new WebAssembly.Module(bytes);
+    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+    wasm2.__wbg_set_wasm(wasmInstance.exports);
+    exports2["get_encoding"] = wasm2["get_encoding"];
+    exports2["encoding_for_model"] = wasm2["encoding_for_model"];
+    exports2["get_encoding_name_for_model"] = wasm2["get_encoding_name_for_model"];
+    exports2["Tiktoken"] = wasm2["Tiktoken"];
+  }
+});
+
 // packages/core/dist/src/utils/request-tokenizer/textTokenizer.js
-import { get_encoding } from "tiktoken";
-var TextTokenizer;
+var import_tiktoken, TextTokenizer;
 var init_textTokenizer = __esm({
   "packages/core/dist/src/utils/request-tokenizer/textTokenizer.js"() {
     "use strict";
     init_esbuild_shims();
+    import_tiktoken = __toESM(require_tiktoken(), 1);
     TextTokenizer = class {
       static {
         __name(this, "TextTokenizer");
@@ -145628,7 +145863,7 @@ var init_textTokenizer = __esm({
         if (this.encoding)
           return;
         try {
-          this.encoding = get_encoding(this.encodingName);
+          this.encoding = (0, import_tiktoken.get_encoding)(this.encodingName);
         } catch (error2) {
           console.warn(`Failed to load tiktoken with encoding ${this.encodingName}:`, error2);
           this.encoding = null;
@@ -146777,7 +147012,7 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config2, gcConfig, sessionId2, isInitialAuth) {
-  const version3 = "0.1.90";
+  const version3 = "0.1.93";
   const userAgent2 = `OSAgent/${version3} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -335775,7 +336010,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.90";
+  return "0.1.93";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -339983,8 +340218,8 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "8429295";
-var CLI_VERSION2 = "0.1.90";
+var GIT_COMMIT_INFO2 = "a277a77";
+var CLI_VERSION2 = "0.1.93";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osagent",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "description": "OSAgent - AI-powered CLI for autonomous coding with Ollama, Qwen, and other models",
   "author": "Roberto Luna",
   "license": "Apache-2.0",
@@ -16,13 +16,8 @@
   "engines": {
     "node": ">=20"
   },
-  "keywords": [
-    "ai",
-    "cli",
-    "coding",
-    "assistant",
-    "ollama",
-    "qwen",
-    "agent"
-  ]
+  "optionalDependencies": {
+    "@lydell/node-pty": "^1.0.1"
+  },
+  "keywords": ["ai", "cli", "coding", "assistant", "ollama", "qwen", "agent"]
 }