@dexto/agent-management 1.5.1 → 1.5.3

package/dist/runtime/approval-delegation.js

@@ -0,0 +1,73 @@
+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;
+}
+export {
+  createDelegatingApprovalHandler
+};

package/dist/runtime/error-codes.cjs

@@ -0,0 +1,40 @@
+"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 error_codes_exports = {};
+__export(error_codes_exports, {
+  RuntimeErrorCode: () => RuntimeErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var RuntimeErrorCode = /* @__PURE__ */ ((RuntimeErrorCode2) => {
+  RuntimeErrorCode2["MAX_AGENTS_EXCEEDED"] = "runtime_max_agents_exceeded";
+  RuntimeErrorCode2["AGENT_NOT_FOUND"] = "runtime_agent_not_found";
+  RuntimeErrorCode2["AGENT_ALREADY_EXISTS"] = "runtime_agent_already_exists";
+  RuntimeErrorCode2["AGENT_NOT_STARTED"] = "runtime_agent_not_started";
+  RuntimeErrorCode2["AGENT_ALREADY_STOPPED"] = "runtime_agent_already_stopped";
+  RuntimeErrorCode2["SPAWN_FAILED"] = "runtime_spawn_failed";
+  RuntimeErrorCode2["INVALID_CONFIG"] = "runtime_invalid_config";
+  RuntimeErrorCode2["TASK_TIMEOUT"] = "runtime_task_timeout";
+  RuntimeErrorCode2["TASK_FAILED"] = "runtime_task_failed";
+  RuntimeErrorCode2["TASK_CANCELLED"] = "runtime_task_cancelled";
+  return RuntimeErrorCode2;
+})(RuntimeErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeErrorCode
+});

package/dist/runtime/error-codes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runtime-specific error codes
+ * Includes errors for agent spawning, lifecycle management, and task execution
+ */
+export declare enum RuntimeErrorCode {
+    MAX_AGENTS_EXCEEDED = "runtime_max_agents_exceeded",
+    AGENT_NOT_FOUND = "runtime_agent_not_found",
+    AGENT_ALREADY_EXISTS = "runtime_agent_already_exists",
+    AGENT_NOT_STARTED = "runtime_agent_not_started",
+    AGENT_ALREADY_STOPPED = "runtime_agent_already_stopped",
+    SPAWN_FAILED = "runtime_spawn_failed",
+    INVALID_CONFIG = "runtime_invalid_config",
+    TASK_TIMEOUT = "runtime_task_timeout",
+    TASK_FAILED = "runtime_task_failed",
+    TASK_CANCELLED = "runtime_task_cancelled"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/runtime/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/runtime/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAExB,mBAAmB,gCAAgC;IAGnD,eAAe,4BAA4B;IAC3C,oBAAoB,iCAAiC;IACrD,iBAAiB,8BAA8B;IAC/C,qBAAqB,kCAAkC;IAGvD,YAAY,yBAAyB;IACrC,cAAc,2BAA2B;IAGzC,YAAY,yBAAyB;IACrC,WAAW,wBAAwB;IACnC,cAAc,2BAA2B;CAC5C"}

package/dist/runtime/error-codes.js

@@ -0,0 +1,16 @@
+var RuntimeErrorCode = /* @__PURE__ */ ((RuntimeErrorCode2) => {
+  RuntimeErrorCode2["MAX_AGENTS_EXCEEDED"] = "runtime_max_agents_exceeded";
+  RuntimeErrorCode2["AGENT_NOT_FOUND"] = "runtime_agent_not_found";
+  RuntimeErrorCode2["AGENT_ALREADY_EXISTS"] = "runtime_agent_already_exists";
+  RuntimeErrorCode2["AGENT_NOT_STARTED"] = "runtime_agent_not_started";
+  RuntimeErrorCode2["AGENT_ALREADY_STOPPED"] = "runtime_agent_already_stopped";
+  RuntimeErrorCode2["SPAWN_FAILED"] = "runtime_spawn_failed";
+  RuntimeErrorCode2["INVALID_CONFIG"] = "runtime_invalid_config";
+  RuntimeErrorCode2["TASK_TIMEOUT"] = "runtime_task_timeout";
+  RuntimeErrorCode2["TASK_FAILED"] = "runtime_task_failed";
+  RuntimeErrorCode2["TASK_CANCELLED"] = "runtime_task_cancelled";
+  return RuntimeErrorCode2;
+})(RuntimeErrorCode || {});
+export {
+  RuntimeErrorCode
+};

package/dist/runtime/errors.cjs

@@ -0,0 +1,135 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  RuntimeError: () => RuntimeError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_core = require("@dexto/core");
+var import_error_codes = require("./error-codes.js");
+class RuntimeError {
+  // Limit errors
+  static maxAgentsExceeded(currentCount, maxAllowed) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.MAX_AGENTS_EXCEEDED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Maximum agents limit exceeded. Current: ${currentCount}, Max: ${maxAllowed}`,
+      { currentCount, maxAllowed },
+      "Stop some existing agents before spawning new ones"
+    );
+  }
+  // Agent lifecycle errors
+  static agentNotFound(agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.AGENT_NOT_FOUND,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.NOT_FOUND,
+      `Agent '${agentId}' not found`,
+      { agentId },
+      "Ensure the agent ID is correct and the agent has been spawned"
+    );
+  }
+  static agentAlreadyExists(agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.AGENT_ALREADY_EXISTS,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Agent with ID '${agentId}' already exists`,
+      { agentId },
+      "Use a different agent ID or stop the existing agent first"
+    );
+  }
+  static agentNotStarted(agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.AGENT_NOT_STARTED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Agent '${agentId}' has not been started`,
+      { agentId },
+      "Start the agent before executing tasks"
+    );
+  }
+  static agentAlreadyStopped(agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.AGENT_ALREADY_STOPPED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Agent '${agentId}' has already been stopped`,
+      { agentId },
+      "Spawn a new agent if you need to continue"
+    );
+  }
+  // Spawn errors
+  static spawnFailed(cause, agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.SPAWN_FAILED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.SYSTEM,
+      agentId ? `Failed to spawn agent '${agentId}': ${cause}` : `Failed to spawn agent: ${cause}`,
+      { agentId, cause },
+      "Check the agent configuration and try again"
+    );
+  }
+  static invalidConfig(message, details) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.INVALID_CONFIG,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Invalid agent configuration: ${message}`,
+      details ?? {},
+      "Check the configuration and ensure all required fields are provided"
+    );
+  }
+  // Task execution errors
+  static taskTimeout(agentId, timeoutMs) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.TASK_TIMEOUT,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.TIMEOUT,
+      `Task execution timed out for agent '${agentId}' after ${timeoutMs}ms`,
+      { agentId, timeoutMs },
+      "Increase the timeout or simplify the task"
+    );
+  }
+  static taskFailed(agentId, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.TASK_FAILED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.SYSTEM,
+      `Task execution failed for agent '${agentId}': ${cause}`,
+      { agentId, cause },
+      "Check the task requirements and agent configuration"
+    );
+  }
+  static taskCancelled(agentId) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.RuntimeErrorCode.TASK_CANCELLED,
+      import_core.ErrorScope.AGENT,
+      import_core.ErrorType.USER,
+      `Task execution was cancelled for agent '${agentId}'`,
+      { agentId },
+      "The task was cancelled by user or system request"
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeError
+});

package/dist/runtime/errors.d.ts

@@ -0,0 +1,40 @@
+import { DextoRuntimeError } from '@dexto/core';
+/**
+ * Runtime error factory methods
+ * Creates properly typed errors for agent runtime operations
+ */
+export declare class RuntimeError {
+    static maxAgentsExceeded(currentCount: number, maxAllowed: number): DextoRuntimeError<{
+        currentCount: number;
+        maxAllowed: number;
+    }>;
+    static agentNotFound(agentId: string): DextoRuntimeError<{
+        agentId: string;
+    }>;
+    static agentAlreadyExists(agentId: string): DextoRuntimeError<{
+        agentId: string;
+    }>;
+    static agentNotStarted(agentId: string): DextoRuntimeError<{
+        agentId: string;
+    }>;
+    static agentAlreadyStopped(agentId: string): DextoRuntimeError<{
+        agentId: string;
+    }>;
+    static spawnFailed(cause: string, agentId?: string): DextoRuntimeError<{
+        agentId: string | undefined;
+        cause: string;
+    }>;
+    static invalidConfig(message: string, details?: Record<string, unknown>): DextoRuntimeError<Record<string, unknown>>;
+    static taskTimeout(agentId: string, timeoutMs: number): DextoRuntimeError<{
+        agentId: string;
+        timeoutMs: number;
+    }>;
+    static taskFailed(agentId: string, cause: string): DextoRuntimeError<{
+        agentId: string;
+        cause: string;
+    }>;
+    static taskCancelled(agentId: string): DextoRuntimeError<{
+        agentId: string;
+    }>;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAyB,MAAM,aAAa,CAAC;AAGvE;;;GAGG;AACH,qBAAa,YAAY;IAErB,MAAM,CAAC,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;;;;IAYjE,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM;;;IAWpC,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM;;;IAWzC,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM;;;IAWtC,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM;;;IAY1C,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;;;;IAalD,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAYvE,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;IAWrD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAWhD,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM;;;CAUvC"}

package/dist/runtime/errors.js

@@ -0,0 +1,111 @@
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
+import { RuntimeErrorCode } from "./error-codes.js";
+class RuntimeError {
+  // Limit errors
+  static maxAgentsExceeded(currentCount, maxAllowed) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.MAX_AGENTS_EXCEEDED,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Maximum agents limit exceeded. Current: ${currentCount}, Max: ${maxAllowed}`,
+      { currentCount, maxAllowed },
+      "Stop some existing agents before spawning new ones"
+    );
+  }
+  // Agent lifecycle errors
+  static agentNotFound(agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.AGENT_NOT_FOUND,
+      ErrorScope.AGENT,
+      ErrorType.NOT_FOUND,
+      `Agent '${agentId}' not found`,
+      { agentId },
+      "Ensure the agent ID is correct and the agent has been spawned"
+    );
+  }
+  static agentAlreadyExists(agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.AGENT_ALREADY_EXISTS,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Agent with ID '${agentId}' already exists`,
+      { agentId },
+      "Use a different agent ID or stop the existing agent first"
+    );
+  }
+  static agentNotStarted(agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.AGENT_NOT_STARTED,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Agent '${agentId}' has not been started`,
+      { agentId },
+      "Start the agent before executing tasks"
+    );
+  }
+  static agentAlreadyStopped(agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.AGENT_ALREADY_STOPPED,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Agent '${agentId}' has already been stopped`,
+      { agentId },
+      "Spawn a new agent if you need to continue"
+    );
+  }
+  // Spawn errors
+  static spawnFailed(cause, agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.SPAWN_FAILED,
+      ErrorScope.AGENT,
+      ErrorType.SYSTEM,
+      agentId ? `Failed to spawn agent '${agentId}': ${cause}` : `Failed to spawn agent: ${cause}`,
+      { agentId, cause },
+      "Check the agent configuration and try again"
+    );
+  }
+  static invalidConfig(message, details) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.INVALID_CONFIG,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Invalid agent configuration: ${message}`,
+      details ?? {},
+      "Check the configuration and ensure all required fields are provided"
+    );
+  }
+  // Task execution errors
+  static taskTimeout(agentId, timeoutMs) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.TASK_TIMEOUT,
+      ErrorScope.AGENT,
+      ErrorType.TIMEOUT,
+      `Task execution timed out for agent '${agentId}' after ${timeoutMs}ms`,
+      { agentId, timeoutMs },
+      "Increase the timeout or simplify the task"
+    );
+  }
+  static taskFailed(agentId, cause) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.TASK_FAILED,
+      ErrorScope.AGENT,
+      ErrorType.SYSTEM,
+      `Task execution failed for agent '${agentId}': ${cause}`,
+      { agentId, cause },
+      "Check the task requirements and agent configuration"
+    );
+  }
+  static taskCancelled(agentId) {
+    return new DextoRuntimeError(
+      RuntimeErrorCode.TASK_CANCELLED,
+      ErrorScope.AGENT,
+      ErrorType.USER,
+      `Task execution was cancelled for agent '${agentId}'`,
+      { agentId },
+      "The task was cancelled by user or system request"
+    );
+  }
+}
+export {
+  RuntimeError
+};

package/dist/runtime/index.cjs

@@ -0,0 +1,53 @@
+"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 runtime_exports = {};
+__export(runtime_exports, {
+  AgentFilterSchema: () => import_schemas.AgentFilterSchema,
+  AgentPool: () => import_AgentPool.AgentPool,
+  AgentRuntime: () => import_AgentRuntime.AgentRuntime,
+  AgentRuntimeConfigSchema: () => import_schemas.AgentRuntimeConfigSchema,
+  AgentStatusSchema: () => import_schemas.AgentStatusSchema,
+  DEFAULT_MAX_AGENTS: () => import_schemas.DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT: () => import_schemas.DEFAULT_TASK_TIMEOUT,
+  RuntimeError: () => import_errors.RuntimeError,
+  RuntimeErrorCode: () => import_error_codes.RuntimeErrorCode,
+  SpawnConfigSchema: () => import_schemas.SpawnConfigSchema,
+  createDelegatingApprovalHandler: () => import_approval_delegation.createDelegatingApprovalHandler
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_AgentRuntime = require("./AgentRuntime.js");
+var import_AgentPool = require("./AgentPool.js");
+var import_approval_delegation = require("./approval-delegation.js");
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+var import_error_codes = require("./error-codes.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentFilterSchema,
+  AgentPool,
+  AgentRuntime,
+  AgentRuntimeConfigSchema,
+  AgentStatusSchema,
+  DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT,
+  RuntimeError,
+  RuntimeErrorCode,
+  SpawnConfigSchema,
+  createDelegatingApprovalHandler
+});

package/dist/runtime/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Agent Runtime Module
+ *
+ * Provides infrastructure for spawning and managing agents.
+ * General-purpose runtime that can be used for:
+ * - Dashboard managing multiple independent agents
+ * - Agent task delegation (parent spawns sub-agents)
+ * - Test harnesses managing multiple agents
+ */
+export { AgentRuntime } from './AgentRuntime.js';
+export type { AgentRuntimeOptions } from './AgentRuntime.js';
+export { AgentPool } from './AgentPool.js';
+export { createDelegatingApprovalHandler } from './approval-delegation.js';
+export type { SpawnConfig, AgentStatus, AgentHandle, TaskResult, AgentRuntimeConfig, AgentFilter, } from './types.js';
+export { AgentRuntimeConfigSchema, SpawnConfigSchema, AgentStatusSchema, AgentFilterSchema, DEFAULT_MAX_AGENTS, DEFAULT_TASK_TIMEOUT, } from './schemas.js';
+export type { ValidatedAgentRuntimeConfig, ValidatedSpawnConfig, ValidatedAgentFilter, } from './schemas.js';
+export { RuntimeError } from './errors.js';
+export { RuntimeErrorCode } from './error-codes.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAG7D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC;AAG3E,YAAY,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,WAAW,GACd,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,wBAAwB,EACxB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACvB,MAAM,cAAc,CAAC;AACtB,YAAY,EACR,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,GACvB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,26 @@
+import { AgentRuntime } from "./AgentRuntime.js";
+import { AgentPool } from "./AgentPool.js";
+import { createDelegatingApprovalHandler } from "./approval-delegation.js";
+import {
+  AgentRuntimeConfigSchema,
+  SpawnConfigSchema,
+  AgentStatusSchema,
+  AgentFilterSchema,
+  DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT
+} from "./schemas.js";
+import { RuntimeError } from "./errors.js";
+import { RuntimeErrorCode } from "./error-codes.js";
+export {
+  AgentFilterSchema,
+  AgentPool,
+  AgentRuntime,
+  AgentRuntimeConfigSchema,
+  AgentStatusSchema,
+  DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT,
+  RuntimeError,
+  RuntimeErrorCode,
+  SpawnConfigSchema,
+  createDelegatingApprovalHandler
+};

package/dist/runtime/schemas.cjs

@@ -0,0 +1,64 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  AgentFilterSchema: () => AgentFilterSchema,
+  AgentRuntimeConfigSchema: () => AgentRuntimeConfigSchema,
+  AgentStatusSchema: () => AgentStatusSchema,
+  DEFAULT_MAX_AGENTS: () => DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT: () => DEFAULT_TASK_TIMEOUT,
+  SpawnConfigSchema: () => SpawnConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const DEFAULT_MAX_AGENTS = 20;
+const DEFAULT_TASK_TIMEOUT = 3e5;
+const AgentRuntimeConfigSchema = import_zod.z.object({
+  maxAgents: import_zod.z.number().int().positive().default(DEFAULT_MAX_AGENTS).describe("Maximum total agents managed by this runtime"),
+  defaultTaskTimeout: import_zod.z.number().int().positive().default(DEFAULT_TASK_TIMEOUT).describe("Default task timeout in milliseconds")
+}).strict().describe("Configuration for the AgentRuntime");
+const SpawnConfigSchema = import_zod.z.object({
+  agentConfig: import_zod.z.record(import_zod.z.unknown()).describe("Base agent configuration"),
+  ephemeral: import_zod.z.boolean().default(true).describe("Whether agent should be destroyed after task completion"),
+  agentId: import_zod.z.string().min(1).optional().describe("Optional custom agent ID (auto-generated if not provided)"),
+  group: import_zod.z.string().min(1).optional().describe("Optional group identifier for logical grouping"),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Optional metadata for tracking relationships or context")
+}).strict().describe("Configuration for spawning an agent");
+const AgentStatusSchema = import_zod.z.enum([
+  "starting",
+  "idle",
+  "running",
+  "stopping",
+  "stopped",
+  "error"
+]);
+const AgentFilterSchema = import_zod.z.object({
+  group: import_zod.z.string().optional().describe("Filter by group"),
+  status: import_zod.z.union([AgentStatusSchema, import_zod.z.array(AgentStatusSchema)]).optional().describe("Filter by status"),
+  ephemeral: import_zod.z.boolean().optional().describe("Filter by ephemeral flag")
+}).strict().describe("Filter options for listing agents");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentFilterSchema,
+  AgentRuntimeConfigSchema,
+  AgentStatusSchema,
+  DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT,
+  SpawnConfigSchema
+});