@jxsuite/ai 0.1.0 → 0.33.0

package/dist/index.js

@@ -1,1531 +0,0 @@
-// src/tools.ts
-function toolError(error) {
-  return { success: false, error };
-}
-function createToolDefinition({
-  name,
-  description,
-  parameters,
-  strict = true,
-  llmStrict = false,
-  execute
-}) {
-  return { name, description, parameters, strict, llmStrict, execute };
-}
-function createToolRegistry() {
-  const _tools = new Map;
-  return {
-    register(tool) {
-      if (_tools.has(tool.name)) {
-        console.warn(`Tool "${tool.name}" is being re-registered.`);
-      }
-      _tools.set(tool.name, tool);
-    },
-    list() {
-      return [..._tools.values()];
-    },
-    listForLLM() {
-      return [..._tools.values()].map((t) => ({
-        type: "function",
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters,
-          ...t.llmStrict === true ? { strict: true } : {}
-        }
-      }));
-    },
-    getDefinition(toolName) {
-      return _tools.get(toolName);
-    },
-    validate(toolName, args) {
-      const tool = _tools.get(toolName);
-      if (!tool) {
-        return { valid: false, errors: [`Unknown tool: "${toolName}"`] };
-      }
-      if (!tool.strict) {
-        return { valid: true };
-      }
-      const schema = tool.parameters;
-      if (!schema || !schema.properties) {
-        return { valid: true };
-      }
-      const errors = [];
-      const props = schema.properties;
-      const required = schema.required || [];
-      const argRecord = args;
-      for (const key of required) {
-        if (!(key in args) || argRecord[key] === undefined || argRecord[key] === null) {
-          errors.push(`Missing required argument: "${key}"`);
-        }
-      }
-      for (const [key, value] of Object.entries(argRecord)) {
-        const propSchema = props[key];
-        if (!propSchema) {
-          continue;
-        }
-        const expectedType = propSchema.type;
-        if (!expectedType) {
-          continue;
-        }
-        const actualType = Array.isArray(value) ? "array" : typeof value;
-        if (expectedType === "number" || expectedType === "integer") {
-          if (actualType === "number") {
-            continue;
-          }
-          if (actualType === "string") {
-            if (!Number.isNaN(Number(value))) {
-              continue;
-            }
-            errors.push(`Argument "${key}" should be a number, got non-numeric string "${value}"`);
-            continue;
-          }
-          errors.push(`Argument "${key}" should be a number, got ${actualType}`);
-          continue;
-        }
-        if (expectedType === "string" && actualType !== "string") {
-          errors.push(`Argument "${key}" should be a string, got ${actualType}`);
-        } else if (expectedType === "boolean" && actualType !== "boolean") {
-          errors.push(`Argument "${key}" should be a boolean, got ${actualType}`);
-        } else if (expectedType === "array" && actualType !== "array") {
-          errors.push(`Argument "${key}" should be an array, got ${actualType}`);
-        } else if (expectedType === "object" && actualType !== "object") {
-          errors.push(`Argument "${key}" should be an object, got ${actualType}`);
-        }
-      }
-      return errors.length > 0 ? { valid: false, errors } : { valid: true };
-    },
-    async execute(toolName, args) {
-      const tool = _tools.get(toolName);
-      if (!tool) {
-        return toolError(`Unknown tool: "${toolName}"`);
-      }
-      const validation = this.validate(toolName, args);
-      if (!validation.valid) {
-        return toolError(`Validation failed: ${(validation.errors || []).join("; ")}`);
-      }
-      try {
-        return await tool.execute(args);
-      } catch (error) {
-        return toolError(`Tool "${toolName}" execution error: ${error.message}`);
-      }
-    }
-  };
-}
-// ../../node_modules/@vue/shared/dist/shared.esm-bundler.js
-function makeMap(str) {
-  const map = /* @__PURE__ */ Object.create(null);
-  for (const key of str.split(","))
-    map[key] = 1;
-  return (val) => (val in map);
-}
-var EMPTY_OBJ = Object.freeze({});
-var EMPTY_ARR = Object.freeze([]);
-var extend = Object.assign;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var hasOwn = (val, key) => hasOwnProperty.call(val, key);
-var isArray = Array.isArray;
-var isMap = (val) => toTypeString(val) === "[object Map]";
-var isString = (val) => typeof val === "string";
-var isSymbol = (val) => typeof val === "symbol";
-var isObject = (val) => val !== null && typeof val === "object";
-var objectToString = Object.prototype.toString;
-var toTypeString = (value) => objectToString.call(value);
-var toRawType = (value) => {
-  return toTypeString(value).slice(8, -1);
-};
-var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
-var cacheStringFunction = (fn) => {
-  const cache = /* @__PURE__ */ Object.create(null);
-  return (str) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  };
-};
-var camelizeRE = /-\w/g;
-var camelize = cacheStringFunction((str) => {
-  return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
-});
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-var capitalize = cacheStringFunction((str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-});
-var toHandlerKey = cacheStringFunction((str) => {
-  const s = str ? `on${capitalize(str)}` : ``;
-  return s;
-});
-var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
-var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
-var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
-
-// ../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
-function warn(msg, ...args) {
-  console.warn(`[Vue warn] ${msg}`, ...args);
-}
-var activeSub;
-var batchDepth = 0;
-var batchedSub;
-var batchedComputed;
-function startBatch() {
-  batchDepth++;
-}
-function endBatch() {
-  if (--batchDepth > 0) {
-    return;
-  }
-  if (batchedComputed) {
-    let e = batchedComputed;
-    batchedComputed = undefined;
-    while (e) {
-      const next = e.next;
-      e.next = undefined;
-      e.flags &= -9;
-      e = next;
-    }
-  }
-  let error;
-  while (batchedSub) {
-    let e = batchedSub;
-    batchedSub = undefined;
-    while (e) {
-      const next = e.next;
-      e.next = undefined;
-      e.flags &= -9;
-      if (e.flags & 1) {
-        try {
-          e.trigger();
-        } catch (err) {
-          if (!error)
-            error = err;
-        }
-      }
-      e = next;
-    }
-  }
-  if (error)
-    throw error;
-}
-var shouldTrack = true;
-var trackStack = [];
-function pauseTracking() {
-  trackStack.push(shouldTrack);
-  shouldTrack = false;
-}
-function resetTracking() {
-  const last = trackStack.pop();
-  shouldTrack = last === undefined ? true : last;
-}
-var globalVersion = 0;
-
-class Link {
-  constructor(sub, dep) {
-    this.sub = sub;
-    this.dep = dep;
-    this.version = dep.version;
-    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = undefined;
-  }
-}
-
-class Dep {
-  constructor(computed) {
-    this.computed = computed;
-    this.version = 0;
-    this.activeLink = undefined;
-    this.subs = undefined;
-    this.map = undefined;
-    this.key = undefined;
-    this.sc = 0;
-    this.__v_skip = true;
-    if (true) {
-      this.subsHead = undefined;
-    }
-  }
-  track(debugInfo) {
-    if (!activeSub || !shouldTrack || activeSub === this.computed) {
-      return;
-    }
-    let link = this.activeLink;
-    if (link === undefined || link.sub !== activeSub) {
-      link = this.activeLink = new Link(activeSub, this);
-      if (!activeSub.deps) {
-        activeSub.deps = activeSub.depsTail = link;
-      } else {
-        link.prevDep = activeSub.depsTail;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-      }
-      addSub(link);
-    } else if (link.version === -1) {
-      link.version = this.version;
-      if (link.nextDep) {
-        const next = link.nextDep;
-        next.prevDep = link.prevDep;
-        if (link.prevDep) {
-          link.prevDep.nextDep = next;
-        }
-        link.prevDep = activeSub.depsTail;
-        link.nextDep = undefined;
-        activeSub.depsTail.nextDep = link;
-        activeSub.depsTail = link;
-        if (activeSub.deps === link) {
-          activeSub.deps = next;
-        }
-      }
-    }
-    if (activeSub.onTrack) {
-      activeSub.onTrack(extend({
-        effect: activeSub
-      }, debugInfo));
-    }
-    return link;
-  }
-  trigger(debugInfo) {
-    this.version++;
-    globalVersion++;
-    this.notify(debugInfo);
-  }
-  notify(debugInfo) {
-    startBatch();
-    try {
-      if (true) {
-        for (let head = this.subsHead;head; head = head.nextSub) {
-          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
-            head.sub.onTrigger(extend({
-              effect: head.sub
-            }, debugInfo));
-          }
-        }
-      }
-      for (let link = this.subs;link; link = link.prevSub) {
-        if (link.sub.notify()) {
-          link.sub.dep.notify();
-        }
-      }
-    } finally {
-      endBatch();
-    }
-  }
-}
-function addSub(link) {
-  link.dep.sc++;
-  if (link.sub.flags & 4) {
-    const computed = link.dep.computed;
-    if (computed && !link.dep.subs) {
-      computed.flags |= 4 | 16;
-      for (let l = computed.deps;l; l = l.nextDep) {
-        addSub(l);
-      }
-    }
-    const currentTail = link.dep.subs;
-    if (currentTail !== link) {
-      link.prevSub = currentTail;
-      if (currentTail)
-        currentTail.nextSub = link;
-    }
-    if (link.dep.subsHead === undefined) {
-      link.dep.subsHead = link;
-    }
-    link.dep.subs = link;
-  }
-}
-var targetMap = /* @__PURE__ */ new WeakMap;
-var ITERATE_KEY = /* @__PURE__ */ Symbol("Object iterate");
-var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("Map keys iterate");
-var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array iterate");
-function track(target, type, key) {
-  if (shouldTrack && activeSub) {
-    let depsMap = targetMap.get(target);
-    if (!depsMap) {
-      targetMap.set(target, depsMap = /* @__PURE__ */ new Map);
-    }
-    let dep = depsMap.get(key);
-    if (!dep) {
-      depsMap.set(key, dep = new Dep);
-      dep.map = depsMap;
-      dep.key = key;
-    }
-    if (true) {
-      dep.track({
-        target,
-        type,
-        key
-      });
-    } else {}
-  }
-}
-function trigger(target, type, key, newValue, oldValue, oldTarget) {
-  const depsMap = targetMap.get(target);
-  if (!depsMap) {
-    globalVersion++;
-    return;
-  }
-  const run = (dep) => {
-    if (dep) {
-      if (true) {
-        dep.trigger({
-          target,
-          type,
-          key,
-          newValue,
-          oldValue,
-          oldTarget
-        });
-      } else {}
-    }
-  };
-  startBatch();
-  if (type === "clear") {
-    depsMap.forEach(run);
-  } else {
-    const targetIsArray = isArray(target);
-    const isArrayIndex = targetIsArray && isIntegerKey(key);
-    if (targetIsArray && key === "length") {
-      const newLength = Number(newValue);
-      depsMap.forEach((dep, key2) => {
-        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
-          run(dep);
-        }
-      });
-    } else {
-      if (key !== undefined || depsMap.has(undefined)) {
-        run(depsMap.get(key));
-      }
-      if (isArrayIndex) {
-        run(depsMap.get(ARRAY_ITERATE_KEY));
-      }
-      switch (type) {
-        case "add":
-          if (!targetIsArray) {
-            run(depsMap.get(ITERATE_KEY));
-            if (isMap(target)) {
-              run(depsMap.get(MAP_KEY_ITERATE_KEY));
-            }
-          } else if (isArrayIndex) {
-            run(depsMap.get("length"));
-          }
-          break;
-        case "delete":
-          if (!targetIsArray) {
-            run(depsMap.get(ITERATE_KEY));
-            if (isMap(target)) {
-              run(depsMap.get(MAP_KEY_ITERATE_KEY));
-            }
-          }
-          break;
-        case "set":
-          if (isMap(target)) {
-            run(depsMap.get(ITERATE_KEY));
-          }
-          break;
-      }
-    }
-  }
-  endBatch();
-}
-function reactiveReadArray(array) {
-  const raw = toRaw(array);
-  if (raw === array)
-    return raw;
-  track(raw, "iterate", ARRAY_ITERATE_KEY);
-  return isShallow(array) ? raw : raw.map(toReactive);
-}
-function shallowReadArray(arr) {
-  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
-  return arr;
-}
-function toWrapped(target, item) {
-  if (isReadonly(target)) {
-    return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
-  }
-  return toReactive(item);
-}
-var arrayInstrumentations = {
-  __proto__: null,
-  [Symbol.iterator]() {
-    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
-  },
-  concat(...args) {
-    return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
-  },
-  entries() {
-    return iterator(this, "entries", (value) => {
-      value[1] = toWrapped(this, value[1]);
-      return value;
-    });
-  },
-  every(fn, thisArg) {
-    return apply(this, "every", fn, thisArg, undefined, arguments);
-  },
-  filter(fn, thisArg) {
-    return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
-  },
-  find(fn, thisArg) {
-    return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
-  },
-  findIndex(fn, thisArg) {
-    return apply(this, "findIndex", fn, thisArg, undefined, arguments);
-  },
-  findLast(fn, thisArg) {
-    return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
-  },
-  findLastIndex(fn, thisArg) {
-    return apply(this, "findLastIndex", fn, thisArg, undefined, arguments);
-  },
-  forEach(fn, thisArg) {
-    return apply(this, "forEach", fn, thisArg, undefined, arguments);
-  },
-  includes(...args) {
-    return searchProxy(this, "includes", args);
-  },
-  indexOf(...args) {
-    return searchProxy(this, "indexOf", args);
-  },
-  join(separator) {
-    return reactiveReadArray(this).join(separator);
-  },
-  lastIndexOf(...args) {
-    return searchProxy(this, "lastIndexOf", args);
-  },
-  map(fn, thisArg) {
-    return apply(this, "map", fn, thisArg, undefined, arguments);
-  },
-  pop() {
-    return noTracking(this, "pop");
-  },
-  push(...args) {
-    return noTracking(this, "push", args);
-  },
-  reduce(fn, ...args) {
-    return reduce(this, "reduce", fn, args);
-  },
-  reduceRight(fn, ...args) {
-    return reduce(this, "reduceRight", fn, args);
-  },
-  shift() {
-    return noTracking(this, "shift");
-  },
-  some(fn, thisArg) {
-    return apply(this, "some", fn, thisArg, undefined, arguments);
-  },
-  splice(...args) {
-    return noTracking(this, "splice", args);
-  },
-  toReversed() {
-    return reactiveReadArray(this).toReversed();
-  },
-  toSorted(comparer) {
-    return reactiveReadArray(this).toSorted(comparer);
-  },
-  toSpliced(...args) {
-    return reactiveReadArray(this).toSpliced(...args);
-  },
-  unshift(...args) {
-    return noTracking(this, "unshift", args);
-  },
-  values() {
-    return iterator(this, "values", (item) => toWrapped(this, item));
-  }
-};
-function iterator(self2, method, wrapValue) {
-  const arr = shallowReadArray(self2);
-  const iter = arr[method]();
-  if (arr !== self2 && !isShallow(self2)) {
-    iter._next = iter.next;
-    iter.next = () => {
-      const result = iter._next();
-      if (!result.done) {
-        result.value = wrapValue(result.value);
-      }
-      return result;
-    };
-  }
-  return iter;
-}
-var arrayProto = Array.prototype;
-function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
-  const arr = shallowReadArray(self2);
-  const needsWrap = arr !== self2 && !isShallow(self2);
-  const methodFn = arr[method];
-  if (methodFn !== arrayProto[method]) {
-    const result2 = methodFn.apply(self2, args);
-    return needsWrap ? toReactive(result2) : result2;
-  }
-  let wrappedFn = fn;
-  if (arr !== self2) {
-    if (needsWrap) {
-      wrappedFn = function(item, index) {
-        return fn.call(this, toWrapped(self2, item), index, self2);
-      };
-    } else if (fn.length > 2) {
-      wrappedFn = function(item, index) {
-        return fn.call(this, item, index, self2);
-      };
-    }
-  }
-  const result = methodFn.call(arr, wrappedFn, thisArg);
-  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
-}
-function reduce(self2, method, fn, args) {
-  const arr = shallowReadArray(self2);
-  const needsWrap = arr !== self2 && !isShallow(self2);
-  let wrappedFn = fn;
-  let wrapInitialAccumulator = false;
-  if (arr !== self2) {
-    if (needsWrap) {
-      wrapInitialAccumulator = args.length === 0;
-      wrappedFn = function(acc, item, index) {
-        if (wrapInitialAccumulator) {
-          wrapInitialAccumulator = false;
-          acc = toWrapped(self2, acc);
-        }
-        return fn.call(this, acc, toWrapped(self2, item), index, self2);
-      };
-    } else if (fn.length > 3) {
-      wrappedFn = function(acc, item, index) {
-        return fn.call(this, acc, item, index, self2);
-      };
-    }
-  }
-  const result = arr[method](wrappedFn, ...args);
-  return wrapInitialAccumulator ? toWrapped(self2, result) : result;
-}
-function searchProxy(self2, method, args) {
-  const arr = toRaw(self2);
-  track(arr, "iterate", ARRAY_ITERATE_KEY);
-  const res = arr[method](...args);
-  if ((res === -1 || res === false) && isProxy(args[0])) {
-    args[0] = toRaw(args[0]);
-    return arr[method](...args);
-  }
-  return res;
-}
-function noTracking(self2, method, args = []) {
-  pauseTracking();
-  startBatch();
-  const res = toRaw(self2)[method].apply(self2, args);
-  endBatch();
-  resetTracking();
-  return res;
-}
-var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
-var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
-function hasOwnProperty2(key) {
-  if (!isSymbol(key))
-    key = String(key);
-  const obj = toRaw(this);
-  track(obj, "has", key);
-  return obj.hasOwnProperty(key);
-}
-
-class BaseReactiveHandler {
-  constructor(_isReadonly = false, _isShallow = false) {
-    this._isReadonly = _isReadonly;
-    this._isShallow = _isShallow;
-  }
-  get(target, key, receiver) {
-    if (key === "__v_skip")
-      return target["__v_skip"];
-    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
-    if (key === "__v_isReactive") {
-      return !isReadonly2;
-    } else if (key === "__v_isReadonly") {
-      return isReadonly2;
-    } else if (key === "__v_isShallow") {
-      return isShallow2;
-    } else if (key === "__v_raw") {
-      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
-        return target;
-      }
-      return;
-    }
-    const targetIsArray = isArray(target);
-    if (!isReadonly2) {
-      let fn;
-      if (targetIsArray && (fn = arrayInstrumentations[key])) {
-        return fn;
-      }
-      if (key === "hasOwnProperty") {
-        return hasOwnProperty2;
-      }
-    }
-    const res = Reflect.get(target, key, isRef(target) ? target : receiver);
-    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
-      return res;
-    }
-    if (!isReadonly2) {
-      track(target, "get", key);
-    }
-    if (isShallow2) {
-      return res;
-    }
-    if (isRef(res)) {
-      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
-      return isReadonly2 && isObject(value) ? readonly(value) : value;
-    }
-    if (isObject(res)) {
-      return isReadonly2 ? readonly(res) : reactive(res);
-    }
-    return res;
-  }
-}
-
-class MutableReactiveHandler extends BaseReactiveHandler {
-  constructor(isShallow2 = false) {
-    super(false, isShallow2);
-  }
-  set(target, key, value, receiver) {
-    let oldValue = target[key];
-    const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
-    if (!this._isShallow) {
-      const isOldValueReadonly = isReadonly(oldValue);
-      if (!isShallow(value) && !isReadonly(value)) {
-        oldValue = toRaw(oldValue);
-        value = toRaw(value);
-      }
-      if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
-        if (isOldValueReadonly) {
-          if (true) {
-            warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
-          }
-          return true;
-        } else {
-          oldValue.value = value;
-          return true;
-        }
-      }
-    }
-    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
-    const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
-    if (target === toRaw(receiver) && result) {
-      if (!hadKey) {
-        trigger(target, "add", key, value);
-      } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set", key, value, oldValue);
-      }
-    }
-    return result;
-  }
-  deleteProperty(target, key) {
-    const hadKey = hasOwn(target, key);
-    const oldValue = target[key];
-    const result = Reflect.deleteProperty(target, key);
-    if (result && hadKey) {
-      trigger(target, "delete", key, undefined, oldValue);
-    }
-    return result;
-  }
-  has(target, key) {
-    const result = Reflect.has(target, key);
-    if (!isSymbol(key) || !builtInSymbols.has(key)) {
-      track(target, "has", key);
-    }
-    return result;
-  }
-  ownKeys(target) {
-    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
-    return Reflect.ownKeys(target);
-  }
-}
-
-class ReadonlyReactiveHandler extends BaseReactiveHandler {
-  constructor(isShallow2 = false) {
-    super(true, isShallow2);
-  }
-  set(target, key) {
-    if (true) {
-      warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
-    }
-    return true;
-  }
-  deleteProperty(target, key) {
-    if (true) {
-      warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
-    }
-    return true;
-  }
-}
-var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler;
-var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler;
-var toShallow = (value) => value;
-var getProto = (v) => Reflect.getPrototypeOf(v);
-function createIterableMethod(method, isReadonly2, isShallow2) {
-  return function(...args) {
-    const target = this["__v_raw"];
-    const rawTarget = toRaw(target);
-    const targetIsMap = isMap(rawTarget);
-    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
-    const isKeyOnly = method === "keys" && targetIsMap;
-    const innerIterator = target[method](...args);
-    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
-    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
-    return extend(Object.create(innerIterator), {
-      next() {
-        const { value, done } = innerIterator.next();
-        return done ? { value, done } : {
-          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-          done
-        };
-      }
-    });
-  };
-}
-function createReadonlyMethod(type) {
-  return function(...args) {
-    if (true) {
-      const key = args[0] ? `on key "${args[0]}" ` : ``;
-      warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
-    }
-    return type === "delete" ? false : type === "clear" ? undefined : this;
-  };
-}
-function createInstrumentations(readonly, shallow) {
-  const instrumentations = {
-    get(key) {
-      const target = this["__v_raw"];
-      const rawTarget = toRaw(target);
-      const rawKey = toRaw(key);
-      if (!readonly) {
-        if (hasChanged(key, rawKey)) {
-          track(rawTarget, "get", key);
-        }
-        track(rawTarget, "get", rawKey);
-      }
-      const { has } = getProto(rawTarget);
-      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-      if (has.call(rawTarget, key)) {
-        return wrap(target.get(key));
-      } else if (has.call(rawTarget, rawKey)) {
-        return wrap(target.get(rawKey));
-      } else if (target !== rawTarget) {
-        target.get(key);
-      }
-    },
-    get size() {
-      const target = this["__v_raw"];
-      !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
-      return target.size;
-    },
-    has(key) {
-      const target = this["__v_raw"];
-      const rawTarget = toRaw(target);
-      const rawKey = toRaw(key);
-      if (!readonly) {
-        if (hasChanged(key, rawKey)) {
-          track(rawTarget, "has", key);
-        }
-        track(rawTarget, "has", rawKey);
-      }
-      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
-    },
-    forEach(callback, thisArg) {
-      const observed = this;
-      const target = observed["__v_raw"];
-      const rawTarget = toRaw(target);
-      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
-      !readonly && track(rawTarget, "iterate", ITERATE_KEY);
-      return target.forEach((value, key) => {
-        return callback.call(thisArg, wrap(value), wrap(key), observed);
-      });
-    }
-  };
-  extend(instrumentations, readonly ? {
-    add: createReadonlyMethod("add"),
-    set: createReadonlyMethod("set"),
-    delete: createReadonlyMethod("delete"),
-    clear: createReadonlyMethod("clear")
-  } : {
-    add(value) {
-      const target = toRaw(this);
-      const proto = getProto(target);
-      const rawValue = toRaw(value);
-      const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
-      const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
-      if (!hadKey) {
-        target.add(valueToAdd);
-        trigger(target, "add", valueToAdd, valueToAdd);
-      }
-      return this;
-    },
-    set(key, value) {
-      if (!shallow && !isShallow(value) && !isReadonly(value)) {
-        value = toRaw(value);
-      }
-      const target = toRaw(this);
-      const { has, get } = getProto(target);
-      let hadKey = has.call(target, key);
-      if (!hadKey) {
-        key = toRaw(key);
-        hadKey = has.call(target, key);
-      } else if (true) {
-        checkIdentityKeys(target, has, key);
-      }
-      const oldValue = get.call(target, key);
-      target.set(key, value);
-      if (!hadKey) {
-        trigger(target, "add", key, value);
-      } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set", key, value, oldValue);
-      }
-      return this;
-    },
-    delete(key) {
-      const target = toRaw(this);
-      const { has, get } = getProto(target);
-      let hadKey = has.call(target, key);
-      if (!hadKey) {
-        key = toRaw(key);
-        hadKey = has.call(target, key);
-      } else if (true) {
-        checkIdentityKeys(target, has, key);
-      }
-      const oldValue = get ? get.call(target, key) : undefined;
-      const result = target.delete(key);
-      if (hadKey) {
-        trigger(target, "delete", key, undefined, oldValue);
-      }
-      return result;
-    },
-    clear() {
-      const target = toRaw(this);
-      const hadItems = target.size !== 0;
-      const oldTarget = isMap(target) ? new Map(target) : new Set(target);
-      const result = target.clear();
-      if (hadItems) {
-        trigger(target, "clear", undefined, undefined, oldTarget);
-      }
-      return result;
-    }
-  });
-  const iteratorMethods = [
-    "keys",
-    "values",
-    "entries",
-    Symbol.iterator
-  ];
-  iteratorMethods.forEach((method) => {
-    instrumentations[method] = createIterableMethod(method, readonly, shallow);
-  });
-  return instrumentations;
-}
-function createInstrumentationGetter(isReadonly2, shallow) {
-  const instrumentations = createInstrumentations(isReadonly2, shallow);
-  return (target, key, receiver) => {
-    if (key === "__v_isReactive") {
-      return !isReadonly2;
-    } else if (key === "__v_isReadonly") {
-      return isReadonly2;
-    } else if (key === "__v_raw") {
-      return target;
-    }
-    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-  };
-}
-var mutableCollectionHandlers = {
-  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
-};
-var readonlyCollectionHandlers = {
-  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
-};
-function checkIdentityKeys(target, has, key) {
-  const rawKey = toRaw(key);
-  if (rawKey !== key && has.call(target, rawKey)) {
-    const type = toRawType(target);
-    warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
-  }
-}
-var reactiveMap = /* @__PURE__ */ new WeakMap;
-var shallowReactiveMap = /* @__PURE__ */ new WeakMap;
-var readonlyMap = /* @__PURE__ */ new WeakMap;
-var shallowReadonlyMap = /* @__PURE__ */ new WeakMap;
-function targetTypeMap(rawType) {
-  switch (rawType) {
-    case "Object":
-    case "Array":
-      return 1;
-    case "Map":
-    case "Set":
-    case "WeakMap":
-    case "WeakSet":
-      return 2;
-    default:
-      return 0;
-  }
-}
-function reactive(target) {
-  if (/* @__PURE__ */ isReadonly(target)) {
-    return target;
-  }
-  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
-}
-function readonly(target) {
-  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
-}
-function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
-  if (!isObject(target)) {
-    if (true) {
-      warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
-    }
-    return target;
-  }
-  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
-    return target;
-  }
-  if (target["__v_skip"] || !Object.isExtensible(target)) {
-    return target;
-  }
-  const existingProxy = proxyMap.get(target);
-  if (existingProxy) {
-    return existingProxy;
-  }
-  const targetType = targetTypeMap(toRawType(target));
-  if (targetType === 0) {
-    return target;
-  }
-  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
-  proxyMap.set(target, proxy);
-  return proxy;
-}
-function isReactive(value) {
-  if (/* @__PURE__ */ isReadonly(value)) {
-    return /* @__PURE__ */ isReactive(value["__v_raw"]);
-  }
-  return !!(value && value["__v_isReactive"]);
-}
-function isReadonly(value) {
-  return !!(value && value["__v_isReadonly"]);
-}
-function isShallow(value) {
-  return !!(value && value["__v_isShallow"]);
-}
-function isProxy(value) {
-  return value ? !!value["__v_raw"] : false;
-}
-function toRaw(observed) {
-  const raw = observed && observed["__v_raw"];
-  return raw ? /* @__PURE__ */ toRaw(raw) : observed;
-}
-var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
-var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
-function isRef(r) {
-  return r ? r["__v_isRef"] === true : false;
-}
-
-// src/chat-state.ts
-var _idCounter = 0;
-function uid() {
-  _idCounter += 1;
-  return `msg_${Date.now()}_${_idCounter}`;
-}
-function createChatState(opts = {}) {
-  const model = opts.model || "gpt-4o";
-  const store = reactive({
-    messages: [],
-    status: "idle",
-    streamingContent: "",
-    pendingToolCalls: [],
-    error: null,
-    model,
-    tokenCount: 0,
-    contextWarning: false
-  });
-  let _streamingMessage = null;
-  function sendMessage(text) {
-    if (store.status === "streaming") {
-      return;
-    }
-    const userMsg = {
-      id: uid(),
-      role: "user",
-      content: text,
-      timestamp: Date.now()
-    };
-    store.messages.push(userMsg);
-    beginAssistantTurn();
-  }
-  function beginAssistantTurn() {
-    if (store.status === "streaming") {
-      return;
-    }
-    store.error = null;
-    store.streamingContent = "";
-    store.pendingToolCalls = [];
-    store.status = "streaming";
-    _streamingMessage = {
-      id: uid(),
-      role: "assistant",
-      content: "",
-      timestamp: Date.now()
-    };
-    store.messages.push(_streamingMessage);
-    _streamingMessage = store.messages.at(-1) ?? null;
-  }
-  function pushToolResultMessage(toolCallId, content) {
-    store.messages.push({
-      id: uid(),
-      role: "tool",
-      toolCallId,
-      content,
-      timestamp: Date.now()
-    });
-  }
-  function appendDelta(content) {
-    if (store.status !== "streaming" || !_streamingMessage) {
-      return;
-    }
-    store.streamingContent += content;
-    _streamingMessage.content = store.streamingContent;
-  }
-  function appendToolCallStart(id, name) {
-    if (store.status !== "streaming") {
-      return;
-    }
-    const tc = {
-      id,
-      name,
-      arguments: "",
-      result: null
-    };
-    store.pendingToolCalls.push(tc);
-    if (_streamingMessage) {
-      if (!_streamingMessage.toolCalls) {
-        _streamingMessage.toolCalls = [];
-      }
-      _streamingMessage.toolCalls.push(tc);
-    }
-  }
-  function appendToolCallDelta(id, args) {
-    const tc = store.pendingToolCalls.find((t) => t.id === id);
-    if (tc) {
-      tc.arguments += args;
-    }
-  }
-  function appendToolCallEnd(_id) {}
-  function appendToolResult(id, result) {
-    const tc = store.pendingToolCalls.find((t) => t.id === id);
-    if (tc) {
-      tc.result = result;
-    }
-    if (_streamingMessage?.toolCalls) {
-      const mtc = _streamingMessage.toolCalls.find((t) => t.id === id);
-      if (mtc) {
-        mtc.result = result;
-      }
-    }
-  }
-  function finishStream(_stopReason) {
-    store.status = "idle";
-    store.streamingContent = "";
-    store.pendingToolCalls = [];
-    _streamingMessage = null;
-  }
-  function setError(message) {
-    store.status = "error";
-    store.error = message;
-    store.streamingContent = "";
-    if (_streamingMessage) {
-      const idx = store.messages.lastIndexOf(_streamingMessage);
-      if (idx !== -1) {
-        store.messages.splice(idx, 1);
-      }
-    }
-    _streamingMessage = null;
-  }
-  function cancelStream() {
-    if (_streamingMessage) {
-      const idx = store.messages.lastIndexOf(_streamingMessage);
-      if (idx !== -1) {
-        store.messages.splice(idx, 1);
-      }
-    }
-    store.status = "idle";
-    store.streamingContent = "";
-    store.pendingToolCalls = [];
-    _streamingMessage = null;
-    store.error = null;
-  }
-  function clearChat() {
-    store.messages.length = 0;
-    store.status = "idle";
-    store.streamingContent = "";
-    store.pendingToolCalls = [];
-    store.error = null;
-    store.contextWarning = false;
-    _streamingMessage = null;
-  }
-  function retryLast() {
-    while (store.messages.length > 0 && store.messages.at(-1).role !== "user") {
-      store.messages.pop();
-    }
-    if (store.messages.length > 0 && store.messages.at(-1).role === "user") {
-      store.messages.pop();
-    }
-    store.status = "idle";
-    store.error = null;
-  }
-  function setModel(m) {
-    store.model = m;
-  }
-  function setTokenCount(count) {
-    store.tokenCount = count;
-  }
-  function setContextWarning(warning) {
-    store.contextWarning = warning;
-  }
-  function toMessagesArray() {
-    const out = [];
-    for (const msg of store.messages) {
-      if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
-        out.push({
-          role: "assistant",
-          content: msg.content || null,
-          tool_calls: msg.toolCalls.map((tc) => ({
-            id: tc.id,
-            type: "function",
-            function: {
-              name: tc.name,
-              arguments: tc.arguments
-            }
-          }))
-        });
-      } else if (msg.role === "tool") {
-        out.push({
-          role: "tool",
-          tool_call_id: msg.toolCallId,
-          content: msg.content
-        });
-      } else {
-        out.push({
-          role: msg.role,
-          content: msg.content
-        });
-      }
-    }
-    return out;
-  }
-  return Object.assign(store, {
-    sendMessage,
-    beginAssistantTurn,
-    appendDelta,
-    appendToolCallStart,
-    appendToolCallDelta,
-    appendToolCallEnd,
-    appendToolResult,
-    pushToolResultMessage,
-    finishStream,
-    setError,
-    cancelStream,
-    clearChat,
-    retryLast,
-    setModel,
-    setTokenCount,
-    setContextWarning,
-    toMessagesArray
-  });
-}
-// src/streaming-client.ts
-var STREAM_EVENT_TYPES = {
-  DELTA: "delta",
-  TOOL_CALL_START: "tool_call_start",
-  TOOL_CALL_DELTA: "tool_call_delta",
-  TOOL_CALL_END: "tool_call_end",
-  DONE: "done",
-  ERROR: "error"
-};
-function createOpenAIStreamingClient({
-  baseUrl,
-  apiKey,
-  model = "gpt-4o",
-  temperature
-}) {
-  async function* streamChat(messages, tools, systemPrompt, signal) {
-    const url = `${baseUrl}/chat/completions`;
-    const body = {
-      model,
-      messages: [{ role: "system", content: systemPrompt }, ...messages],
-      stream: true,
-      stream_options: { include_usage: true }
-    };
-    if (temperature !== undefined) {
-      body.temperature = temperature;
-    }
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-      body.tool_choice = "auto";
-      body.parallel_tool_calls = true;
-    }
-    let response;
-    try {
-      response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify(body),
-        signal
-      });
-    } catch (error) {
-      if (error.name === "AbortError") {
-        yield { type: "done", stopReason: "cancelled" };
-        return;
-      }
-      yield {
-        type: "error",
-        message: `Network error: ${error.message}`
-      };
-      return;
-    }
-    if (!response.ok) {
-      let errorBody = "";
-      try {
-        errorBody = await response.text();
-      } catch {}
-      yield {
-        type: "error",
-        message: `API error ${response.status}: ${errorBody || response.statusText}`,
-        code: String(response.status)
-      };
-      return;
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      yield { type: "error", message: "No response body" };
-      return;
-    }
-    const decoder = new TextDecoder;
-    let buffer = "";
-    const pendingToolCalls = new Map;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split(`
-`);
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith("data: ")) {
-            continue;
-          }
-          const dataStr = trimmed.slice(6);
-          if (dataStr === "[DONE]") {
-            for (const tc of pendingToolCalls.values()) {
-              yield { type: "tool_call_end", id: tc.id };
-            }
-            pendingToolCalls.clear();
-            yield { type: "done", stopReason: "stop" };
-            return;
-          }
-          let parsed;
-          try {
-            parsed = JSON.parse(dataStr);
-          } catch {
-            continue;
-          }
-          const choice = parsed.choices?.[0];
-          if (!choice) {
-            continue;
-          }
-          const { delta } = choice;
-          if (!delta) {
-            continue;
-          }
-          if (delta.content) {
-            yield { type: "delta", content: delta.content };
-          }
-          if (delta.tool_calls) {
-            for (const tc of delta.tool_calls) {
-              const existing = pendingToolCalls.get(tc.index);
-              if (tc.id) {
-                const entry = {
-                  id: tc.id,
-                  name: tc.function?.name || "",
-                  args: tc.function?.arguments || ""
-                };
-                pendingToolCalls.set(tc.index, entry);
-                yield { type: "tool_call_start", id: tc.id, name: entry.name };
-                if (entry.args) {
-                  yield { type: "tool_call_delta", id: tc.id, args: entry.args };
-                }
-              } else if (existing && tc.function?.arguments) {
-                existing.args += tc.function.arguments;
-                yield {
-                  type: "tool_call_delta",
-                  id: existing.id,
-                  args: tc.function.arguments
-                };
-              }
-            }
-          }
-          if (choice.finish_reason === "tool_calls") {
-            for (const tc of pendingToolCalls.values()) {
-              yield { type: "tool_call_end", id: tc.id };
-            }
-            pendingToolCalls.clear();
-            yield { type: "done", stopReason: "tool_calls" };
-            return;
-          }
-          if (choice.finish_reason === "stop" || choice.finish_reason === "length") {
-            for (const tc of pendingToolCalls.values()) {
-              yield { type: "tool_call_end", id: tc.id };
-            }
-            pendingToolCalls.clear();
-            yield {
-              type: "done",
-              stopReason: choice.finish_reason === "length" ? "length" : "stop"
-            };
-            return;
-          }
-        }
-      }
-      for (const tc of pendingToolCalls.values()) {
-        yield { type: "tool_call_end", id: tc.id };
-      }
-      pendingToolCalls.clear();
-      yield { type: "done", stopReason: "stop" };
-    } catch (error) {
-      reader.cancel();
-      if (error.name === "AbortError") {
-        yield { type: "done", stopReason: "cancelled" };
-        return;
-      }
-      yield {
-        type: "error",
-        message: `Stream error: ${error.message}`
-      };
-    }
-  }
-  return { streamChat };
-}
-function createAnthropicStreamingClient({
-  baseUrl: _,
-  apiKey: __
-}) {
-  async function* streamChat() {
-    yield {
-      type: "error",
-      message: "Anthropic provider is not yet implemented (planned for v2). Use OpenAI.",
-      code: "NOT_IMPLEMENTED"
-    };
-  }
-  return { streamChat };
-}
-function createProxyStreamingClient({
-  chatUrl,
-  model = "gpt-4o",
-  apiKey,
-  baseUrl
-}) {
-  async function* streamChat(messages, tools, systemPrompt, signal) {
-    const headers = { "Content-Type": "application/json" };
-    if (apiKey) {
-      headers["X-Api-Key"] = apiKey;
-    }
-    if (baseUrl) {
-      headers["X-Api-Base-URL"] = baseUrl;
-    }
-    let response;
-    try {
-      response = await fetch(chatUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ messages, tools, systemPrompt, model }),
-        signal
-      });
-    } catch (error) {
-      if (error.name === "AbortError") {
-        yield { type: "done", stopReason: "cancelled" };
-        return;
-      }
-      yield {
-        type: "error",
-        message: `Network error: ${error.message}`
-      };
-      return;
-    }
-    if (!response.ok) {
-      let errorBody = "";
-      try {
-        errorBody = await response.text();
-      } catch {}
-      let cleanMessage = errorBody || response.statusText;
-      try {
-        const parsed = JSON.parse(errorBody);
-        if (typeof parsed.error === "string") {
-          cleanMessage = parsed.error;
-        } else if (parsed.error?.message) {
-          cleanMessage = parsed.error.message;
-        }
-      } catch {}
-      yield {
-        type: "error",
-        message: cleanMessage,
-        code: String(response.status)
-      };
-      return;
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      yield { type: "error", message: "No response body" };
-      return;
-    }
-    const decoder = new TextDecoder;
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split(`
-`);
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith("data: ")) {
-            continue;
-          }
-          const dataStr = trimmed.slice(6);
-          let event;
-          try {
-            event = JSON.parse(dataStr);
-          } catch {
-            continue;
-          }
-          yield event;
-          if (event.type === "done" || event.type === "error") {
-            return;
-          }
-        }
-      }
-    } catch (error) {
-      reader.cancel();
-      if (error.name === "AbortError") {
-        yield { type: "done", stopReason: "cancelled" };
-        return;
-      }
-      yield {
-        type: "error",
-        message: `Stream error: ${error.message}`
-      };
-    }
-  }
-  return { streamChat };
-}
-export {
-  createToolRegistry,
-  createToolDefinition,
-  createProxyStreamingClient,
-  createOpenAIStreamingClient,
-  createChatState,
-  createAnthropicStreamingClient,
-  STREAM_EVENT_TYPES
-};
-
-//# debugId=BF651F4D1B20097764756E2164756E21
-//# sourceMappingURL=index.js.map