@isdk/ai-tool 0.0.3 → 0.0.4

package/dist/{chunk-DGMU4VSJ.mjs → chunk-ZXBTGYVX.mjs}

@@ -1,7 +1,7 @@
 import {
   __export,
   __reExport
-} from "./chunk-EZFPVSGF.mjs";
+} from "./chunk-U5DDQYSF.mjs";
 
 // src/funcs/event.ts
 import { EventEmitter } from "events-ex";
@@ -345,8 +345,7 @@ var ToolFunc = class _ToolFunc extends AdvancePropertyManager {
   runSync(params) {
     const isPosParams = this.params && Array.isArray(this.params);
     if (Array.isArray(params)) {
-      if (isPosParams)
-        return this.func(...params);
+      if (isPosParams) return this.func(...params);
       throwError2("the function is not support array params, the params must be object!", this.name);
     }
     if (isPosParams) {
@@ -554,22 +553,19 @@ var SSEChannel = class {
    * @throws Will throw an error if the channel is closed.
    */
   publish(data, eventName) {
-    if (!this.active)
-      throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
+    if (!this.active) throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
     let output;
     let id;
     let _eventName = eventName;
     if (!data && !eventName) {
-      if (!this.clients.size)
-        return;
+      if (!this.clients.size) return;
       output = "data: \n\n";
     } else {
       id = this.nextID++;
       if (typeof data === "object") {
         if (data.event) {
           _eventName = data.event;
-          if (data.data !== void 0)
-            data = JSON.stringify(data.data);
+          if (data.data !== void 0) data = JSON.stringify(data.data);
         } else {
           data = JSON.stringify(data);
         }
@@ -596,8 +592,7 @@ var SSEChannel = class {
    * @throws Will throw an error if the channel is closed.
    */
   subscribe(req, res, events) {
-    if (!this.active)
-      throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
+    if (!this.active) throwError2("Channel closed", "SSEChannel", SSEChannelAlreadyClosedErrCode);
     const c = { req, res, events };
     const maxStreamDuration = this.options.maxStreamDuration;
     let cacheControl = "max-age=0, stale-while-revalidate=0, stale-if-error=0, no-transform";
@@ -758,8 +753,7 @@ import { env as _env, pipeline as _pipeline, cos_sim as _cos_sim } from "@xenova
 import { Cache as _Cache } from "secondary-cache";
 function _lrucache({ key, value, options } = {}) {
   if (key === void 0) {
-    if (options)
-      this.cache.setDefaultOptions(options);
+    if (options) this.cache.setDefaultOptions(options);
   } else if (value === null) {
     return this.cache.del(key);
   } else if (value !== void 0) {
@@ -1012,8 +1006,7 @@ async function _splitSegments({ texts, model } = {}) {
       }
     }
   }
-  if (segment.length)
-    segments2.push([...segment]);
+  if (segment.length) segments2.push([...segment]);
   return segments2;
 }
 var splitSegments = new ServerTools("splitSegments", {
@@ -1621,8 +1614,7 @@ function tokenize(source, options = {}) {
     while (predicate(src[cursorPosition])) {
       if (src[cursorPosition] === "\\") {
         ++cursorPosition;
-        if (cursorPosition >= src.length)
-          throw new SyntaxError("Unexpected end of input");
+        if (cursorPosition >= src.length) throw new SyntaxError("Unexpected end of input");
         const escaped = src[cursorPosition++];
         const unescaped = ESCAPE_CHARACTERS.get(escaped);
         if (unescaped === void 0) {
@@ -1632,83 +1624,81 @@ function tokenize(source, options = {}) {
         continue;
       }
       str += src[cursorPosition++];
-      if (cursorPosition >= src.length)
-        throw new SyntaxError("Unexpected end of input");
+      if (cursorPosition >= src.length) throw new SyntaxError("Unexpected end of input");
     }
     return str;
   };
-  main:
-    while (cursorPosition < src.length) {
-      const lastTokenType = tokens.at(-1)?.type;
-      if (lastTokenType === void 0 || lastTokenType === TOKEN_TYPES.CloseStatement || lastTokenType === TOKEN_TYPES.CloseExpression) {
-        let text = "";
-        while (cursorPosition < src.length && // Keep going until we hit the next Jinja statement or expression
-        !(src[cursorPosition] === "{" && (src[cursorPosition + 1] === "%" || src[cursorPosition + 1] === "{"))) {
-          text += src[cursorPosition++];
-        }
-        if (text.length > 0) {
-          tokens.push(new Token(text, TOKEN_TYPES.Text));
-          continue;
-        }
-      }
-      consumeWhile((char2) => /\s/.test(char2));
-      const char = src[cursorPosition];
-      if (char === "-" || char === "+") {
-        const lastTokenType2 = tokens.at(-1)?.type;
-        if (lastTokenType2 === TOKEN_TYPES.Text || lastTokenType2 === void 0) {
-          throw new SyntaxError(`Unexpected character: ${char}`);
-        }
-        switch (lastTokenType2) {
-          case TOKEN_TYPES.Identifier:
-          case TOKEN_TYPES.NumericLiteral:
-          case TOKEN_TYPES.BooleanLiteral:
-          case TOKEN_TYPES.StringLiteral:
-          case TOKEN_TYPES.CloseParen:
-          case TOKEN_TYPES.CloseSquareBracket:
-            break;
-          default: {
-            ++cursorPosition;
-            const num = consumeWhile(isInteger);
-            tokens.push(
-              new Token(`${char}${num}`, num.length > 0 ? TOKEN_TYPES.NumericLiteral : TOKEN_TYPES.UnaryOperator)
-            );
-            continue;
-          }
-        }
+  main: while (cursorPosition < src.length) {
+    const lastTokenType = tokens.at(-1)?.type;
+    if (lastTokenType === void 0 || lastTokenType === TOKEN_TYPES.CloseStatement || lastTokenType === TOKEN_TYPES.CloseExpression) {
+      let text = "";
+      while (cursorPosition < src.length && // Keep going until we hit the next Jinja statement or expression
+      !(src[cursorPosition] === "{" && (src[cursorPosition + 1] === "%" || src[cursorPosition + 1] === "{"))) {
+        text += src[cursorPosition++];
+      }
+      if (text.length > 0) {
+        tokens.push(new Token(text, TOKEN_TYPES.Text));
+        continue;
       }
-      for (const [char2, token] of ORDERED_MAPPING_TABLE) {
-        const slice2 = src.slice(cursorPosition, cursorPosition + char2.length);
-        if (slice2 === char2) {
-          tokens.push(new Token(char2, token));
-          cursorPosition += char2.length;
-          continue main;
+    }
+    consumeWhile((char2) => /\s/.test(char2));
+    const char = src[cursorPosition];
+    if (char === "-" || char === "+") {
+      const lastTokenType2 = tokens.at(-1)?.type;
+      if (lastTokenType2 === TOKEN_TYPES.Text || lastTokenType2 === void 0) {
+        throw new SyntaxError(`Unexpected character: ${char}`);
+      }
+      switch (lastTokenType2) {
+        case TOKEN_TYPES.Identifier:
+        case TOKEN_TYPES.NumericLiteral:
+        case TOKEN_TYPES.BooleanLiteral:
+        case TOKEN_TYPES.StringLiteral:
+        case TOKEN_TYPES.CloseParen:
+        case TOKEN_TYPES.CloseSquareBracket:
+          break;
+        default: {
+          ++cursorPosition;
+          const num = consumeWhile(isInteger);
+          tokens.push(
+            new Token(`${char}${num}`, num.length > 0 ? TOKEN_TYPES.NumericLiteral : TOKEN_TYPES.UnaryOperator)
+          );
+          continue;
         }
       }
-      if (char === "'" || char === '"') {
-        ++cursorPosition;
-        const str = consumeWhile((c) => c !== char);
-        tokens.push(new Token(str, TOKEN_TYPES.StringLiteral));
-        ++cursorPosition;
-        continue;
-      }
-      if (isInteger(char)) {
-        const num = consumeWhile(isInteger);
-        tokens.push(new Token(num, TOKEN_TYPES.NumericLiteral));
-        continue;
+    }
+    for (const [char2, token] of ORDERED_MAPPING_TABLE) {
+      const slice2 = src.slice(cursorPosition, cursorPosition + char2.length);
+      if (slice2 === char2) {
+        tokens.push(new Token(char2, token));
+        cursorPosition += char2.length;
+        continue main;
       }
-      if (isWord(char)) {
-        const word = consumeWhile(isWord);
-        const type = Object.hasOwn(KEYWORDS, word) ? KEYWORDS[word] : TOKEN_TYPES.Identifier;
-        if (type === TOKEN_TYPES.In && tokens.at(-1)?.type === TOKEN_TYPES.Not) {
-          tokens.pop();
-          tokens.push(new Token("not in", TOKEN_TYPES.NotIn));
-        } else {
-          tokens.push(new Token(word, type));
-        }
-        continue;
+    }
+    if (char === "'" || char === '"') {
+      ++cursorPosition;
+      const str = consumeWhile((c) => c !== char);
+      tokens.push(new Token(str, TOKEN_TYPES.StringLiteral));
+      ++cursorPosition;
+      continue;
+    }
+    if (isInteger(char)) {
+      const num = consumeWhile(isInteger);
+      tokens.push(new Token(num, TOKEN_TYPES.NumericLiteral));
+      continue;
+    }
+    if (isWord(char)) {
+      const word = consumeWhile(isWord);
+      const type = Object.hasOwn(KEYWORDS, word) ? KEYWORDS[word] : TOKEN_TYPES.Identifier;
+      if (type === TOKEN_TYPES.In && tokens.at(-1)?.type === TOKEN_TYPES.Not) {
+        tokens.pop();
+        tokens.push(new Token("not in", TOKEN_TYPES.NotIn));
+      } else {
+        tokens.push(new Token(word, type));
       }
-      throw new SyntaxError(`Unexpected character: ${char}`);
+      continue;
     }
+    throw new SyntaxError(`Unexpected character: ${char}`);
+  }
   return tokens;
 }
 
@@ -3004,8 +2994,7 @@ var Interpreter = class {
     return new StringValue(result);
   }
   evaluate(statement, environment) {
-    if (statement === void 0)
-      return new UndefinedValue();
+    if (statement === void 0) return new UndefinedValue();
     switch (statement.type) {
       case "Program":
         return this.evalProgram(statement, environment);
@@ -3824,8 +3813,7 @@ function createEventStreamTransformer(customParser) {
             const parsedMessage = customParser ? customParser(event2.data, {
               event: event2.event
             }) : event2.data;
-            if (parsedMessage)
-              controller.enqueue(parsedMessage);
+            if (parsedMessage) controller.enqueue(parsedMessage);
           }
         }
       );
@@ -3841,15 +3829,13 @@ function createCallbacksTransformer(cb) {
   const callbacks = cb || {};
   return new TransformStream({
     async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
+      if (callbacks.onStart) await callbacks.onStart();
     },
     async transform(message, controller) {
       const content = typeof message === "string" ? message : message.content;
       controller.enqueue(textEncoder.encode(content));
       aggregatedResponse += content;
-      if (callbacks.onToken)
-        await callbacks.onToken(content);
+      if (callbacks.onToken) await callbacks.onToken(content);
       if (callbacks.onText && typeof message === "string") {
         await callbacks.onText(message);
       }
@@ -3869,8 +3855,7 @@ function trimStartOfStreamHelper() {
   return (text) => {
     if (isStreamStart) {
       text = text.trimStart();
-      if (text)
-        isStreamStart = false;
+      if (text) isStreamStart = false;
     }
     return text;
   };
@@ -3897,10 +3882,8 @@ function readableFromAsyncIterable(iterable) {
   return new ReadableStream({
     async pull(controller) {
       const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
+      if (done) controller.close();
+      else controller.enqueue(value);
     },
     async cancel(reason) {
       await it.return?.(reason);
@@ -3974,8 +3957,7 @@ var XXHashAlgorithm = /* @__PURE__ */ ((XXHashAlgorithm2) => {
   return XXHashAlgorithm2;
 })(XXHashAlgorithm || {});
 function xxhash(value, hashAlgo = 111 /* xxhash64 */, seed = SEED) {
-  if (value.buffer)
-    value = value.buffer;
+  if (value.buffer) value = value.buffer;
   let result;
   if (hashAlgo !== 112 /* xxhash32 */) {
     result = h64(value, seed);
@@ -4164,8 +4146,7 @@ function isObject(value) {
   return !!value && value.constructor === Object;
 }
 function getKeysPath(value) {
-  if (!value)
-    return [];
+  if (!value) return [];
   return getKeys(value, [], "");
 }
 function getKeys(obj, paths, dot = ".") {
@@ -4387,27 +4368,26 @@ function jsonFilterToWhere(filter, wrapKey) {
   }
   if (Array.isArray(filter)) {
     andQuery.push(generateAndClause(filter, wrapKey));
-  } else
-    for (const [key, value] of Object.entries(filter)) {
-      if (key === "$and") {
-        andQuery.push(`(${generateAndClause(filter[key], wrapKey)})`);
-      } else if (key === "$or") {
-        andQuery.push(`(${generateOrClause(filter[key], wrapKey)})`);
+  } else for (const [key, value] of Object.entries(filter)) {
+    if (key === "$and") {
+      andQuery.push(`(${generateAndClause(filter[key], wrapKey)})`);
+    } else if (key === "$or") {
+      andQuery.push(`(${generateOrClause(filter[key], wrapKey)})`);
+    } else {
+      const tValue = typeof value;
+      if (value == null) {
+        andQuery.push(`${wrapKey(key)} IS NULL`);
+      } else if (tValue === "object" && !Array.isArray(value)) {
+        andQuery.push(generateCondition(wrapKey(key), value));
+      } else if (tValue === "string") {
+        andQuery.push(`${wrapKey(key)}='${value}'`);
+      } else if (tValue === "number" || tValue === "boolean") {
+        andQuery.push(`${wrapKey(key)}=${value}`);
       } else {
-        const tValue = typeof value;
-        if (value == null) {
-          andQuery.push(`${wrapKey(key)} IS NULL`);
-        } else if (tValue === "object" && !Array.isArray(value)) {
-          andQuery.push(generateCondition(wrapKey(key), value));
-        } else if (tValue === "string") {
-          andQuery.push(`${wrapKey(key)}='${value}'`);
-        } else if (tValue === "number" || tValue === "boolean") {
-          andQuery.push(`${wrapKey(key)}=${value}`);
-        } else {
-          throw new Error(`Unsupported value type for key ${key}`);
-        }
+        throw new Error(`Unsupported value type for key ${key}`);
       }
     }
+  }
   ;
   return andQuery.length > 1 ? andQuery.join(" AND ") : andQuery[0];
 }
@@ -4435,8 +4415,7 @@ var ClientTools = class _ClientTools extends ToolFunc {
         "Content-Type": "application/json"
       } });
       const items = await res.json();
-      if (items)
-        this.loadFromSync(items);
+      if (items) this.loadFromSync(items);
     } else {
       throwError2("missing apiRoot to load tools", "ClientTools");
     }
@@ -4742,8 +4721,7 @@ var EventClient = class extends ResClientTools {
     for (const event2 of events) {
       if (!this._forwardEvents.has(event2)) {
         this._forwardEvents.add(event2);
-        if (this.on)
-          this.on(event2, this.ebListener);
+        if (this.on) this.on(event2, this.ebListener);
       }
     }
   }
@@ -4762,8 +4740,7 @@ var EventClient = class extends ResClientTools {
     for (const event2 of events) {
       if (this._forwardEvents.has(event2)) {
         this._forwardEvents.delete(event2);
-        if (this.off)
-          this.off(event2, this.ebListener);
+        if (this.off) this.off(event2, this.ebListener);
       }
     }
   }