@dexto/agent-management 1.5.2 → 1.5.4

package/dist/preferences/schemas.d.ts

@@ -53,6 +53,19 @@ export declare const PreferenceSetupSchema: z.ZodObject<{
     apiKeyPending?: boolean | undefined;
     baseURLPending?: boolean | undefined;
 }>;
+export declare const PreferenceSoundsSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    onApprovalRequired: z.ZodDefault<z.ZodBoolean>;
+    onTaskComplete: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    enabled: boolean;
+    onApprovalRequired: boolean;
+    onTaskComplete: boolean;
+}, {
+    enabled?: boolean | undefined;
+    onApprovalRequired?: boolean | undefined;
+    onTaskComplete?: boolean | undefined;
+}>;
 export declare const GlobalPreferencesSchema: z.ZodObject<{
     llm: z.ZodEffects<z.ZodObject<{
         provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere", "openrouter", "litellm", "glama", "vertex", "bedrock", "local", "ollama"]>;
@@ -108,6 +121,19 @@ export declare const GlobalPreferencesSchema: z.ZodObject<{
         apiKeyPending?: boolean | undefined;
         baseURLPending?: boolean | undefined;
     }>>;
+    sounds: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        onApprovalRequired: z.ZodDefault<z.ZodBoolean>;
+        onTaskComplete: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        enabled: boolean;
+        onApprovalRequired: boolean;
+        onTaskComplete: boolean;
+    }, {
+        enabled?: boolean | undefined;
+        onApprovalRequired?: boolean | undefined;
+        onTaskComplete?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     llm: {
         provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
@@ -125,6 +151,11 @@ export declare const GlobalPreferencesSchema: z.ZodObject<{
         apiKeyPending: boolean;
         baseURLPending: boolean;
     };
+    sounds: {
+        enabled: boolean;
+        onApprovalRequired: boolean;
+        onTaskComplete: boolean;
+    };
 }, {
     llm: {
         provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | "openrouter" | "litellm" | "glama" | "vertex" | "bedrock" | "local" | "ollama";
@@ -142,9 +173,15 @@ export declare const GlobalPreferencesSchema: z.ZodObject<{
         apiKeyPending?: boolean | undefined;
         baseURLPending?: boolean | undefined;
     } | undefined;
+    sounds?: {
+        enabled?: boolean | undefined;
+        onApprovalRequired?: boolean | undefined;
+        onTaskComplete?: boolean | undefined;
+    } | undefined;
 }>;
 export type PreferenceLLM = z.output<typeof PreferenceLLMSchema>;
 export type PreferenceDefaults = z.output<typeof PreferenceDefaultsSchema>;
 export type PreferenceSetup = z.output<typeof PreferenceSetupSchema>;
+export type PreferenceSounds = z.output<typeof PreferenceSoundsSchema>;
 export type GlobalPreferences = z.output<typeof GlobalPreferencesSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/preferences/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/preferences/schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsE1B,CAAC;AAEP,eAAO,MAAM,wBAAwB;;;;;;;;;EAYxB,CAAC;AAEd,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAYrB,CAAC;AAEd,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUvB,CAAC;AAGd,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/preferences/schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsE1B,CAAC;AAEP,eAAO,MAAM,wBAAwB;;;;;;;;;EAYxB,CAAC;AAEd,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAYrB,CAAC;AAEd,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EActB,CAAC;AAEd,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC;AAGd,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/preferences/schemas.js

@@ -60,16 +60,27 @@ const PreferenceSetupSchema = z.object({
   apiKeyPending: z.boolean().default(false).describe("Whether API key setup was skipped and needs to be configured later"),
   baseURLPending: z.boolean().default(false).describe("Whether baseURL setup was skipped and needs to be configured later")
 }).strict();
+const PreferenceSoundsSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable sound notifications (default: true)"),
+  onApprovalRequired: z.boolean().default(true).describe(
+    "Play sound when tool approval is required (default: true when sounds enabled)"
+  ),
+  onTaskComplete: z.boolean().default(true).describe("Play sound when agent task completes (default: true when sounds enabled)")
+}).strict();
 const GlobalPreferencesSchema = z.object({
   llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
   defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
   setup: PreferenceSetupSchema.default({ completed: false }).describe(
     "Setup completion tracking"
+  ),
+  sounds: PreferenceSoundsSchema.default({}).describe(
+    "Sound notification preferences (defaults applied for legacy preferences)"
   )
 }).strict();
 export {
   GlobalPreferencesSchema,
   PreferenceDefaultsSchema,
   PreferenceLLMSchema,
-  PreferenceSetupSchema
+  PreferenceSetupSchema,
+  PreferenceSoundsSchema
 };

package/dist/runtime/AgentPool.cjs

@@ -0,0 +1,181 @@
+"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 AgentPool_exports = {};
+__export(AgentPool_exports, {
+  AgentPool: () => AgentPool
+});
+module.exports = __toCommonJS(AgentPool_exports);
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+class AgentPool {
+  agents = /* @__PURE__ */ new Map();
+  config;
+  logger;
+  constructor(config, logger) {
+    this.config = {
+      maxAgents: config.maxAgents ?? import_schemas.DEFAULT_MAX_AGENTS,
+      defaultTaskTimeout: config.defaultTaskTimeout ?? import_schemas.DEFAULT_TASK_TIMEOUT
+    };
+    this.logger = logger;
+  }
+  /**
+   * Add an agent handle to the pool
+   * @throws RuntimeError if agent with same ID already exists or limit exceeded
+   */
+  add(handle) {
+    if (this.agents.has(handle.agentId)) {
+      throw import_errors.RuntimeError.agentAlreadyExists(handle.agentId);
+    }
+    if (this.agents.size >= this.config.maxAgents) {
+      throw import_errors.RuntimeError.maxAgentsExceeded(this.agents.size, this.config.maxAgents);
+    }
+    this.agents.set(handle.agentId, handle);
+    this.logger.debug(
+      `Added agent '${handle.agentId}' to pool${handle.group ? ` (group: ${handle.group})` : ""}`
+    );
+  }
+  /**
+   * Remove an agent from the pool
+   * @returns The removed handle, or undefined if not found
+   */
+  remove(agentId) {
+    const handle = this.agents.get(agentId);
+    if (handle) {
+      this.agents.delete(agentId);
+      this.logger.debug(`Removed agent '${agentId}' from pool`);
+    }
+    return handle;
+  }
+  /**
+   * Get an agent handle by ID
+   */
+  get(agentId) {
+    return this.agents.get(agentId);
+  }
+  /**
+   * Check if another agent can be spawned
+   */
+  canSpawn() {
+    return this.agents.size < this.config.maxAgents;
+  }
+  /**
+   * List agents matching the given filter
+   */
+  list(filter) {
+    if (!filter) {
+      return Array.from(this.agents.values());
+    }
+    const results = [];
+    for (const handle of this.agents.values()) {
+      if (this.matchesFilter(handle, filter)) {
+        results.push(handle);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get all agents in a specific group
+   */
+  getByGroup(group) {
+    return this.list({ group });
+  }
+  /**
+   * Get the count of agents in a specific group
+   */
+  getGroupCount(group) {
+    return this.getByGroup(group).length;
+  }
+  /**
+   * Update the status of an agent
+   * @throws RuntimeError if agent not found
+   */
+  updateStatus(agentId, status, error) {
+    const handle = this.agents.get(agentId);
+    if (!handle) {
+      throw import_errors.RuntimeError.agentNotFound(agentId);
+    }
+    const previousStatus = handle.status;
+    handle.status = status;
+    if (status !== "error") {
+      delete handle.error;
+    } else if (error !== void 0) {
+      handle.error = error;
+    }
+    this.logger.debug(
+      `Agent '${agentId}' status changed: ${previousStatus} -> ${status}${error ? ` (error: ${error})` : ""}`
+    );
+  }
+  /**
+   * Check if an agent exists in the pool
+   */
+  has(agentId) {
+    return this.agents.has(agentId);
+  }
+  /**
+   * Get all agent handles in the pool
+   */
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get the total count of agents in the pool
+   */
+  get size() {
+    return this.agents.size;
+  }
+  /**
+   * Get the configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Clear all agents from the pool
+   * Note: This does NOT stop the agents - use AgentRuntime.stopAll instead
+   */
+  clear() {
+    const count = this.agents.size;
+    this.agents.clear();
+    if (count > 0) {
+      this.logger.debug(`Cleared ${count} agents from pool`);
+    }
+  }
+  /**
+   * Check if an agent handle matches a filter
+   */
+  matchesFilter(handle, filter) {
+    if (filter.group !== void 0 && handle.group !== filter.group) {
+      return false;
+    }
+    if (filter.status !== void 0) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      if (!statuses.includes(handle.status)) {
+        return false;
+      }
+    }
+    if (filter.ephemeral !== void 0 && handle.ephemeral !== filter.ephemeral) {
+      return false;
+    }
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentPool
+});

package/dist/runtime/AgentPool.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AgentPool - Manages a pool of agent instances
+ *
+ * Tracks active agents, enforces resource limits, and provides
+ * lookup and lifecycle management capabilities.
+ */
+import type { IDextoLogger } from '@dexto/core';
+import type { AgentHandle, AgentStatus, AgentFilter } from './types.js';
+import { type ValidatedAgentRuntimeConfig } from './schemas.js';
+export declare class AgentPool {
+    private agents;
+    private config;
+    private logger;
+    constructor(config: Partial<ValidatedAgentRuntimeConfig>, logger: IDextoLogger);
+    /**
+     * Add an agent handle to the pool
+     * @throws RuntimeError if agent with same ID already exists or limit exceeded
+     */
+    add(handle: AgentHandle): void;
+    /**
+     * Remove an agent from the pool
+     * @returns The removed handle, or undefined if not found
+     */
+    remove(agentId: string): AgentHandle | undefined;
+    /**
+     * Get an agent handle by ID
+     */
+    get(agentId: string): AgentHandle | undefined;
+    /**
+     * Check if another agent can be spawned
+     */
+    canSpawn(): boolean;
+    /**
+     * List agents matching the given filter
+     */
+    list(filter?: AgentFilter): AgentHandle[];
+    /**
+     * Get all agents in a specific group
+     */
+    getByGroup(group: string): AgentHandle[];
+    /**
+     * Get the count of agents in a specific group
+     */
+    getGroupCount(group: string): number;
+    /**
+     * Update the status of an agent
+     * @throws RuntimeError if agent not found
+     */
+    updateStatus(agentId: string, status: AgentStatus, error?: string): void;
+    /**
+     * Check if an agent exists in the pool
+     */
+    has(agentId: string): boolean;
+    /**
+     * Get all agent handles in the pool
+     */
+    getAll(): AgentHandle[];
+    /**
+     * Get the total count of agents in the pool
+     */
+    get size(): number;
+    /**
+     * Get the configuration
+     */
+    getConfig(): ValidatedAgentRuntimeConfig;
+    /**
+     * Clear all agents from the pool
+     * Note: This does NOT stop the agents - use AgentRuntime.stopAll instead
+     */
+    clear(): void;
+    /**
+     * Check if an agent handle matches a filter
+     */
+    private matchesFilter;
+}
+//# sourceMappingURL=AgentPool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AgentPool.d.ts","sourceRoot":"","sources":["../../src/runtime/AgentPool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAGH,KAAK,2BAA2B,EACnC,MAAM,cAAc,CAAC;AAGtB,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,EAAE,OAAO,CAAC,2BAA2B,CAAC,EAAE,MAAM,EAAE,YAAY;IAQ9E;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAe9B;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAShD;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI7C;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE;IAczC;;OAEG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE;IAIxC;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIpC;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAmBxE;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI7B;;OAEG;IACH,MAAM,IAAI,WAAW,EAAE;IAIvB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,SAAS,IAAI,2BAA2B;IAIxC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;IACH,OAAO,CAAC,aAAa;CAqBxB"}

package/dist/runtime/AgentPool.js

@@ -0,0 +1,160 @@
+import {
+  DEFAULT_MAX_AGENTS,
+  DEFAULT_TASK_TIMEOUT
+} from "./schemas.js";
+import { RuntimeError } from "./errors.js";
+class AgentPool {
+  agents = /* @__PURE__ */ new Map();
+  config;
+  logger;
+  constructor(config, logger) {
+    this.config = {
+      maxAgents: config.maxAgents ?? DEFAULT_MAX_AGENTS,
+      defaultTaskTimeout: config.defaultTaskTimeout ?? DEFAULT_TASK_TIMEOUT
+    };
+    this.logger = logger;
+  }
+  /**
+   * Add an agent handle to the pool
+   * @throws RuntimeError if agent with same ID already exists or limit exceeded
+   */
+  add(handle) {
+    if (this.agents.has(handle.agentId)) {
+      throw RuntimeError.agentAlreadyExists(handle.agentId);
+    }
+    if (this.agents.size >= this.config.maxAgents) {
+      throw RuntimeError.maxAgentsExceeded(this.agents.size, this.config.maxAgents);
+    }
+    this.agents.set(handle.agentId, handle);
+    this.logger.debug(
+      `Added agent '${handle.agentId}' to pool${handle.group ? ` (group: ${handle.group})` : ""}`
+    );
+  }
+  /**
+   * Remove an agent from the pool
+   * @returns The removed handle, or undefined if not found
+   */
+  remove(agentId) {
+    const handle = this.agents.get(agentId);
+    if (handle) {
+      this.agents.delete(agentId);
+      this.logger.debug(`Removed agent '${agentId}' from pool`);
+    }
+    return handle;
+  }
+  /**
+   * Get an agent handle by ID
+   */
+  get(agentId) {
+    return this.agents.get(agentId);
+  }
+  /**
+   * Check if another agent can be spawned
+   */
+  canSpawn() {
+    return this.agents.size < this.config.maxAgents;
+  }
+  /**
+   * List agents matching the given filter
+   */
+  list(filter) {
+    if (!filter) {
+      return Array.from(this.agents.values());
+    }
+    const results = [];
+    for (const handle of this.agents.values()) {
+      if (this.matchesFilter(handle, filter)) {
+        results.push(handle);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get all agents in a specific group
+   */
+  getByGroup(group) {
+    return this.list({ group });
+  }
+  /**
+   * Get the count of agents in a specific group
+   */
+  getGroupCount(group) {
+    return this.getByGroup(group).length;
+  }
+  /**
+   * Update the status of an agent
+   * @throws RuntimeError if agent not found
+   */
+  updateStatus(agentId, status, error) {
+    const handle = this.agents.get(agentId);
+    if (!handle) {
+      throw RuntimeError.agentNotFound(agentId);
+    }
+    const previousStatus = handle.status;
+    handle.status = status;
+    if (status !== "error") {
+      delete handle.error;
+    } else if (error !== void 0) {
+      handle.error = error;
+    }
+    this.logger.debug(
+      `Agent '${agentId}' status changed: ${previousStatus} -> ${status}${error ? ` (error: ${error})` : ""}`
+    );
+  }
+  /**
+   * Check if an agent exists in the pool
+   */
+  has(agentId) {
+    return this.agents.has(agentId);
+  }
+  /**
+   * Get all agent handles in the pool
+   */
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get the total count of agents in the pool
+   */
+  get size() {
+    return this.agents.size;
+  }
+  /**
+   * Get the configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Clear all agents from the pool
+   * Note: This does NOT stop the agents - use AgentRuntime.stopAll instead
+   */
+  clear() {
+    const count = this.agents.size;
+    this.agents.clear();
+    if (count > 0) {
+      this.logger.debug(`Cleared ${count} agents from pool`);
+    }
+  }
+  /**
+   * Check if an agent handle matches a filter
+   */
+  matchesFilter(handle, filter) {
+    if (filter.group !== void 0 && handle.group !== filter.group) {
+      return false;
+    }
+    if (filter.status !== void 0) {
+      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+      if (!statuses.includes(handle.status)) {
+        return false;
+      }
+    }
+    if (filter.ephemeral !== void 0 && handle.ephemeral !== filter.ephemeral) {
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  AgentPool
+};