@microfox/ai-router 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @microfox/ai-router
 
+## 2.1.2
+
+### Patch Changes
+
+- 56b7b6e: Changes from PR #36: middlewar-changes-before-after
+
+## 2.1.1
+
+### Patch Changes
+
+- a05002d: Changes from PR #31: beta
+
 ## 2.1.0
 
 ### Minor Changes

package/dist/chunk-BJTO5JO5.mjs

@@ -0,0 +1,11 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=chunk-BJTO5JO5.mjs.map

package/dist/chunk-BJTO5JO5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/fs_store.d.mts

@@ -0,0 +1,5 @@
+import { S as Store } from './store-BBHh-uTh.mjs';
+
+declare const FileSystemStore: new (...args: any[]) => Store;
+
+export { FileSystemStore };

package/dist/fs_store.d.ts

@@ -0,0 +1,5 @@
+import { S as Store } from './store-BBHh-uTh.js';
+
+declare const FileSystemStore: new (...args: any[]) => Store;
+
+export { FileSystemStore };

package/dist/fs_store.js

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/fs_store.ts
+var fs_store_exports = {};
+__export(fs_store_exports, {
+  FileSystemStore: () => FileSystemStore
+});
+module.exports = __toCommonJS(fs_store_exports);
+var NoOpStore = class {
+  constructor() {
+    console.warn(
+      "FileSystemStore is not available in the browser. Using a mock store."
+    );
+  }
+  async get(_key) {
+    return void 0;
+  }
+  async set(_key, _value) {
+  }
+  async delete(_key) {
+  }
+  async has(_key) {
+    return false;
+  }
+};
+var store;
+if (typeof window !== "undefined") {
+  store = NoOpStore;
+} else {
+  const fs = require("fs/promises");
+  const path = require("path");
+  const AsyncLock = require("async-lock");
+  class FileSystemStore2 {
+    constructor(storagePath = ".ai-router.store.json") {
+      this.storeFilePath = path.resolve(storagePath);
+      this.lock = new AsyncLock();
+      this.init();
+    }
+    async init() {
+      try {
+        await fs.access(this.storeFilePath);
+      } catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+          await fs.writeFile(this.storeFilePath, "{}", "utf-8");
+        } else {
+          console.error("Failed to access or create storage file:", error);
+        }
+      }
+    }
+    async readStore() {
+      try {
+        const fileContent = await fs.readFile(this.storeFilePath, "utf-8");
+        return JSON.parse(fileContent);
+      } catch (error) {
+        console.error(
+          "Failed to read store file, returning empty object:",
+          error
+        );
+        return {};
+      }
+    }
+    async writeStore(data) {
+      const fileContent = JSON.stringify(data, null, 2);
+      await fs.writeFile(this.storeFilePath, fileContent, "utf-8");
+    }
+    async get(key) {
+      return this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        return store2[key];
+      });
+    }
+    async set(key, value) {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        store2[key] = value;
+        await this.writeStore(store2);
+      });
+    }
+    async delete(key) {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        delete store2[key];
+        await this.writeStore(store2);
+      });
+    }
+    async has(key) {
+      return this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        return key in store2;
+      });
+    }
+    async clear() {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        await this.writeStore({});
+      });
+    }
+  }
+  store = FileSystemStore2;
+}
+var FileSystemStore = store;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystemStore
+});
+//# sourceMappingURL=fs_store.js.map

package/dist/fs_store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fs_store.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nimport { Store } from './store';\n\n// Type definition for AsyncLock since @types/async-lock might not be available\ntype AsyncLock = {\n  acquire<T>(key: string, fn: () => Promise<T>): Promise<T>;\n};\n\nclass NoOpStore implements Store {\n  constructor() {\n    console.warn(\n      'FileSystemStore is not available in the browser. Using a mock store.'\n    );\n  }\n\n  async get<T>(_key: string): Promise<T | undefined> {\n    return undefined;\n  }\n\n  async set<T>(_key: string, _value: T): Promise<void> {\n    // No-op\n  }\n\n  async delete(_key: string): Promise<void> {\n    // No-op\n  }\n\n  async has(_key: string): Promise<boolean> {\n    return false;\n  }\n}\n\nlet store: new (...args: any[]) => Store;\nif (typeof window !== 'undefined') {\n  store = NoOpStore;\n} else {\n  const fs = require('fs/promises');\n  const path = require('path');\n  const AsyncLock = require('async-lock');\n\n  class FileSystemStore implements Store {\n    private storeFilePath: string;\n    private lock: AsyncLock;\n\n    constructor(storagePath: string = '.ai-router.store.json') {\n      this.storeFilePath = path.resolve(storagePath);\n      this.lock = new AsyncLock();\n      this.init();\n    }\n\n    private async init() {\n      try {\n        // Check if file exists by trying to read it.\n        await fs.access(this.storeFilePath);\n      } catch (error: unknown) {\n        // If not, create it with an empty object.\n        if (\n          error &&\n          typeof error === 'object' &&\n          'code' in error &&\n          error.code === 'ENOENT'\n        ) {\n          await fs.writeFile(this.storeFilePath, '{}', 'utf-8');\n        } else {\n          console.error('Failed to access or create storage file:', error);\n        }\n      }\n    }\n\n    private async readStore(): Promise<Record<string, unknown>> {\n      try {\n        const fileContent = await fs.readFile(this.storeFilePath, 'utf-8');\n        return JSON.parse(fileContent);\n      } catch (error) {\n        console.error(\n          'Failed to read store file, returning empty object:',\n          error\n        );\n        return {};\n      }\n    }\n\n    private async writeStore(data: Record<string, unknown>): Promise<void> {\n      const fileContent = JSON.stringify(data, null, 2);\n      await fs.writeFile(this.storeFilePath, fileContent, 'utf-8');\n    }\n\n    async get<T>(key: string): Promise<T | undefined> {\n      return this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        return store[key] as T | undefined;\n      });\n    }\n\n    async set<T>(key: string, value: T): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        store[key] = value;\n        await this.writeStore(store);\n      });\n    }\n\n    async delete(key: string): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        delete store[key];\n        await this.writeStore(store);\n      });\n    }\n\n    async has(key: string): Promise<boolean> {\n      return this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        return key in store;\n      });\n    }\n\n    async clear(): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        await this.writeStore({});\n      });\n    }\n  }\n  store = FileSystemStore;\n}\n\nexport const FileSystemStore = store;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,IAAM,YAAN,MAAiC;AAAA,EAC/B,cAAc;AACZ,YAAQ;AAAA,MACN;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,IAAO,MAAsC;AACjD,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAO,MAAc,QAA0B;AAAA,EAErD;AAAA,EAEA,MAAM,OAAO,MAA6B;AAAA,EAE1C;AAAA,EAEA,MAAM,IAAI,MAAgC;AACxC,WAAO;AAAA,EACT;AACF;AAEA,IAAI;AACJ,IAAI,OAAO,WAAW,aAAa;AACjC,UAAQ;AACV,OAAO;AACL,QAAM,KAAK,QAAQ,aAAa;AAChC,QAAM,OAAO,QAAQ,MAAM;AAC3B,QAAM,YAAY,QAAQ,YAAY;AAAA,EAEtC,MAAMA,iBAAiC;AAAA,IAIrC,YAAY,cAAsB,yBAAyB;AACzD,WAAK,gBAAgB,KAAK,QAAQ,WAAW;AAC7C,WAAK,OAAO,IAAI,UAAU;AAC1B,WAAK,KAAK;AAAA,IACZ;AAAA,IAEA,MAAc,OAAO;AACnB,UAAI;AAEF,cAAM,GAAG,OAAO,KAAK,aAAa;AAAA,MACpC,SAAS,OAAgB;AAEvB,YACE,SACA,OAAO,UAAU,YACjB,UAAU,SACV,MAAM,SAAS,UACf;AACA,gBAAM,GAAG,UAAU,KAAK,eAAe,MAAM,OAAO;AAAA,QACtD,OAAO;AACL,kBAAQ,MAAM,4CAA4C,KAAK;AAAA,QACjE;AAAA,MACF;AAAA,IACF;AAAA,IAEA,MAAc,YAA8C;AAC1D,UAAI;AACF,cAAM,cAAc,MAAM,GAAG,SAAS,KAAK,eAAe,OAAO;AACjE,eAAO,KAAK,MAAM,WAAW;AAAA,MAC/B,SAAS,OAAO;AACd,gBAAQ;AAAA,UACN;AAAA,UACA;AAAA,QACF;AACA,eAAO,CAAC;AAAA,MACV;AAAA,IACF;AAAA,IAEA,MAAc,WAAW,MAA8C;AACrE,YAAM,cAAc,KAAK,UAAU,MAAM,MAAM,CAAC;AAChD,YAAM,GAAG,UAAU,KAAK,eAAe,aAAa,OAAO;AAAA,IAC7D;AAAA,IAEA,MAAM,IAAO,KAAqC;AAChD,aAAO,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACvD,cAAMC,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAOA,OAAM,GAAG;AAAA,MAClB,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,IAAO,KAAa,OAAyB;AACjD,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,QAAAA,OAAM,GAAG,IAAI;AACb,cAAM,KAAK,WAAWA,MAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,OAAO,KAA4B;AACvC,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAOA,OAAM,GAAG;AAChB,cAAM,KAAK,WAAWA,MAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,IAAI,KAA+B;AACvC,aAAO,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACvD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAO,OAAOA;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,QAAuB;AAC3B,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAM,KAAK,WAAW,CAAC,CAAC;AAAA,MAC1B,CAAC;AAAA,IACH;AAAA,EACF;AACA,UAAQD;AACV;AAEO,IAAM,kBAAkB;","names":["FileSystemStore","store"]}

package/dist/fs_store.mjs

@@ -0,0 +1,101 @@
+import {
+  __require
+} from "./chunk-BJTO5JO5.mjs";
+
+// src/fs_store.ts
+var NoOpStore = class {
+  constructor() {
+    console.warn(
+      "FileSystemStore is not available in the browser. Using a mock store."
+    );
+  }
+  async get(_key) {
+    return void 0;
+  }
+  async set(_key, _value) {
+  }
+  async delete(_key) {
+  }
+  async has(_key) {
+    return false;
+  }
+};
+var store;
+if (typeof window !== "undefined") {
+  store = NoOpStore;
+} else {
+  const fs = __require("fs/promises");
+  const path = __require("path");
+  const AsyncLock = __require("async-lock");
+  class FileSystemStore2 {
+    constructor(storagePath = ".ai-router.store.json") {
+      this.storeFilePath = path.resolve(storagePath);
+      this.lock = new AsyncLock();
+      this.init();
+    }
+    async init() {
+      try {
+        await fs.access(this.storeFilePath);
+      } catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+          await fs.writeFile(this.storeFilePath, "{}", "utf-8");
+        } else {
+          console.error("Failed to access or create storage file:", error);
+        }
+      }
+    }
+    async readStore() {
+      try {
+        const fileContent = await fs.readFile(this.storeFilePath, "utf-8");
+        return JSON.parse(fileContent);
+      } catch (error) {
+        console.error(
+          "Failed to read store file, returning empty object:",
+          error
+        );
+        return {};
+      }
+    }
+    async writeStore(data) {
+      const fileContent = JSON.stringify(data, null, 2);
+      await fs.writeFile(this.storeFilePath, fileContent, "utf-8");
+    }
+    async get(key) {
+      return this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        return store2[key];
+      });
+    }
+    async set(key, value) {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        store2[key] = value;
+        await this.writeStore(store2);
+      });
+    }
+    async delete(key) {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        delete store2[key];
+        await this.writeStore(store2);
+      });
+    }
+    async has(key) {
+      return this.lock.acquire(this.storeFilePath, async () => {
+        const store2 = await this.readStore();
+        return key in store2;
+      });
+    }
+    async clear() {
+      await this.lock.acquire(this.storeFilePath, async () => {
+        await this.writeStore({});
+      });
+    }
+  }
+  store = FileSystemStore2;
+}
+var FileSystemStore = store;
+export {
+  FileSystemStore
+};
+//# sourceMappingURL=fs_store.mjs.map

package/dist/fs_store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fs_store.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-var-requires */\nimport { Store } from './store';\n\n// Type definition for AsyncLock since @types/async-lock might not be available\ntype AsyncLock = {\n  acquire<T>(key: string, fn: () => Promise<T>): Promise<T>;\n};\n\nclass NoOpStore implements Store {\n  constructor() {\n    console.warn(\n      'FileSystemStore is not available in the browser. Using a mock store.'\n    );\n  }\n\n  async get<T>(_key: string): Promise<T | undefined> {\n    return undefined;\n  }\n\n  async set<T>(_key: string, _value: T): Promise<void> {\n    // No-op\n  }\n\n  async delete(_key: string): Promise<void> {\n    // No-op\n  }\n\n  async has(_key: string): Promise<boolean> {\n    return false;\n  }\n}\n\nlet store: new (...args: any[]) => Store;\nif (typeof window !== 'undefined') {\n  store = NoOpStore;\n} else {\n  const fs = require('fs/promises');\n  const path = require('path');\n  const AsyncLock = require('async-lock');\n\n  class FileSystemStore implements Store {\n    private storeFilePath: string;\n    private lock: AsyncLock;\n\n    constructor(storagePath: string = '.ai-router.store.json') {\n      this.storeFilePath = path.resolve(storagePath);\n      this.lock = new AsyncLock();\n      this.init();\n    }\n\n    private async init() {\n      try {\n        // Check if file exists by trying to read it.\n        await fs.access(this.storeFilePath);\n      } catch (error: unknown) {\n        // If not, create it with an empty object.\n        if (\n          error &&\n          typeof error === 'object' &&\n          'code' in error &&\n          error.code === 'ENOENT'\n        ) {\n          await fs.writeFile(this.storeFilePath, '{}', 'utf-8');\n        } else {\n          console.error('Failed to access or create storage file:', error);\n        }\n      }\n    }\n\n    private async readStore(): Promise<Record<string, unknown>> {\n      try {\n        const fileContent = await fs.readFile(this.storeFilePath, 'utf-8');\n        return JSON.parse(fileContent);\n      } catch (error) {\n        console.error(\n          'Failed to read store file, returning empty object:',\n          error\n        );\n        return {};\n      }\n    }\n\n    private async writeStore(data: Record<string, unknown>): Promise<void> {\n      const fileContent = JSON.stringify(data, null, 2);\n      await fs.writeFile(this.storeFilePath, fileContent, 'utf-8');\n    }\n\n    async get<T>(key: string): Promise<T | undefined> {\n      return this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        return store[key] as T | undefined;\n      });\n    }\n\n    async set<T>(key: string, value: T): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        store[key] = value;\n        await this.writeStore(store);\n      });\n    }\n\n    async delete(key: string): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        delete store[key];\n        await this.writeStore(store);\n      });\n    }\n\n    async has(key: string): Promise<boolean> {\n      return this.lock.acquire(this.storeFilePath, async () => {\n        const store = await this.readStore();\n        return key in store;\n      });\n    }\n\n    async clear(): Promise<void> {\n      await this.lock.acquire(this.storeFilePath, async () => {\n        await this.writeStore({});\n      });\n    }\n  }\n  store = FileSystemStore;\n}\n\nexport const FileSystemStore = store;\n"],"mappings":";;;;;AAQA,IAAM,YAAN,MAAiC;AAAA,EAC/B,cAAc;AACZ,YAAQ;AAAA,MACN;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,IAAO,MAAsC;AACjD,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAO,MAAc,QAA0B;AAAA,EAErD;AAAA,EAEA,MAAM,OAAO,MAA6B;AAAA,EAE1C;AAAA,EAEA,MAAM,IAAI,MAAgC;AACxC,WAAO;AAAA,EACT;AACF;AAEA,IAAI;AACJ,IAAI,OAAO,WAAW,aAAa;AACjC,UAAQ;AACV,OAAO;AACL,QAAM,KAAK,UAAQ,aAAa;AAChC,QAAM,OAAO,UAAQ,MAAM;AAC3B,QAAM,YAAY,UAAQ,YAAY;AAAA,EAEtC,MAAMA,iBAAiC;AAAA,IAIrC,YAAY,cAAsB,yBAAyB;AACzD,WAAK,gBAAgB,KAAK,QAAQ,WAAW;AAC7C,WAAK,OAAO,IAAI,UAAU;AAC1B,WAAK,KAAK;AAAA,IACZ;AAAA,IAEA,MAAc,OAAO;AACnB,UAAI;AAEF,cAAM,GAAG,OAAO,KAAK,aAAa;AAAA,MACpC,SAAS,OAAgB;AAEvB,YACE,SACA,OAAO,UAAU,YACjB,UAAU,SACV,MAAM,SAAS,UACf;AACA,gBAAM,GAAG,UAAU,KAAK,eAAe,MAAM,OAAO;AAAA,QACtD,OAAO;AACL,kBAAQ,MAAM,4CAA4C,KAAK;AAAA,QACjE;AAAA,MACF;AAAA,IACF;AAAA,IAEA,MAAc,YAA8C;AAC1D,UAAI;AACF,cAAM,cAAc,MAAM,GAAG,SAAS,KAAK,eAAe,OAAO;AACjE,eAAO,KAAK,MAAM,WAAW;AAAA,MAC/B,SAAS,OAAO;AACd,gBAAQ;AAAA,UACN;AAAA,UACA;AAAA,QACF;AACA,eAAO,CAAC;AAAA,MACV;AAAA,IACF;AAAA,IAEA,MAAc,WAAW,MAA8C;AACrE,YAAM,cAAc,KAAK,UAAU,MAAM,MAAM,CAAC;AAChD,YAAM,GAAG,UAAU,KAAK,eAAe,aAAa,OAAO;AAAA,IAC7D;AAAA,IAEA,MAAM,IAAO,KAAqC;AAChD,aAAO,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACvD,cAAMC,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAOA,OAAM,GAAG;AAAA,MAClB,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,IAAO,KAAa,OAAyB;AACjD,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,QAAAA,OAAM,GAAG,IAAI;AACb,cAAM,KAAK,WAAWA,MAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,OAAO,KAA4B;AACvC,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAOA,OAAM,GAAG;AAChB,cAAM,KAAK,WAAWA,MAAK;AAAA,MAC7B,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,IAAI,KAA+B;AACvC,aAAO,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACvD,cAAMA,SAAQ,MAAM,KAAK,UAAU;AACnC,eAAO,OAAOA;AAAA,MAChB,CAAC;AAAA,IACH;AAAA,IAEA,MAAM,QAAuB;AAC3B,YAAM,KAAK,KAAK,QAAQ,KAAK,eAAe,YAAY;AACtD,cAAM,KAAK,WAAW,CAAC,CAAC;AAAA,MAC1B,CAAC;AAAA,IACH;AAAA,EACF;AACA,UAAQD;AACV;AAEO,IAAM,kBAAkB;","names":["FileSystemStore","store"]}

package/dist/index.d.mts

@@ -0,0 +1,340 @@
+import * as ai from 'ai';
+import { UIMessageStreamWriter, UIMessage, GenerateObjectResult, UIDataTypes, generateId, ToolSet, JSONValue, Tool } from 'ai';
+import { z } from 'zod';
+import { S as Store } from './store-BBHh-uTh.mjs';
+export { M as MemoryStore } from './store-BBHh-uTh.mjs';
+
+type UITools = Record<string, {
+    input: unknown;
+    output: unknown | undefined;
+}>;
+
+declare const findLastElement: <T>(array: T[]) => T;
+declare const findFirstElement: <T>(array: T[]) => T;
+declare class StreamWriter<METADATA, TOOLS extends UITools> {
+    writer: UIMessageStreamWriter<UIMessage<METADATA, any, TOOLS>>;
+    constructor(writer: UIMessageStreamWriter<UIMessage<METADATA, any, TOOLS>>);
+    generateId: () => string;
+    writeMessageMetadata: <NEW_METADATA extends METADATA>(metadata: NEW_METADATA) => void;
+    writeCustomTool: <K extends keyof TOOLS>(tool: {
+        toolCallId?: string;
+        toolName: K;
+        inputTextDelta?: string[];
+        input?: any;
+        output?: any;
+    }) => void;
+    writeObjectAsTool: <K extends keyof TOOLS>(tool: {
+        toolName: K;
+        result?: GenerateObjectResult<TOOLS[K]["output"]>;
+        input?: GenerateObjectResult<TOOLS[K]["input"]>;
+    }) => void;
+}
+declare const getTextParts: (message: UIMessage | null | undefined) => string[];
+declare const getTextPartsContent: (message: UIMessage | null | undefined) => string;
+declare const findLastMessageWith: <T>(message: UIMessage[] | null | undefined, filters: {
+    role?: "user" | "assistant" | "system";
+    metadata?: Record<string, any>;
+}) => UIMessage<unknown, UIDataTypes, ai.UITools> | null | undefined;
+
+/**
+ * Sets a global logger that will be used by all router instances when no instance-specific logger is set.
+ * This is useful for debugging across multiple router instances.
+ * @param logger The logger to use globally, or undefined to disable global logging
+ */
+declare function setGlobalLogger(logger?: AiLogger): void;
+/**
+ * Gets the current global logger.
+ * @returns The current global logger or undefined if none is set
+ */
+declare function getGlobalLogger(): AiLogger | undefined;
+declare class AiKitError extends Error {
+    constructor(message: string);
+}
+declare class AgentNotFoundError extends AiKitError {
+    constructor(path: string);
+}
+declare class MaxCallDepthExceededError extends AiKitError {
+    constructor(maxDepth: number);
+}
+declare class AgentDefinitionMissingError extends AiKitError {
+    constructor(path: string);
+}
+type AiStreamWriter<METADATA = unknown, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = UIMessageStreamWriter<UIMessage<METADATA, PARTS, TOOLS>> & Omit<StreamWriter<METADATA, TOOLS>, 'writer'> & {
+    generateId: typeof generateId;
+};
+/**
+ * The context object passed to every agent, tool, and middleware. It contains
+ * all the necessary information and utilities for a handler to perform its work.
+ * @template METADATA - The type for custom metadata in UI messages.
+ * @template PARTS - The type for custom parts in UI messages.
+ * @template TOOLS - The type for custom tools in UI messages.
+ * @template ContextState - The type for the shared state object.
+ */
+type AiContext<METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = Record<string, any>, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = {
+    request: {
+        /** The message history for the current request. The user can modify this array to change the message history or manipulate the message history, but beware that in the routing, the messages are passed as a reference and not a copy, making the mutatated value available to all the handlers in the request chain. */
+        messages: UIMessage<METADATA, PARTS, TOOLS>[];
+        /** Parameters passed from an internal tool or agent call. */
+        params: PARAMS;
+        [key: string]: any;
+    } & METADATA;
+    /** A shared, mutable state object that persists for the lifetime of a single request. */
+    state: ContextState;
+    /** A shared, mutable store object that persists for the lifetime of a single request. */
+    store: Store;
+    /**
+     * Internal execution context for the router. Should not be modified by user code.
+     * @internal
+     */
+    executionContext: {
+        handlerPathStack?: string[];
+        currentPath?: string;
+        callDepth?: number;
+        [key: string]: any;
+    };
+    /**
+     * A unique ID for the top-level request, useful for logging and tracing.
+     */
+    requestId: string;
+    /**
+     * A structured logger that automatically includes the `requestId` and current handler path.
+     */
+    logger: AiLogger;
+    /**
+     * The stream writer to send data back to the end-user's UI.
+     * Includes helpers for writing structured data like tool calls and metadata.
+     */
+    response: AiStreamWriter<Partial<METADATA>, PARTS, TOOLS>;
+    /**
+     * Provides functions for an agent to dispatch calls to other agents or tools.
+     * @internal
+     */
+    next: NextHandler<METADATA, ContextState, PARAMS, PARTS, TOOLS>;
+    _onExecutionStart?: () => void;
+    _onExecutionEnd?: () => void;
+};
+/** Represents the `next` function in a middleware chain, used to pass control to the next handler. */
+type NextFunction = () => Promise<any>;
+/** A function that handles a request for a specific agent path. */
+type AiHandler<METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = Record<string, any>, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = (ctx: AiContext<METADATA, ContextState, PARAMS, PARTS, TOOLS>) => Promise<any>;
+/** A function that acts as middleware, processing a request and optionally passing control to the next handler. */
+type AiMiddleware<METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = Record<string, any>, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = (ctx: AiContext<METADATA, ContextState, PARAMS, PARTS, TOOLS>, next: NextFunction) => Promise<any>;
+/** A simple structured logger interface. */
+type AiLogger = {
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+};
+/** Internal representation of a registered handler in the router's stack. */
+type Layer<METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = Record<string, any>, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> = {
+    path: string | RegExp;
+    handler: AiMiddleware<METADATA, ContextState, PARAMS, PARTS, TOOLS>;
+    isAgent: boolean;
+    timing?: 'before' | 'after';
+    hasDynamicParams?: boolean;
+    paramNames?: string[];
+};
+type AgentTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any> = Tool<INPUT, OUTPUT> & {
+    name: string;
+    id: string;
+    metadata?: Record<string, any> & {
+        absolutePath?: string;
+        name?: string;
+        description?: string;
+        toolKey?: string;
+        icon?: string;
+        parentTitle?: string;
+        title?: string;
+        hideUI?: boolean;
+    };
+};
+type AgentData = {
+    metadata?: Record<string, any> & {
+        absolutePath?: string;
+        name?: string;
+        description?: string;
+        toolKey?: string;
+        icon?: string;
+        parentTitle?: string;
+        title?: string;
+        hideUI?: boolean;
+    };
+    [key: string]: any;
+};
+/**
+ * A composable router for building structured, multi-agent AI applications.
+ * It allows you to define agents and tools, compose them together, and handle
+ * requests in a predictable, middleware-style pattern.
+ *
+ * @template KIT_METADATA - The base metadata type for all UI messages in this router.
+ * @template PARTS - The base custom parts type for all UI messages.
+ * @template TOOLS - The base custom tools type for all UI messages.
+ * @template ContextState - The base type for the shared state object.
+ */
+declare class AiRouter<KIT_METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = {}, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools, REGISTERED_TOOLS extends ToolSet = {}> {
+    private stack;
+    actAsToolDefinitions: Map<string | RegExp, AgentTool<any, any>>;
+    private logger?;
+    private _store;
+    /** Configuration options for the router instance. */
+    options: {
+        /** The maximum number of agent-to-agent calls allowed in a single request to prevent infinite loops. */
+        maxCallDepth: number;
+    };
+    /**
+     * Constructs a new AiAgentKit router.
+     * @param stack An optional initial stack of layers, used for composing routers.
+     * @param options Optional configuration for the router.
+     */
+    constructor(stack?: Layer<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS>[], options?: {
+        maxCallDepth?: number;
+        logger?: AiLogger;
+    });
+    setStore(store: Store): void;
+    /**
+     * Sets a logger for this router instance.
+     * If no logger is set, the router will fall back to the global logger.
+     * @param logger The logger to use for this router instance, or undefined to use global logger
+     */
+    setLogger(logger?: AiLogger): void;
+    /**
+     * Gets the effective logger for this router instance.
+     * Returns instance logger if set, otherwise falls back to global logger.
+     * @returns The effective logger or undefined if no logging should occur
+     */
+    private _getEffectiveLogger;
+    /**
+     * Registers a middleware-style agent that runs for a specific path prefix, regex pattern, or wildcard.
+     * Agents can modify the context and must call `next()` to pass control to the next handler in the chain.
+     * This method is primarily for middleware. For terminal agents, see `.agent()` on an instance.
+     *
+     * @param path The path prefix, regex pattern, or "*" for wildcard matching.
+     * @param agents The agent middleware function(s).
+     */
+    agent<const TAgents extends (AiMiddleware<any, any, any, any, any> | AiRouter<any, any, any, any, any, any>)[]>(agentPath: string | RegExp | AiMiddleware<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS>, ...agents: TAgents): AiRouter<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS, REGISTERED_TOOLS & (TAgents[number] extends AiRouter<any, any, any, any, any, infer R> ? R : {})>;
+    /**
+     * Registers middleware that runs BEFORE agent execution for a specific path prefix, regex pattern, or wildcard.
+     * The middleware can modify the context and must call `next()` to pass control to the next handler.
+     *
+     * @param mountPathArg The path prefix, regex pattern, or "*" for wildcard matching.
+     * @param handler The middleware function or AiAgentKit router instance to mount.
+     */
+    before<THandler extends AiMiddleware<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS> | AiRouter<any, any, any, any, any, any>>(mountPathArg: string | RegExp, handler: THandler): AiRouter<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS, REGISTERED_TOOLS & (THandler extends AiRouter<any, any, any, any, any, infer R> ? R : {})>;
+    /**
+     * Registers middleware that runs AFTER agent execution for a specific path prefix, regex pattern, or wildcard.
+     * The middleware can modify the context and must call `next()` to pass control to the next handler.
+     *
+     * @param mountPathArg The path prefix, regex pattern, or "*" for wildcard matching.
+     * @param handler The middleware function or AiAgentKit router instance to mount.
+     */
+    after<THandler extends AiMiddleware<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS> | AiRouter<any, any, any, any, any, any>>(mountPathArg: string | RegExp, handler: THandler): AiRouter<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS, REGISTERED_TOOLS & (THandler extends AiRouter<any, any, any, any, any, infer R> ? R : {})>;
+    /**
+     * Pre-defines the schema and description for an agent when it is used as a tool by an LLM.
+     * This allows `next.agentAsTool()` to create a valid `Tool` object without needing the definition at call time.
+     * @param path The path of the agent being defined.
+     * @param options The tool definition, including a Zod schema and description.
+     */
+    actAsTool<const TPath extends string | RegExp, const TTool extends AgentTool<z.infer<TTool['inputSchema']>, z.infer<TTool['outputSchema']>>>(path: TPath, options: TTool): AiRouter<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS, REGISTERED_TOOLS & {
+        [K in TTool['id']]: Tool<z.infer<TTool['inputSchema']>, z.infer<TTool['outputSchema']>> & {
+            metadata: TTool['metadata'] & {
+                toolKey: TTool['id'];
+                name: TTool['name'];
+                description: TTool['description'];
+            };
+        };
+    }>;
+    getToolSet(): REGISTERED_TOOLS;
+    getToolDefinition(path: string): AgentTool<any, any>;
+    /**
+     * Outputs all registered paths, and the middlewares and agents registered on each path.
+     * @returns A map of paths to their registered handlers.
+     */
+    registry(): {
+        map: Record<string, {
+            before: any[];
+            agents: any[];
+            after: any[];
+        }>;
+        tools: REGISTERED_TOOLS;
+    };
+    /**
+     * Resolves a path based on the parent path and the requested path.
+     * - If path starts with `@/`, it's an absolute path from the root.
+     * - Otherwise, it's a relative path.
+     * @internal
+     */
+    private _resolvePath;
+    /**
+     * Creates a new context for an internal agent or tool call.
+     * It inherits from the parent context but gets a new logger and call depth.
+     * @internal
+     */
+    private _createSubContext;
+    /**
+     * Creates a new logger instance with a structured prefix.
+     * @internal
+     */
+    private _createLogger;
+    /**
+     * Calculates a specificity score for a layer to enable Express-style routing.
+     * Higher score means more specific.
+     * - Middleware is less specific than an agent/tool.
+     * - Deeper paths are more specific.
+     * - Static segments are more specific than dynamic segments.
+     * @internal
+     */
+    private _getSpecificityScore;
+    /**
+     * The core execution engine. It finds all matching layers for a given path
+     * and runs them in a middleware-style chain.
+     * @internal
+     */
+    private _execute;
+    private pendingExecutions;
+    /**
+     * The main public entry point for the router. It handles an incoming request,
+     * sets up the response stream, creates the root context, and starts the execution chain.
+     *
+     * @param path The path of the agent or tool to execute.
+     * @param initialContext The initial context for the request, typically containing messages.
+     * @returns A standard `Response` object containing the rich UI stream.
+     */
+    handle(path: string, initialContext: Omit<AiContext<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS>, 'state' | 'response' | 'next' | 'requestId' | 'logger' | 'executionContext' | 'store'>): Response;
+    handleStream(path: string, initialContext: Omit<AiContext<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS>, 'state' | 'response' | 'next' | 'requestId' | 'logger' | 'executionContext' | 'store'>, executionCompletionPromise: Promise<void>, executionCompletionResolver: (() => void) | null): ReadableStream<ai.InferUIMessageChunk<UIMessage<KIT_METADATA, PARTS, TOOLS>>>;
+    /**
+     * Handles an incoming request and returns a promise that resolves with the full,
+     * non-streamed response. This is useful for environments where streaming is not
+     * desired or for testing.
+     *
+     * @param path The path of the agent or tool to execute.
+     * @param initialContext The initial context for the request, typically containing messages.
+     * @returns A `Promise<Response>` that resolves with the final JSON response.
+     */
+    toAwaitResponse(path: string, initialContext: Omit<AiContext<KIT_METADATA, ContextState, PARAMS, PARTS, TOOLS>, 'state' | 'response' | 'next' | 'requestId' | 'logger' | 'executionContext' | 'store'>): Promise<Response>;
+}
+type AiRouterType = typeof AiRouter;
+declare class NextHandler<METADATA extends Record<string, any> = Record<string, any>, ContextState extends Record<string, any> = Record<string, any>, PARAMS extends Record<string, any> = Record<string, any>, PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
+    private ctx;
+    private router;
+    private onExecutionStart;
+    private onExecutionEnd;
+    maxCallDepth: number;
+    constructor(ctx: AiContext<METADATA, ContextState, PARAMS, PARTS, TOOLS>, router: AiRouter<METADATA, ContextState, PARAMS, PARTS, TOOLS>, onExecutionStart: () => void, onExecutionEnd: () => void, parentNext?: NextHandler<METADATA, ContextState, PARAMS, PARTS, TOOLS>);
+    callAgent(agentPath: string, params?: Record<string, any>, options?: {
+        streamToUI?: boolean;
+    }): Promise<{
+        ok: true;
+        data: any;
+    } | {
+        ok: false;
+        error: Error;
+    }>;
+    agentAsTool<INPUT extends JSONValue | unknown | never = any, OUTPUT = any>(agentPath: string, schemaControl?: Record<string, any> & {
+        disableAllInputs?: boolean;
+    }): {
+        [x: string]: Tool<INPUT, OUTPUT>;
+    };
+    getToolDefinition(agentPath: string | RegExp): AgentTool<any, any> | undefined;
+}
+
+export { type AgentData, AgentDefinitionMissingError, AgentNotFoundError, type AgentTool, type AiContext, type AiHandler, AiKitError, type AiLogger, type AiMiddleware, AiRouter, type AiRouterType, type AiStreamWriter, MaxCallDepthExceededError, type NextFunction, Store, StreamWriter, type UITools, findFirstElement, findLastElement, findLastMessageWith, getGlobalLogger, getTextParts, getTextPartsContent, setGlobalLogger };