@microfox/ai-router 2.1.0 → 2.1.2

package/dist/index.js

@@ -0,0 +1,1164 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentDefinitionMissingError: () => AgentDefinitionMissingError,
+  AgentNotFoundError: () => AgentNotFoundError,
+  AiKitError: () => AiKitError,
+  AiRouter: () => AiRouter,
+  MaxCallDepthExceededError: () => MaxCallDepthExceededError,
+  MemoryStore: () => MemoryStore,
+  StreamWriter: () => StreamWriter,
+  findFirstElement: () => findFirstElement,
+  findLastElement: () => findLastElement,
+  findLastMessageWith: () => findLastMessageWith,
+  getGlobalLogger: () => getGlobalLogger,
+  getTextParts: () => getTextParts,
+  getTextPartsContent: () => getTextPartsContent,
+  setGlobalLogger: () => setGlobalLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/router.ts
+var import_ai = require("ai");
+
+// ../../node_modules/nanoid/index.js
+var import_crypto = __toESM(require("crypto"), 1);
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+var fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    import_crypto.default.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    import_crypto.default.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+};
+var random = (bytes) => {
+  fillPool(bytes |= 0);
+  return pool.subarray(poolOffset - bytes, poolOffset);
+};
+var customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+  let step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+  return (size = defaultSize) => {
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || "";
+        if (id.length === size) return id;
+      }
+    }
+  };
+};
+var customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size, random);
+
+// src/helper.ts
+var findLastElement = (array) => {
+  return array[array.length - 1];
+};
+var findFirstElement = (array) => {
+  return array[0];
+};
+var StreamWriter = class {
+  constructor(writer) {
+    this.generateId = () => {
+      return customAlphabet("1234567890abcdefghijklmnopqrstuvwxyz", 10)();
+    };
+    this.writeMessageMetadata = (metadata) => {
+      return this.writer.write({
+        type: "message-metadata",
+        messageMetadata: metadata
+      });
+    };
+    this.writeCustomTool = (tool2) => {
+      const toolCallId = tool2.toolCallId || tool2.toolName?.toString() + "-" + this.generateId();
+      if ("input" in tool2 && tool2.input) {
+        this.writer.write({
+          type: "tool-input-available",
+          input: tool2.input,
+          toolCallId,
+          toolName: tool2.toolName
+        });
+      }
+      if (tool2.inputTextDelta && tool2.inputTextDelta.length > 0 || "output" in tool2 && tool2.output) {
+        this.writer.write({
+          type: "tool-input-start",
+          toolCallId,
+          toolName: tool2.toolName
+        });
+        if (tool2.inputTextDelta) {
+          for (const delta of tool2.inputTextDelta) {
+            this.writer.write({
+              type: "tool-input-delta",
+              toolCallId,
+              inputTextDelta: delta
+            });
+          }
+        }
+      }
+      if ("output" in tool2 && tool2.output) {
+        this.writer.write({
+          type: "tool-output-available",
+          toolCallId,
+          output: tool2.output
+        });
+      }
+    };
+    this.writeObjectAsTool = (tool2) => {
+      if (!tool2.result?.object) {
+        throw new Error("No object found in the GenerateObjectResult");
+      }
+      const toolCallId = tool2.toolName.toString() + "-" + this.generateId();
+      this.writer.write({
+        type: "tool-input-start",
+        toolCallId,
+        toolName: tool2.toolName
+      });
+      this.writer.write({
+        type: "tool-input-available",
+        toolCallId,
+        input: tool2.input ?? tool2.result ? {
+          usage: tool2.result?.usage,
+          warnings: tool2.result?.warnings,
+          finishReason: tool2.result?.finishReason
+        } : void 0,
+        toolName: tool2.toolName
+      });
+      this.writer.write({
+        type: "tool-output-available",
+        toolCallId,
+        output: tool2.result?.object
+      });
+    };
+    this.writer = writer;
+  }
+};
+var getTextParts = (message) => {
+  if (!message) return [];
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text);
+};
+var getTextPartsContent = (message) => {
+  if (!message) return "";
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("").trim();
+};
+var findLastMessageWith = (message, filters) => {
+  if (!message) return null;
+  return message.filter((m) => {
+    if (filters.role && m.role !== filters.role) return false;
+    if (filters.metadata) {
+      for (const key in filters.metadata) {
+      }
+    }
+    return true;
+  }).pop();
+};
+
+// src/router.ts
+var import_zod = require("zod");
+var import_path = __toESM(require("path"));
+
+// src/store.ts
+var MemoryStore = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async get(key) {
+    return this.store.get(key);
+  }
+  async set(key, value) {
+    this.store.set(key, value);
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async has(key) {
+    return this.store.has(key);
+  }
+};
+
+// src/router.ts
+var globalLogger = void 0;
+function setGlobalLogger(logger) {
+  globalLogger = logger;
+}
+function getGlobalLogger() {
+  return globalLogger;
+}
+function clubParts(parts) {
+  if (!parts || parts.length === 0) return parts;
+  const clubbedParts = [];
+  const toolCallIdGroups = /* @__PURE__ */ new Map();
+  const dataIdGroups = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (part.type?.startsWith("tool-") && part.toolCallId) {
+      const toolCallId = part.toolCallId;
+      if (!toolCallIdGroups.has(toolCallId)) {
+        toolCallIdGroups.set(toolCallId, []);
+      }
+      toolCallIdGroups.get(toolCallId).push(part);
+    } else if (part.type?.startsWith("data-") && part.id) {
+      const id = part.id;
+      if (!dataIdGroups.has(id)) {
+        dataIdGroups.set(id, []);
+      }
+      dataIdGroups.get(id).push(part);
+    } else {
+      clubbedParts.push(part);
+    }
+  }
+  for (const [toolCallId, toolParts] of toolCallIdGroups) {
+    if (toolParts.length === 1) {
+      clubbedParts.push(toolParts[0]);
+    } else {
+      const mergedPart = { ...toolParts[0] };
+      for (let i = 1; i < toolParts.length; i++) {
+        const currentPart = toolParts[i];
+        Object.keys(currentPart).forEach((key) => {
+          if (key !== "type" && key !== "toolCallId") {
+            mergedPart[key] = currentPart[key];
+          }
+        });
+      }
+      clubbedParts.push(mergedPart);
+    }
+  }
+  for (const [id, dataParts] of dataIdGroups) {
+    if (dataParts.length === 1) {
+      clubbedParts.push(dataParts[0]);
+    } else {
+      const mergedPart = { ...dataParts[0] };
+      for (let i = 1; i < dataParts.length; i++) {
+        const currentPart = dataParts[i];
+        Object.keys(currentPart).forEach((key) => {
+          if (key !== "type" && key !== "id") {
+            mergedPart[key] = currentPart[key];
+          }
+        });
+      }
+      clubbedParts.push(mergedPart);
+    }
+  }
+  return clubbedParts;
+}
+var AiKitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AiKitError";
+  }
+};
+var AgentNotFoundError = class extends AiKitError {
+  constructor(path2) {
+    super(`[AiAgentKit] Agent not found for path: ${path2}`);
+    this.name = "AgentNotFoundError";
+  }
+};
+var MaxCallDepthExceededError = class extends AiKitError {
+  constructor(maxDepth) {
+    super(`[AiAgentKit] Agent call depth limit (${maxDepth}) exceeded.`);
+    this.name = "MaxCallDepthExceededError";
+  }
+};
+var AgentDefinitionMissingError = class extends AiKitError {
+  constructor(path2) {
+    super(
+      `[AiAgentKit] agentAsTool: No definition found for "${path2}". Please define it using '.actAsTool()' or pass a definition as the second argument.`
+    );
+    this.name = "AgentDefinitionMissingError";
+  }
+};
+function parsePathPattern(pattern) {
+  const paramNames = [];
+  const parts = pattern.split(/(\/:[^\/]+)/);
+  const regexPattern = parts.map((part) => {
+    if (part.startsWith("/:")) {
+      paramNames.push(part.substring(2));
+      return "/([^/]+)";
+    }
+    return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }).join("");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return { regex, paramNames };
+}
+function extractPathParams(pattern, path2) {
+  const { regex, paramNames } = parsePathPattern(pattern);
+  const match = path2.match(regex);
+  if (!match) {
+    return null;
+  }
+  const params = {};
+  paramNames.forEach((paramName, index) => {
+    const value = match[index + 1];
+    if (value !== void 0) {
+      params[paramName] = value;
+    }
+  });
+  return params;
+}
+var AiRouter = class _AiRouter {
+  /**
+   * 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, options) {
+    this.stack = [];
+    this.actAsToolDefinitions = /* @__PURE__ */ new Map();
+    this.logger = void 0;
+    this._store = new MemoryStore();
+    /** Configuration options for the router instance. */
+    this.options = {
+      maxCallDepth: 10
+    };
+    this.pendingExecutions = 0;
+    if (stack) {
+      this.stack = stack;
+    }
+    if (options?.maxCallDepth) {
+      this.options.maxCallDepth = options.maxCallDepth;
+    }
+  }
+  setStore(store) {
+    this._store = store;
+  }
+  /**
+   * 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) {
+    this.logger = logger;
+  }
+  /**
+   * 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
+   */
+  _getEffectiveLogger() {
+    return this.logger ?? globalLogger;
+  }
+  /**
+   * 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(agentPath, ...agents) {
+    let prefix = "/";
+    if (typeof agentPath === "string" || agentPath instanceof RegExp) {
+      prefix = agentPath;
+    } else {
+      agents.unshift(agentPath);
+    }
+    for (const handler of agents) {
+      if (typeof handler !== "function") {
+        if (handler instanceof _AiRouter && typeof prefix === "string") {
+          const router = handler;
+          const mountPath = prefix.toString().replace(/\/$/, "");
+          router.stack.forEach((layer) => {
+            const layerPath = layer.path.toString();
+            const relativeLayerPath = layerPath.startsWith("/") ? layerPath.substring(1) : layerPath;
+            const newPath = import_path.default.posix.join(mountPath, relativeLayerPath);
+            this.stack.push({ ...layer, path: newPath });
+          });
+          router.actAsToolDefinitions.forEach((value, key) => {
+            const keyPath = key.toString();
+            const relativeKeyPath = keyPath.startsWith("/") ? keyPath.substring(1) : keyPath;
+            const newKey = import_path.default.posix.join(mountPath, relativeKeyPath);
+            this.actAsToolDefinitions.set(newKey, value);
+          });
+        }
+        continue;
+      }
+      this.stack.push({
+        path: prefix,
+        handler,
+        isAgent: true
+        // Mark as an agent
+      });
+      this.logger?.log(`Agent registered: path=${prefix}`);
+    }
+    return this;
+  }
+  /**
+   * 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(mountPathArg, handler) {
+    if (mountPathArg instanceof RegExp && handler instanceof _AiRouter) {
+      throw new AiKitError(
+        "[AiAgentKit] Mounting a router on a RegExp path is not supported."
+      );
+    }
+    if (handler instanceof _AiRouter) {
+      const router = handler;
+      const mountPath = mountPathArg.toString().replace(/\/$/, "");
+      router.stack.forEach((layer) => {
+        const layerPath = layer.path.toString();
+        const relativeLayerPath = layerPath.startsWith("/") ? layerPath.substring(1) : layerPath;
+        const newPath = import_path.default.posix.join(mountPath, relativeLayerPath);
+        this.stack.push({ ...layer, path: newPath });
+      });
+      router.actAsToolDefinitions.forEach((value, key) => {
+        const keyPath = key.toString();
+        const relativeKeyPath = keyPath.startsWith("/") ? keyPath.substring(1) : keyPath;
+        const newKey = import_path.default.posix.join(mountPath, relativeKeyPath);
+        this.actAsToolDefinitions.set(newKey, value);
+      });
+    } else {
+      this.stack.push({
+        path: mountPathArg,
+        handler,
+        isAgent: false,
+        // Middleware is not a terminal agent
+        timing: "before"
+        // Mark as before middleware
+      });
+    }
+    return this;
+  }
+  /**
+   * 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(mountPathArg, handler) {
+    if (mountPathArg instanceof RegExp && handler instanceof _AiRouter) {
+      throw new AiKitError(
+        "[AiAgentKit] Mounting a router on a RegExp path is not supported."
+      );
+    }
+    if (handler instanceof _AiRouter) {
+      const router = handler;
+      const mountPath = mountPathArg.toString().replace(/\/$/, "");
+      router.stack.forEach((layer) => {
+        const layerPath = layer.path.toString();
+        const relativeLayerPath = layerPath.startsWith("/") ? layerPath.substring(1) : layerPath;
+        const newPath = import_path.default.posix.join(mountPath, relativeLayerPath);
+        this.stack.push({ ...layer, path: newPath });
+      });
+      router.actAsToolDefinitions.forEach((value, key) => {
+        const keyPath = key.toString();
+        const relativeKeyPath = keyPath.startsWith("/") ? keyPath.substring(1) : keyPath;
+        const newKey = import_path.default.posix.join(mountPath, relativeKeyPath);
+        this.actAsToolDefinitions.set(newKey, value);
+      });
+    } else {
+      this.stack.push({
+        path: mountPathArg,
+        handler,
+        isAgent: false,
+        // Middleware is not a terminal agent
+        timing: "after"
+        // Mark as after middleware
+      });
+    }
+    return this;
+  }
+  /**
+   * 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(path2, options) {
+    this.actAsToolDefinitions.set(path2, options);
+    this.logger?.log(`[actAsTool] Added definition: at path ${path2}`);
+    this.logger?.log(
+      `[actAsTool] Router now has ${this.actAsToolDefinitions.size} definitions`
+    );
+    return this;
+  }
+  getToolSet() {
+    let allTools = Array.from(this.actAsToolDefinitions.entries()).map(
+      ([key, value]) => {
+        return {
+          ...value,
+          metadata: {
+            ...value.metadata,
+            absolutePath: key
+          }
+        };
+      }
+    );
+    return allTools.reduce((acc, _tool) => {
+      const { inputSchema, outputSchema } = _tool;
+      acc[_tool.id] = {
+        ...(0, import_ai.tool)(
+          _tool
+        ),
+        metadata: {
+          ..._tool.metadata,
+          toolKey: _tool.id,
+          name: _tool.name,
+          description: _tool.description
+        }
+      };
+      return acc;
+    }, {});
+  }
+  getToolDefinition(path2) {
+    let definition = this.actAsToolDefinitions.get(path2);
+    if (!definition) {
+      this.logger?.error(
+        `[getToolDefinition] No definition found for path: ${path2}`
+      );
+      throw new AgentDefinitionMissingError(path2);
+    }
+    return definition;
+  }
+  /**
+   * Outputs all registered paths, and the middlewares and agents registered on each path.
+   * @returns A map of paths to their registered handlers.
+   */
+  registry() {
+    const registryMap = {};
+    for (const layer of this.stack) {
+      const pathKey = layer.path.toString();
+      if (!registryMap[pathKey]) {
+        registryMap[pathKey] = { before: [], agents: [], after: [] };
+      }
+      if (layer.isAgent) {
+        const agentInfo = {
+          handler: layer.handler.name || "anonymous"
+        };
+        const actAsToolDef = this.actAsToolDefinitions.get(layer.path);
+        if (actAsToolDef) {
+          agentInfo.actAsTool = {
+            ...actAsToolDef
+          };
+        }
+        registryMap[pathKey].agents.push(agentInfo);
+      } else {
+        const middlewareInfo = {
+          handler: layer.handler.name || "anonymous",
+          timing: layer.timing || "middleware"
+        };
+        if (layer.timing === "before") {
+          registryMap[pathKey].before.push(middlewareInfo);
+        } else if (layer.timing === "after") {
+          registryMap[pathKey].after.push(middlewareInfo);
+        } else {
+          registryMap[pathKey].before.push(middlewareInfo);
+        }
+      }
+    }
+    return {
+      map: registryMap,
+      tools: this.getToolSet()
+    };
+  }
+  /**
+   * 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
+   */
+  _resolvePath(parentPath, newPath) {
+    if (newPath.startsWith("@/")) {
+      return import_path.default.posix.normalize(newPath.substring(1));
+    }
+    const joinedPath = import_path.default.posix.join(parentPath, newPath);
+    return joinedPath;
+  }
+  /**
+   * 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
+   */
+  _createSubContext(parentCtx, options) {
+    const parentDepth = parentCtx.executionContext.callDepth ?? 0;
+    const newCallDepth = parentDepth + (options.type === "agent" ? 1 : 0);
+    const subContext = {
+      ...parentCtx,
+      // State is passed by reference to allow sub-agents to modify the parent's state.
+      // The execution context is a shallow copy to ensure call-specific data is isolated.
+      state: parentCtx.state,
+      store: parentCtx.store,
+      executionContext: {
+        ...parentCtx.executionContext,
+        currentPath: options.path,
+        callDepth: newCallDepth
+      },
+      request: {
+        ...parentCtx.request,
+        messages: options.messages || parentCtx.request.messages || [],
+        params: options.params,
+        path: options.path
+        // The path to execute
+      },
+      logger: this._createLogger(
+        parentCtx.requestId,
+        options.path,
+        newCallDepth
+      ),
+      next: void 0
+      // Will be replaced right after
+    };
+    subContext.executionContext.currentPath = options.path;
+    subContext.next = new NextHandler(
+      subContext,
+      this,
+      parentCtx._onExecutionStart,
+      parentCtx._onExecutionEnd,
+      parentCtx.next
+    );
+    return subContext;
+  }
+  /**
+   * Creates a new logger instance with a structured prefix.
+   * @internal
+   */
+  _createLogger(requestId, path2, callDepth = 0) {
+    const effectiveLogger = this._getEffectiveLogger();
+    if (!effectiveLogger) {
+      return {
+        log: () => {
+        },
+        warn: () => {
+        },
+        error: () => {
+        }
+      };
+    }
+    const indent = "  ".repeat(callDepth);
+    const prefix = `${indent}[${path2.toString()}]`;
+    const fullPrefix = `[${requestId}]${prefix}`;
+    return {
+      log: (...args) => effectiveLogger.log(fullPrefix, ...args),
+      warn: (...args) => effectiveLogger.warn(fullPrefix, ...args),
+      error: (...args) => effectiveLogger.error(fullPrefix, ...args)
+    };
+  }
+  /**
+   * 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
+   */
+  _getSpecificityScore(layer) {
+    const path2 = layer.path.toString();
+    let score = 0;
+    score += path2.split("/").length * 100;
+    score -= (path2.match(/:/g) || []).length * 10;
+    if (layer.path instanceof RegExp) {
+      score -= 50;
+    }
+    if (layer.isAgent) {
+      score += 1;
+    }
+    return score;
+  }
+  /**
+   * The core execution engine. It finds all matching layers for a given path
+   * and runs them in a middleware-style chain.
+   * @internal
+   */
+  async _execute(path2, ctx, isInternalCall = false) {
+    try {
+      const normalizedPath = path2.length > 1 && path2.endsWith("/") ? path2.slice(0, -1) : path2;
+      ctx.logger.log(`Executing path. isInternalCall=${isInternalCall}`);
+      const layersToRun = this.stack.filter((layer) => {
+        let shouldRun = false;
+        if (layer.path instanceof RegExp) {
+          if (isInternalCall) {
+            const exactRegex = new RegExp(`^${layer.path.source}$`);
+            shouldRun = exactRegex.test(normalizedPath);
+          } else {
+            shouldRun = layer.path.test(normalizedPath);
+          }
+        } else if (typeof layer.path === "string") {
+          const layerPath = layer.path;
+          if (layerPath === "*") {
+            return !isInternalCall;
+          }
+          const normalizedLayerPath = layerPath.length > 1 && layerPath.endsWith("/") ? layerPath.slice(0, -1) : layerPath;
+          const isExactMatch = normalizedPath === normalizedLayerPath;
+          if (isInternalCall) {
+            shouldRun = isExactMatch;
+          } else {
+            if (layer.isAgent) {
+              shouldRun = isExactMatch;
+            } else {
+              shouldRun = normalizedPath.startsWith(normalizedLayerPath);
+            }
+          }
+        }
+        if (shouldRun) {
+          ctx.logger.log(
+            `[AiAgentKit][_execute] Layer MATCH: path=${normalizedPath}, layer.path=${layer.path}, isAgent=${layer.isAgent}, isInternal=${isInternalCall}`
+          );
+        }
+        return shouldRun;
+      });
+      const beforeLayers = layersToRun.filter(
+        (l) => !l.isAgent && l.timing === "before"
+      );
+      const agentLayers = layersToRun.filter((l) => l.isAgent);
+      const afterLayers = layersToRun.filter(
+        (l) => !l.isAgent && l.timing === "after"
+      );
+      beforeLayers.sort(
+        (a, b) => this._getSpecificityScore(a) - this._getSpecificityScore(b)
+      );
+      agentLayers.sort(
+        (a, b) => this._getSpecificityScore(a) - this._getSpecificityScore(b)
+      );
+      afterLayers.sort(
+        (a, b) => this._getSpecificityScore(a) - this._getSpecificityScore(b)
+      );
+      const orderedLayers = [...beforeLayers, ...agentLayers, ...afterLayers];
+      const layerDescriptions = orderedLayers.map((l) => {
+        const type = l.isAgent ? "agent" : l.timing === "before" ? "before" : l.timing === "after" ? "after" : "middleware";
+        return `${l.path.toString()} (${type})`;
+      });
+      ctx.logger.log(
+        `Found ${orderedLayers.length} layers to run: [${layerDescriptions.join(
+          ", "
+        )}]`
+      );
+      if (!agentLayers.length && !beforeLayers.length && !afterLayers.length) {
+        const errorMsg = `No agent or tool found for path: ${normalizedPath}`;
+        ctx.logger.error(errorMsg);
+        throw new AgentNotFoundError(normalizedPath);
+      }
+      const dispatch = async (index) => {
+        const layer = orderedLayers[index];
+        if (!layer) {
+          return;
+        }
+        const next = () => dispatch(index + 1);
+        const layerPath = typeof layer.path === "string" ? layer.path : layer.path.toString();
+        const layerType = layer.isAgent ? "agent" : layer.timing === "before" ? "before" : layer.timing === "after" ? "after" : "middleware";
+        ctx.logger.log(`-> Running ${layerType}: ${layerPath}`);
+        try {
+          if (ctx._onExecutionStart) {
+            ctx._onExecutionStart();
+          }
+          const result = await layer.handler(ctx, next);
+          ctx.logger.log(`<- Finished ${layerType}: ${layerPath}`);
+          return result;
+        } catch (err) {
+          ctx.logger.error(
+            `Error in ${layerType} layer for path: ${layerPath}`,
+            err
+          );
+          throw err;
+        } finally {
+          if (ctx._onExecutionEnd) {
+            ctx._onExecutionEnd();
+          }
+        }
+      };
+      return await dispatch(0);
+    } finally {
+    }
+  }
+  /**
+   * 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(path2, initialContext) {
+    this.logger?.log(`Handling request for path: ${path2}`);
+    const self = this;
+    let executionCompletionResolver = null;
+    const executionCompletionPromise = new Promise((resolve) => {
+      executionCompletionResolver = resolve;
+    });
+    return (0, import_ai.createUIMessageStreamResponse)({
+      stream: self.handleStream(
+        path2,
+        initialContext,
+        executionCompletionPromise,
+        executionCompletionResolver
+      )
+    });
+  }
+  handleStream(path2, initialContext, executionCompletionPromise, executionCompletionResolver) {
+    const self = this;
+    return (0, import_ai.createUIMessageStream)({
+      originalMessages: initialContext.request.messages,
+      execute: async ({ writer }) => {
+        const streamWriter = new StreamWriter(writer);
+        const requestId = (0, import_ai.generateId)();
+        const store = self._store instanceof MemoryStore ? new MemoryStore() : self._store;
+        const ctx = {
+          ...initialContext,
+          request: {
+            ...initialContext.request,
+            path: path2
+            // Set the initial path for the root context
+          },
+          state: {},
+          store,
+          executionContext: { currentPath: path2, callDepth: 0 },
+          requestId,
+          logger: self._createLogger(requestId, path2, 0),
+          response: {
+            ...streamWriter.writer,
+            writeMessageMetadata: streamWriter.writeMessageMetadata,
+            writeCustomTool: streamWriter.writeCustomTool,
+            writeObjectAsTool: streamWriter.writeObjectAsTool,
+            generateId: import_ai.generateId
+          },
+          next: void 0,
+          // Will be replaced right after
+          _onExecutionStart: () => {
+            self.pendingExecutions++;
+            self.logger?.log(
+              `[AiAgentKit][lifecycle] Execution started. Pending: ${self.pendingExecutions}`
+            );
+          },
+          _onExecutionEnd: () => {
+            self.pendingExecutions--;
+            self.logger?.log(
+              `[AiAgentKit][lifecycle] Execution ended. Pending: ${self.pendingExecutions}`
+            );
+            if (self.pendingExecutions === 0 && executionCompletionResolver) {
+              self.logger?.log(
+                `[AiAgentKit][lifecycle] All executions finished. Resolving promise.`
+              );
+              executionCompletionResolver();
+            }
+          }
+        };
+        ctx.next = new NextHandler(
+          ctx,
+          self,
+          ctx._onExecutionStart,
+          ctx._onExecutionEnd
+        );
+        ctx._onExecutionStart();
+        self.logger?.log(
+          `[AiAgentKit][lifecycle] Main execution chain started.`
+        );
+        try {
+          const response = await self._execute(path2, ctx);
+          const toolDefinition = this.actAsToolDefinitions.get(path2);
+          if (toolDefinition && !toolDefinition.metadata?.hideUI) {
+            ctx.response.writeCustomTool({
+              toolName: toolDefinition.id,
+              toolCallId: toolDefinition.id + "-" + ctx.response.generateId(),
+              output: response
+            });
+          }
+          return response;
+        } catch (err) {
+          ctx.logger.error("Unhandled error in main execution chain", err);
+        } finally {
+          ctx._onExecutionEnd();
+          self.logger?.log(
+            `[AiAgentKit][lifecycle] Main execution chain finished.`
+          );
+        }
+        await executionCompletionPromise;
+        self.logger?.log(
+          `[AiAgentKit][lifecycle] All executions truly finished. Stream can be safely closed.`
+        );
+      }
+    });
+  }
+  /**
+   * 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.
+   */
+  async toAwaitResponse(path2, initialContext) {
+    this.logger?.log(`Handling request for path: ${path2}`);
+    const self = this;
+    let executionCompletionResolver = null;
+    const executionCompletionPromise = new Promise((resolve) => {
+      executionCompletionResolver = resolve;
+    });
+    const stream = this.handleStream(
+      path2,
+      initialContext,
+      executionCompletionPromise,
+      executionCompletionResolver
+    );
+    const messageStream = (0, import_ai.readUIMessageStream)({
+      stream,
+      onError: (error) => {
+        this.logger?.error("Error reading UI message stream", error);
+      }
+    });
+    let finalMessages = [];
+    const thisMessageId = (0, import_ai.generateId)();
+    for await (const message of messageStream) {
+      if (message.id?.length > 0) {
+        finalMessages.push(message);
+      } else if (finalMessages.find((m) => m.id === thisMessageId)) {
+        finalMessages = finalMessages.map(
+          (m) => m.id === thisMessageId ? {
+            ...m,
+            metadata: {
+              ...m.metadata ?? {},
+              ...message.metadata ?? {}
+            },
+            parts: clubParts([
+              ...m.parts ?? [],
+              ...message.parts ?? []
+            ])
+          } : m
+        );
+      } else {
+        finalMessages.push({
+          ...message,
+          id: thisMessageId
+        });
+      }
+    }
+    const responseBody = JSON.stringify(finalMessages);
+    return new Response(responseBody, {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+var NextHandler = class {
+  constructor(ctx, router, onExecutionStart, onExecutionEnd, parentNext) {
+    this.ctx = ctx;
+    this.router = router;
+    this.onExecutionStart = onExecutionStart;
+    this.onExecutionEnd = onExecutionEnd;
+    this.maxCallDepth = this.router.options.maxCallDepth;
+  }
+  async callAgent(agentPath, params, options) {
+    this.onExecutionStart();
+    try {
+      const currentDepth = this.ctx.executionContext.callDepth ?? 0;
+      if (currentDepth >= this.maxCallDepth) {
+        const err = new MaxCallDepthExceededError(this.maxCallDepth);
+        this.ctx.logger.error(`[callAgent] Aborting. ${err.message}`);
+        throw err;
+      }
+      const parentPath = this.ctx.executionContext.currentPath || "/";
+      const resolvedPath = this.router._resolvePath(
+        parentPath,
+        agentPath
+      );
+      this.ctx.logger.log(`Calling agent: resolvedPath='${resolvedPath}'`);
+      const subContext = this.router._createSubContext(this.ctx, {
+        type: "agent",
+        path: resolvedPath,
+        params: params ?? {},
+        messages: this.ctx.request.messages
+      });
+      const definition = this.router.actAsToolDefinitions.get(resolvedPath);
+      const toolCallId = definition?.id + "-" + this.ctx.response.generateId();
+      if (options?.streamToUI && definition) {
+        this.ctx.response.writeCustomTool({
+          toolName: definition?.id,
+          toolCallId,
+          input: subContext.request.params
+        });
+      }
+      const data = await this.router._execute(
+        resolvedPath,
+        subContext,
+        true
+      );
+      if (options?.streamToUI && definition) {
+        this.ctx.response.writeCustomTool({
+          toolName: definition?.id,
+          toolCallId,
+          output: data
+        });
+      }
+      return { ok: true, data };
+    } catch (error) {
+      this.ctx.logger.error(`[callAgent] Error:`, error);
+      return { ok: false, error };
+    } finally {
+      this.onExecutionEnd();
+    }
+  }
+  agentAsTool(agentPath, schemaControl) {
+    const parentPath = this.ctx.executionContext.currentPath || "/";
+    const resolvedPath = this.router._resolvePath(
+      parentPath,
+      agentPath
+    );
+    const definition = this.getToolDefinition(agentPath);
+    if (!definition) {
+      this.ctx.logger.error(
+        `[agentAsTool] No definition found for agent at resolved path: ${resolvedPath}`
+      );
+      throw new AgentDefinitionMissingError(resolvedPath);
+    }
+    const originalSchema = definition.inputSchema;
+    let finalSchema = originalSchema;
+    const fixedParams = {};
+    if (schemaControl) {
+      if (schemaControl.disableAllInputs) {
+        finalSchema = import_zod.z.object({});
+      } else if (originalSchema) {
+        let isPickMode = false;
+        for (const key in schemaControl) {
+          if (schemaControl[key] === true) {
+            isPickMode = true;
+            break;
+          }
+        }
+        if (isPickMode) {
+          const pickShape = {};
+          for (const key in schemaControl) {
+            if (schemaControl[key] === true) {
+              pickShape[key] = true;
+            } else {
+              fixedParams[key] = schemaControl[key];
+            }
+          }
+          finalSchema = originalSchema.pick(pickShape);
+        } else {
+          const omitShape = {};
+          for (const key in schemaControl) {
+            if (key !== "disableAllInputs") {
+              fixedParams[key] = schemaControl[key];
+              omitShape[key] = true;
+            }
+          }
+          finalSchema = originalSchema.omit(omitShape);
+        }
+      }
+    }
+    const { id, metadata, ...restDefinition } = definition;
+    restDefinition.inputSchema = finalSchema;
+    return {
+      [id]: {
+        ...restDefinition,
+        metadata: {
+          ...metadata,
+          toolKey: id,
+          name: restDefinition.name,
+          description: restDefinition.description,
+          absolutePath: resolvedPath
+        },
+        execute: async (params, options) => {
+          const result = await this.callAgent(agentPath, params, options);
+          if (!result.ok) {
+            throw result.error;
+          }
+          return result.data;
+        }
+      }
+    };
+  }
+  getToolDefinition(agentPath) {
+    const parentPath = this.ctx.executionContext.currentPath || "/";
+    const resolvedPath = this.router._resolvePath(
+      parentPath,
+      agentPath.toString()
+    );
+    let preDefined;
+    const pathsToTry = [resolvedPath];
+    if (typeof agentPath === "string" && agentPath.startsWith("/")) {
+      pathsToTry.unshift(agentPath);
+    }
+    for (const pathToTry of pathsToTry) {
+      for (const [key, value] of this.router.actAsToolDefinitions) {
+        if (typeof key === "string") {
+          if (key === pathToTry) {
+            preDefined = value;
+            break;
+          }
+          if (extractPathParams(key, pathToTry) !== null) {
+            preDefined = value;
+            break;
+          }
+        }
+        if (key instanceof RegExp && key.test(pathToTry)) {
+          preDefined = value;
+          break;
+        }
+      }
+      if (preDefined) break;
+    }
+    const definition = preDefined;
+    if (!definition) {
+      this.ctx.logger.error(
+        `[agentAsTool] No definition found for agent at resolved path: ${resolvedPath}`
+      );
+      return void 0;
+    }
+    const { metadata, ...restDefinition } = definition;
+    return {
+      ...restDefinition,
+      metadata: {
+        ...metadata,
+        toolKey: restDefinition.id,
+        name: restDefinition.name,
+        description: restDefinition.description,
+        absolutePath: resolvedPath
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentDefinitionMissingError,
+  AgentNotFoundError,
+  AiKitError,
+  AiRouter,
+  MaxCallDepthExceededError,
+  MemoryStore,
+  StreamWriter,
+  findFirstElement,
+  findLastElement,
+  findLastMessageWith,
+  getGlobalLogger,
+  getTextParts,
+  getTextPartsContent,
+  setGlobalLogger
+});
+//# sourceMappingURL=index.js.map