@dexto/agent-management 1.5.2 → 1.5.4

package/dist/runtime/AgentRuntime.cjs

@@ -0,0 +1,225 @@
+"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);
+var AgentRuntime_exports = {};
+__export(AgentRuntime_exports, {
+  AgentRuntime: () => AgentRuntime
+});
+module.exports = __toCommonJS(AgentRuntime_exports);
+var import_crypto = require("crypto");
+var import_core = require("@dexto/core");
+var import_config = require("../config/index.js");
+var import_AgentPool = require("./AgentPool.js");
+var import_errors = require("./errors.js");
+var import_schemas = require("./schemas.js");
+class AgentRuntime {
+  pool;
+  config;
+  logger;
+  constructor(options) {
+    this.config = import_schemas.AgentRuntimeConfigSchema.parse(options.config ?? {});
+    this.logger = options.logger;
+    this.pool = new import_AgentPool.AgentPool(this.config, this.logger);
+    this.logger.debug("AgentRuntime initialized", {
+      maxAgents: this.config.maxAgents,
+      defaultTaskTimeout: this.config.defaultTaskTimeout
+    });
+  }
+  /**
+   * Spawn a new agent
+   *
+   * @param config - Configuration for the agent
+   * @returns Handle to the spawned agent
+   */
+  async spawnAgent(config) {
+    if (!this.pool.canSpawn()) {
+      throw import_errors.RuntimeError.maxAgentsExceeded(this.pool.size, this.config.maxAgents);
+    }
+    const agentId = config.agentId ?? `agent-${(0, import_crypto.randomUUID)().slice(0, 8)}`;
+    if (this.pool.has(agentId)) {
+      throw import_errors.RuntimeError.agentAlreadyExists(agentId);
+    }
+    try {
+      const enrichedConfig = (0, import_config.enrichAgentConfig)(
+        config.agentConfig,
+        void 0,
+        // No config path
+        false
+        // Not interactive CLI
+      );
+      enrichedConfig.agentId = agentId;
+      const agent = new import_core.DextoAgent(enrichedConfig);
+      const sessionId = `session-${(0, import_crypto.randomUUID)().slice(0, 8)}`;
+      const handle = {
+        agentId,
+        agent,
+        status: "starting",
+        ephemeral: config.ephemeral ?? true,
+        createdAt: /* @__PURE__ */ new Date(),
+        sessionId
+      };
+      if (config.group !== void 0) {
+        handle.group = config.group;
+      }
+      if (config.metadata !== void 0) {
+        handle.metadata = config.metadata;
+      }
+      this.pool.add(handle);
+      if (config.onBeforeStart) {
+        await config.onBeforeStart(agent);
+      }
+      await agent.start();
+      this.pool.updateStatus(agentId, "idle");
+      this.logger.info(
+        `Spawned agent '${agentId}'${handle.group ? ` (group: ${handle.group})` : ""} (ephemeral: ${handle.ephemeral})`
+      );
+      return handle;
+    } catch (error) {
+      this.pool.remove(agentId);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw import_errors.RuntimeError.spawnFailed(errorMessage, agentId);
+    }
+  }
+  /**
+   * Execute a task on an agent
+   *
+   * @param agentId - ID of the agent
+   * @param task - Task description to execute
+   * @param timeout - Optional timeout in milliseconds
+   * @returns Task result with response or error
+   */
+  async executeTask(agentId, task, timeout) {
+    const handle = this.pool.get(agentId);
+    if (!handle) {
+      throw import_errors.RuntimeError.agentNotFound(agentId);
+    }
+    if (handle.status === "stopped" || handle.status === "error") {
+      throw import_errors.RuntimeError.agentAlreadyStopped(agentId);
+    }
+    const taskTimeout = timeout ?? this.config.defaultTaskTimeout;
+    this.pool.updateStatus(agentId, "running");
+    try {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(import_errors.RuntimeError.taskTimeout(agentId, taskTimeout));
+        }, taskTimeout);
+      });
+      const generatePromise = handle.agent.generate(task, handle.sessionId);
+      const response = await Promise.race([
+        generatePromise,
+        timeoutPromise
+      ]);
+      this.pool.updateStatus(agentId, "idle");
+      const result = {
+        success: true,
+        response: response.content,
+        agentId,
+        tokenUsage: {
+          input: response.usage.inputTokens,
+          output: response.usage.outputTokens,
+          total: response.usage.totalTokens
+        }
+      };
+      this.logger.debug(`Task completed for agent '${agentId}'`);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.pool.updateStatus(agentId, "error", errorMessage);
+      if (error instanceof Error && error.message.includes("Task execution timed out")) {
+        return {
+          success: false,
+          error: errorMessage,
+          agentId
+        };
+      }
+      throw import_errors.RuntimeError.taskFailed(agentId, errorMessage);
+    }
+  }
+  /**
+   * Get an agent handle by ID
+   */
+  getAgent(agentId) {
+    return this.pool.get(agentId);
+  }
+  /**
+   * List agents matching the given filter
+   */
+  listAgents(filter) {
+    return this.pool.list(filter);
+  }
+  /**
+   * Stop a specific agent
+   */
+  async stopAgent(agentId) {
+    const handle = this.pool.get(agentId);
+    if (!handle) {
+      throw import_errors.RuntimeError.agentNotFound(agentId);
+    }
+    if (handle.status === "stopped") {
+      this.logger.debug(`Agent '${agentId}' already stopped`);
+      return;
+    }
+    this.pool.updateStatus(agentId, "stopping");
+    try {
+      handle.agent.services.approvalManager.cancelAllApprovals();
+      await handle.agent.stop();
+      this.pool.updateStatus(agentId, "stopped");
+      this.logger.debug(`Stopped agent '${agentId}'`);
+      if (handle.ephemeral) {
+        this.pool.remove(agentId);
+        this.logger.debug(`Removed ephemeral agent '${agentId}' from pool`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.pool.updateStatus(agentId, "error", errorMessage);
+      this.logger.error(`Failed to stop agent '${agentId}': ${errorMessage}`);
+    }
+  }
+  /**
+   * Stop all agents matching the given filter
+   */
+  async stopAll(filter) {
+    const agents = this.pool.list(filter);
+    this.logger.debug(`Stopping ${agents.length} agents`);
+    await Promise.allSettled(agents.map((handle) => this.stopAgent(handle.agentId)));
+  }
+  /**
+   * Get the runtime configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get statistics about the runtime
+   */
+  getStats() {
+    const agents = this.pool.getAll();
+    const byStatus = {};
+    for (const agent of agents) {
+      byStatus[agent.status] = (byStatus[agent.status] ?? 0) + 1;
+    }
+    return {
+      totalAgents: agents.length,
+      byStatus
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRuntime
+});

package/dist/runtime/AgentRuntime.d.ts

@@ -0,0 +1,77 @@
+/**
+ * AgentRuntime - General-Purpose Agent Lifecycle Manager
+ *
+ * Manages the lifecycle of multiple agent instances. Can be used for:
+ * - Dashboard spawning multiple independent agents
+ * - Agent task delegation (parent spawns sub-agents)
+ * - Test harnesses managing multiple agents
+ * - Any scenario requiring multiple concurrent agents
+ *
+ * Key responsibilities:
+ * - Spawn and manage agents with configurable limits
+ * - Execute tasks on agents with timeout handling
+ * - Track agent status and lifecycle
+ * - Clean up agents when no longer needed
+ */
+import { type IDextoLogger } from '@dexto/core';
+import type { AgentRuntimeConfig, SpawnConfig, AgentHandle, TaskResult, AgentFilter } from './types.js';
+import { type ValidatedAgentRuntimeConfig } from './schemas.js';
+/**
+ * Options for creating an AgentRuntime
+ */
+export interface AgentRuntimeOptions {
+    /** Runtime configuration */
+    config?: AgentRuntimeConfig;
+    /** Logger instance */
+    logger: IDextoLogger;
+}
+export declare class AgentRuntime {
+    private pool;
+    private config;
+    private logger;
+    constructor(options: AgentRuntimeOptions);
+    /**
+     * Spawn a new agent
+     *
+     * @param config - Configuration for the agent
+     * @returns Handle to the spawned agent
+     */
+    spawnAgent(config: SpawnConfig): Promise<AgentHandle>;
+    /**
+     * Execute a task on an agent
+     *
+     * @param agentId - ID of the agent
+     * @param task - Task description to execute
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Task result with response or error
+     */
+    executeTask(agentId: string, task: string, timeout?: number): Promise<TaskResult>;
+    /**
+     * Get an agent handle by ID
+     */
+    getAgent(agentId: string): AgentHandle | undefined;
+    /**
+     * List agents matching the given filter
+     */
+    listAgents(filter?: AgentFilter): AgentHandle[];
+    /**
+     * Stop a specific agent
+     */
+    stopAgent(agentId: string): Promise<void>;
+    /**
+     * Stop all agents matching the given filter
+     */
+    stopAll(filter?: AgentFilter): Promise<void>;
+    /**
+     * Get the runtime configuration
+     */
+    getConfig(): ValidatedAgentRuntimeConfig;
+    /**
+     * Get statistics about the runtime
+     */
+    getStats(): {
+        totalAgents: number;
+        byStatus: Record<string, number>;
+    };
+}
+//# sourceMappingURL=AgentRuntime.d.ts.map

package/dist/runtime/AgentRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentRuntime.d.ts","sourceRoot":"","sources":["../../src/runtime/AgentRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAc,KAAK,YAAY,EAAyB,MAAM,aAAa,CAAC;AAInF,OAAO,KAAK,EACR,kBAAkB,EAClB,WAAW,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAA4B,KAAK,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,4BAA4B;IAC5B,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,sBAAsB;IACtB,MAAM,EAAE,YAAY,CAAC;CACxB;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,MAAM,CAAe;gBAEjB,OAAO,EAAE,mBAAmB;IAYxC;;;;;OAKG;IACG,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IA0E3D;;;;;;;OAOG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAoEvF;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIlD;;OAEG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE;IAI/C;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC/C;;OAEG;IACG,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IASlD;;OAEG;IACH,SAAS,IAAI,2BAA2B;IAIxC;;OAEG;IACH,QAAQ,IAAI;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE;CAaxE"}

package/dist/runtime/AgentRuntime.js

@@ -0,0 +1,201 @@
+import { randomUUID } from "crypto";
+import { DextoAgent } from "@dexto/core";
+import { enrichAgentConfig } from "../config/index.js";
+import { AgentPool } from "./AgentPool.js";
+import { RuntimeError } from "./errors.js";
+import { AgentRuntimeConfigSchema } from "./schemas.js";
+class AgentRuntime {
+  pool;
+  config;
+  logger;
+  constructor(options) {
+    this.config = AgentRuntimeConfigSchema.parse(options.config ?? {});
+    this.logger = options.logger;
+    this.pool = new AgentPool(this.config, this.logger);
+    this.logger.debug("AgentRuntime initialized", {
+      maxAgents: this.config.maxAgents,
+      defaultTaskTimeout: this.config.defaultTaskTimeout
+    });
+  }
+  /**
+   * Spawn a new agent
+   *
+   * @param config - Configuration for the agent
+   * @returns Handle to the spawned agent
+   */
+  async spawnAgent(config) {
+    if (!this.pool.canSpawn()) {
+      throw RuntimeError.maxAgentsExceeded(this.pool.size, this.config.maxAgents);
+    }
+    const agentId = config.agentId ?? `agent-${randomUUID().slice(0, 8)}`;
+    if (this.pool.has(agentId)) {
+      throw RuntimeError.agentAlreadyExists(agentId);
+    }
+    try {
+      const enrichedConfig = enrichAgentConfig(
+        config.agentConfig,
+        void 0,
+        // No config path
+        false
+        // Not interactive CLI
+      );
+      enrichedConfig.agentId = agentId;
+      const agent = new DextoAgent(enrichedConfig);
+      const sessionId = `session-${randomUUID().slice(0, 8)}`;
+      const handle = {
+        agentId,
+        agent,
+        status: "starting",
+        ephemeral: config.ephemeral ?? true,
+        createdAt: /* @__PURE__ */ new Date(),
+        sessionId
+      };
+      if (config.group !== void 0) {
+        handle.group = config.group;
+      }
+      if (config.metadata !== void 0) {
+        handle.metadata = config.metadata;
+      }
+      this.pool.add(handle);
+      if (config.onBeforeStart) {
+        await config.onBeforeStart(agent);
+      }
+      await agent.start();
+      this.pool.updateStatus(agentId, "idle");
+      this.logger.info(
+        `Spawned agent '${agentId}'${handle.group ? ` (group: ${handle.group})` : ""} (ephemeral: ${handle.ephemeral})`
+      );
+      return handle;
+    } catch (error) {
+      this.pool.remove(agentId);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw RuntimeError.spawnFailed(errorMessage, agentId);
+    }
+  }
+  /**
+   * Execute a task on an agent
+   *
+   * @param agentId - ID of the agent
+   * @param task - Task description to execute
+   * @param timeout - Optional timeout in milliseconds
+   * @returns Task result with response or error
+   */
+  async executeTask(agentId, task, timeout) {
+    const handle = this.pool.get(agentId);
+    if (!handle) {
+      throw RuntimeError.agentNotFound(agentId);
+    }
+    if (handle.status === "stopped" || handle.status === "error") {
+      throw RuntimeError.agentAlreadyStopped(agentId);
+    }
+    const taskTimeout = timeout ?? this.config.defaultTaskTimeout;
+    this.pool.updateStatus(agentId, "running");
+    try {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(RuntimeError.taskTimeout(agentId, taskTimeout));
+        }, taskTimeout);
+      });
+      const generatePromise = handle.agent.generate(task, handle.sessionId);
+      const response = await Promise.race([
+        generatePromise,
+        timeoutPromise
+      ]);
+      this.pool.updateStatus(agentId, "idle");
+      const result = {
+        success: true,
+        response: response.content,
+        agentId,
+        tokenUsage: {
+          input: response.usage.inputTokens,
+          output: response.usage.outputTokens,
+          total: response.usage.totalTokens
+        }
+      };
+      this.logger.debug(`Task completed for agent '${agentId}'`);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.pool.updateStatus(agentId, "error", errorMessage);
+      if (error instanceof Error && error.message.includes("Task execution timed out")) {
+        return {
+          success: false,
+          error: errorMessage,
+          agentId
+        };
+      }
+      throw RuntimeError.taskFailed(agentId, errorMessage);
+    }
+  }
+  /**
+   * Get an agent handle by ID
+   */
+  getAgent(agentId) {
+    return this.pool.get(agentId);
+  }
+  /**
+   * List agents matching the given filter
+   */
+  listAgents(filter) {
+    return this.pool.list(filter);
+  }
+  /**
+   * Stop a specific agent
+   */
+  async stopAgent(agentId) {
+    const handle = this.pool.get(agentId);
+    if (!handle) {
+      throw RuntimeError.agentNotFound(agentId);
+    }
+    if (handle.status === "stopped") {
+      this.logger.debug(`Agent '${agentId}' already stopped`);
+      return;
+    }
+    this.pool.updateStatus(agentId, "stopping");
+    try {
+      handle.agent.services.approvalManager.cancelAllApprovals();
+      await handle.agent.stop();
+      this.pool.updateStatus(agentId, "stopped");
+      this.logger.debug(`Stopped agent '${agentId}'`);
+      if (handle.ephemeral) {
+        this.pool.remove(agentId);
+        this.logger.debug(`Removed ephemeral agent '${agentId}' from pool`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.pool.updateStatus(agentId, "error", errorMessage);
+      this.logger.error(`Failed to stop agent '${agentId}': ${errorMessage}`);
+    }
+  }
+  /**
+   * Stop all agents matching the given filter
+   */
+  async stopAll(filter) {
+    const agents = this.pool.list(filter);
+    this.logger.debug(`Stopping ${agents.length} agents`);
+    await Promise.allSettled(agents.map((handle) => this.stopAgent(handle.agentId)));
+  }
+  /**
+   * Get the runtime configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get statistics about the runtime
+   */
+  getStats() {
+    const agents = this.pool.getAll();
+    const byStatus = {};
+    for (const agent of agents) {
+      byStatus[agent.status] = (byStatus[agent.status] ?? 0) + 1;
+    }
+    return {
+      totalAgents: agents.length,
+      byStatus
+    };
+  }
+}
+export {
+  AgentRuntime
+};

package/dist/runtime/approval-delegation.cjs

@@ -0,0 +1,97 @@
+"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);
+var approval_delegation_exports = {};
+__export(approval_delegation_exports, {
+  createDelegatingApprovalHandler: () => createDelegatingApprovalHandler
+});
+module.exports = __toCommonJS(approval_delegation_exports);
+function createDelegatingApprovalHandler(parentApprovalManager, subAgentId, logger) {
+  const pendingApprovalIds = /* @__PURE__ */ new Set();
+  const handler = Object.assign(
+    async (request) => {
+      logger.debug(
+        `Delegating approval '${request.approvalId}' (type: ${request.type}) from sub-agent '${subAgentId}'`
+      );
+      pendingApprovalIds.add(request.approvalId);
+      try {
+        const delegatedDetails = {
+          type: request.type,
+          timeout: request.timeout,
+          sessionId: request.sessionId,
+          metadata: {
+            ...request.metadata,
+            delegatedFromAgent: subAgentId
+          }
+        };
+        const response = await parentApprovalManager.requestApproval(delegatedDetails);
+        logger.debug(
+          `Approval '${request.approvalId}' delegated response: ${response.status}`
+        );
+        return response;
+      } finally {
+        pendingApprovalIds.delete(request.approvalId);
+      }
+    },
+    {
+      /**
+       * Cancel a specific pending approval request
+       */
+      cancel: (approvalId) => {
+        if (pendingApprovalIds.has(approvalId)) {
+          logger.debug(
+            `Cancelling delegated approval '${approvalId}' for sub-agent '${subAgentId}'`
+          );
+          parentApprovalManager.cancelApproval(approvalId);
+          pendingApprovalIds.delete(approvalId);
+        }
+      },
+      /**
+       * Cancel all pending approval requests for this sub-agent
+       */
+      cancelAll: () => {
+        if (pendingApprovalIds.size > 0) {
+          logger.debug(
+            `Cancelling all ${pendingApprovalIds.size} delegated approvals for sub-agent '${subAgentId}'`
+          );
+          for (const approvalId of pendingApprovalIds) {
+            parentApprovalManager.cancelApproval(approvalId);
+          }
+          pendingApprovalIds.clear();
+        }
+      },
+      /**
+       * Get list of pending approval IDs for this sub-agent
+       */
+      getPending: () => {
+        return Array.from(pendingApprovalIds);
+      },
+      /**
+       * Get pending approval requests (not available for delegated handlers)
+       */
+      getPendingRequests: () => {
+        return [];
+      }
+    }
+  );
+  return handler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDelegatingApprovalHandler
+});

package/dist/runtime/approval-delegation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Approval Delegation for Sub-Agents
+ *
+ * Creates ApprovalHandler instances that delegate approval requests
+ * from sub-agents to the parent agent's approval system.
+ */
+import type { ApprovalHandler, ApprovalManager, IDextoLogger } from '@dexto/core';
+/**
+ * Creates an ApprovalHandler that delegates requests to a parent's ApprovalManager.
+ *
+ * This allows sub-agent tool approvals to flow through the parent's approval system,
+ * ensuring the user sees a unified approval UI regardless of which agent made the request.
+ *
+ * @param parentApprovalManager - The parent agent's ApprovalManager
+ * @param subAgentId - ID of the sub-agent for tracking
+ * @param logger - Logger for debugging
+ * @returns An ApprovalHandler that can be set on the sub-agent's ApprovalManager
+ *
+ * @example
+ * ```typescript
+ * const delegatingHandler = createDelegatingApprovalHandler(
+ *   parentAgent.services.approvalManager,
+ *   subAgentId,
+ *   logger
+ * );
+ * subAgent.services.approvalManager.setHandler(delegatingHandler);
+ * ```
+ */
+export declare function createDelegatingApprovalHandler(parentApprovalManager: ApprovalManager, subAgentId: string, logger: IDextoLogger): ApprovalHandler;
+//# sourceMappingURL=approval-delegation.d.ts.map

package/dist/runtime/approval-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-delegation.d.ts","sourceRoot":"","sources":["../../src/runtime/approval-delegation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,eAAe,EAIf,eAAe,EACf,YAAY,EACf,MAAM,aAAa,CAAC;AAYrB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,+BAA+B,CAC3C,qBAAqB,EAAE,eAAe,EACtC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,YAAY,GACrB,eAAe,CAqFjB"}