@teneo-protocol/sdk 1.0.0

package/dist/handlers/message-handler-registry.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Message Handler Registry
+ * Central registry for message handlers - eliminates shotgun surgery when adding new message types
+ */
+import { BaseMessage, MessageType, Logger } from "../types";
+import { MessageHandler, HandlerContext, HandlerRegistrationOptions } from "./message-handlers/types";
+/**
+ * Registry for message handlers
+ * Stores handlers by message type and routes messages to appropriate handlers
+ */
+export declare class MessageHandlerRegistry {
+    private readonly handlers;
+    private readonly logger;
+    constructor(logger: Logger);
+    /**
+     * Registers a message handler for a specific message type.
+     * Prevents duplicate registration unless replace option is true.
+     * Enables extensible message processing following Open/Closed Principle.
+     *
+     * @param handler - The handler to register (must have unique type)
+     * @param options - Registration options
+     * @param options.replace - Whether to replace existing handler (default: false)
+     *
+     * @example
+     * ```typescript
+     * const customHandler = new CustomMessageHandler();
+     * registry.register(customHandler);
+     *
+     * // Replace existing handler
+     * registry.register(newHandler, { replace: true });
+     * ```
+     */
+    register(handler: MessageHandler, options?: HandlerRegistrationOptions): void;
+    /**
+     * Registers multiple message handlers at once.
+     * Convenient for bulk registration of default or custom handlers.
+     * Uses same registration logic as register() for each handler.
+     *
+     * @param handlers - Array of handlers to register
+     * @param options - Registration options applied to all handlers
+     *
+     * @example
+     * ```typescript
+     * const handlers = [
+     *   new TaskResponseHandler(),
+     *   new AgentSelectedHandler(),
+     *   new ErrorHandler()
+     * ];
+     * registry.registerAll(handlers);
+     * ```
+     */
+    registerAll(handlers: MessageHandler[], options?: HandlerRegistrationOptions): void;
+    /**
+     * Unregisters a handler for a specific message type.
+     * Returns whether a handler was actually removed.
+     *
+     * @param type - The message type to unregister
+     * @returns True if handler was removed, false if no handler existed
+     *
+     * @example
+     * ```typescript
+     * const removed = registry.unregister('task_response');
+     * if (removed) {
+     *   console.log('Handler removed successfully');
+     * }
+     * ```
+     */
+    unregister(type: MessageType): boolean;
+    /**
+     * Checks if a handler is registered for a specific message type.
+     * Useful for conditional logic based on handler availability.
+     *
+     * @param type - The message type to check
+     * @returns True if handler exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('task_response')) {
+     *   console.log('Task response handler is registered');
+     * }
+     * ```
+     */
+    has(type: MessageType): boolean;
+    /**
+     * Gets a registered handler for a specific message type.
+     * Returns undefined if no handler is registered for the type.
+     *
+     * @param type - The message type to get handler for
+     * @returns The handler if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const handler = registry.get('task_response');
+     * if (handler) {
+     *   console.log(`Handler found: ${handler.type}`);
+     * }
+     * ```
+     */
+    get(type: MessageType): MessageHandler | undefined;
+    /**
+     * Routes a message to its appropriate handler based on message type.
+     * Validates handler can process the message before delegating.
+     * Catches and logs handler errors, wrapping them in ValidationError.
+     *
+     * @param message - The message to handle
+     * @param context - Handler context with dependencies (logger, emit, etc.)
+     * @returns Promise that resolves when message is handled
+     * @throws {ValidationError} If handler throws an error during processing
+     *
+     * @example
+     * ```typescript
+     * const message = { type: 'task_response', ... };
+     * const context = createHandlerContext();
+     * await registry.handle(message, context);
+     * ```
+     */
+    handle(message: BaseMessage, context: HandlerContext): Promise<void>;
+    /**
+     * Gets an array of all currently registered message types.
+     * Useful for introspection and debugging handler configuration.
+     *
+     * @returns Array of message types that have registered handlers
+     *
+     * @example
+     * ```typescript
+     * const types = registry.getRegisteredTypes();
+     * console.log(`Registered handlers: ${types.join(', ')}`);
+     * ```
+     */
+    getRegisteredTypes(): MessageType[];
+    /**
+     * Gets the total number of registered handlers.
+     * Convenience getter for handler count.
+     *
+     * @returns Number of registered handlers
+     *
+     * @example
+     * ```typescript
+     * console.log(`${registry.size} handlers registered`);
+     * ```
+     */
+    get size(): number;
+    /**
+     * Clears all registered handlers from the registry.
+     * Useful for testing or resetting handler configuration.
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * console.log('All handlers cleared');
+     * ```
+     */
+    clear(): void;
+}
+//# sourceMappingURL=message-handler-registry.d.ts.map

package/dist/handlers/message-handler-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-handler-registry.d.ts","sourceRoot":"","sources":["../../src/handlers/message-handler-registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EACL,cAAc,EACd,cAAc,EACd,0BAA0B,EAC3B,MAAM,0BAA0B,CAAC;AAGlC;;;GAGG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,EAAE,MAAM;IAI1B;;;;;;;;;;;;;;;;;OAiBG;IACI,QAAQ,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,GAAE,0BAA+B,GAAG,IAAI;IAexF;;;;;;;;;;;;;;;;;OAiBG;IACI,WAAW,CAAC,QAAQ,EAAE,cAAc,EAAE,EAAE,OAAO,GAAE,0BAA+B,GAAG,IAAI;IAM9F;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAQ7C;;;;;;;;;;;;;OAaG;IACI,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAItC;;;;;;;;;;;;;;OAcG;IACI,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS;IAIzD;;;;;;;;;;;;;;;;OAgBG;IACU,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkCjF;;;;;;;;;;;OAWG;IACI,kBAAkB,IAAI,WAAW,EAAE;IAI1C;;;;;;;;;;OAUG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;;;;;OASG;IACI,KAAK,IAAI,IAAI;CAIrB"}

package/dist/handlers/message-handler-registry.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Message Handler Registry
+ * Central registry for message handlers - eliminates shotgun surgery when adding new message types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandlerRegistry = void 0;
+const events_1 = require("../types/events");
+/**
+ * Registry for message handlers
+ * Stores handlers by message type and routes messages to appropriate handlers
+ */
+class MessageHandlerRegistry {
+    constructor(logger) {
+        this.handlers = new Map();
+        this.logger = logger;
+    }
+    /**
+     * Registers a message handler for a specific message type.
+     * Prevents duplicate registration unless replace option is true.
+     * Enables extensible message processing following Open/Closed Principle.
+     *
+     * @param handler - The handler to register (must have unique type)
+     * @param options - Registration options
+     * @param options.replace - Whether to replace existing handler (default: false)
+     *
+     * @example
+     * ```typescript
+     * const customHandler = new CustomMessageHandler();
+     * registry.register(customHandler);
+     *
+     * // Replace existing handler
+     * registry.register(newHandler, { replace: true });
+     * ```
+     */
+    register(handler, options = {}) {
+        const { replace = false } = options;
+        // Check if handler already exists
+        if (this.handlers.has(handler.type) && !replace) {
+            this.logger.warn(`Handler for ${handler.type} already registered, skipping. Use replace:true to override.`);
+            return;
+        }
+        this.handlers.set(handler.type, handler);
+        this.logger.debug(`Registered handler for message type: ${handler.type}`);
+    }
+    /**
+     * Registers multiple message handlers at once.
+     * Convenient for bulk registration of default or custom handlers.
+     * Uses same registration logic as register() for each handler.
+     *
+     * @param handlers - Array of handlers to register
+     * @param options - Registration options applied to all handlers
+     *
+     * @example
+     * ```typescript
+     * const handlers = [
+     *   new TaskResponseHandler(),
+     *   new AgentSelectedHandler(),
+     *   new ErrorHandler()
+     * ];
+     * registry.registerAll(handlers);
+     * ```
+     */
+    registerAll(handlers, options = {}) {
+        for (const handler of handlers) {
+            this.register(handler, options);
+        }
+    }
+    /**
+     * Unregisters a handler for a specific message type.
+     * Returns whether a handler was actually removed.
+     *
+     * @param type - The message type to unregister
+     * @returns True if handler was removed, false if no handler existed
+     *
+     * @example
+     * ```typescript
+     * const removed = registry.unregister('task_response');
+     * if (removed) {
+     *   console.log('Handler removed successfully');
+     * }
+     * ```
+     */
+    unregister(type) {
+        const result = this.handlers.delete(type);
+        if (result) {
+            this.logger.debug(`Unregistered handler for message type: ${type}`);
+        }
+        return result;
+    }
+    /**
+     * Checks if a handler is registered for a specific message type.
+     * Useful for conditional logic based on handler availability.
+     *
+     * @param type - The message type to check
+     * @returns True if handler exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('task_response')) {
+     *   console.log('Task response handler is registered');
+     * }
+     * ```
+     */
+    has(type) {
+        return this.handlers.has(type);
+    }
+    /**
+     * Gets a registered handler for a specific message type.
+     * Returns undefined if no handler is registered for the type.
+     *
+     * @param type - The message type to get handler for
+     * @returns The handler if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const handler = registry.get('task_response');
+     * if (handler) {
+     *   console.log(`Handler found: ${handler.type}`);
+     * }
+     * ```
+     */
+    get(type) {
+        return this.handlers.get(type);
+    }
+    /**
+     * Routes a message to its appropriate handler based on message type.
+     * Validates handler can process the message before delegating.
+     * Catches and logs handler errors, wrapping them in ValidationError.
+     *
+     * @param message - The message to handle
+     * @param context - Handler context with dependencies (logger, emit, etc.)
+     * @returns Promise that resolves when message is handled
+     * @throws {ValidationError} If handler throws an error during processing
+     *
+     * @example
+     * ```typescript
+     * const message = { type: 'task_response', ... };
+     * const context = createHandlerContext();
+     * await registry.handle(message, context);
+     * ```
+     */
+    async handle(message, context) {
+        // Check for pending message responses first (handled by caller)
+        if (message.id) {
+            // Let caller handle response matching
+            this.logger.debug(`Message ${message.id} may be a response - caller should check pending messages`);
+        }
+        // Find handler for this message type
+        const handler = this.handlers.get(message.type);
+        if (!handler) {
+            this.logger.debug(`No handler registered for message type: ${message.type}`);
+            // Not an error - some message types don't need handling
+            return;
+        }
+        // Verify handler can handle this message
+        if (!handler.canHandle(message)) {
+            this.logger.warn(`Handler for ${message.type} returned false for canHandle()`);
+            return;
+        }
+        // Delegate to handler
+        this.logger.debug(`Routing ${message.type} message to handler`);
+        try {
+            await handler.handle(message, context);
+        }
+        catch (error) {
+            this.logger.error(`Handler for ${message.type} threw error`, error);
+            throw new events_1.ValidationError(`Handler for ${message.type} failed`, error);
+        }
+    }
+    /**
+     * Gets an array of all currently registered message types.
+     * Useful for introspection and debugging handler configuration.
+     *
+     * @returns Array of message types that have registered handlers
+     *
+     * @example
+     * ```typescript
+     * const types = registry.getRegisteredTypes();
+     * console.log(`Registered handlers: ${types.join(', ')}`);
+     * ```
+     */
+    getRegisteredTypes() {
+        return Array.from(this.handlers.keys());
+    }
+    /**
+     * Gets the total number of registered handlers.
+     * Convenience getter for handler count.
+     *
+     * @returns Number of registered handlers
+     *
+     * @example
+     * ```typescript
+     * console.log(`${registry.size} handlers registered`);
+     * ```
+     */
+    get size() {
+        return this.handlers.size;
+    }
+    /**
+     * Clears all registered handlers from the registry.
+     * Useful for testing or resetting handler configuration.
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * console.log('All handlers cleared');
+     * ```
+     */
+    clear() {
+        this.handlers.clear();
+        this.logger.debug("Cleared all message handlers");
+    }
+}
+exports.MessageHandlerRegistry = MessageHandlerRegistry;
+//# sourceMappingURL=message-handler-registry.js.map

package/dist/handlers/message-handler-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-handler-registry.js","sourceRoot":"","sources":["../../src/handlers/message-handler-registry.ts"],"names":[],"mappings":"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"}

package/dist/handlers/message-handlers/agent-selected-handler.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Handler for agent_selected messages
+ * Processes coordinator's agent selection
+ */
+import { AgentSelectedMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class AgentSelectedHandler extends BaseMessageHandler<AgentSelectedMessage> {
+    readonly type: "agent_selected";
+    readonly schema: import("zod").ZodObject<{
+        content_type: import("zod").ZodOptional<import("zod").ZodEnum<["text/plain", "text/markdown", "text/html", "application/json", "image/*", "STRING", "JSON", "MD", "ARRAY"]>>;
+        to: import("zod").ZodOptional<import("zod").ZodString>;
+        room: import("zod").ZodOptional<import("zod").ZodString>;
+        timestamp: import("zod").ZodOptional<import("zod").ZodString>;
+        signature: import("zod").ZodOptional<import("zod").ZodString>;
+        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
+        task_id: import("zod").ZodOptional<import("zod").ZodString>;
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+    } & {
+        type: import("zod").ZodLiteral<"agent_selected">;
+        content: import("zod").ZodString;
+        from: import("zod").ZodLiteral<"coordinator">;
+        reasoning: import("zod").ZodString;
+        data: import("zod").ZodObject<{
+            agent_id: import("zod").ZodString;
+            agent_name: import("zod").ZodString;
+            capabilities: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+                description: string;
+            }, {
+                name: string;
+                description: string;
+            }>, "many">>;
+            user_request: import("zod").ZodString;
+            command: import("zod").ZodOptional<import("zod").ZodString>;
+            command_reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            agent_id: string;
+            agent_name: string;
+            user_request: string;
+            capabilities?: {
+                name: string;
+                description: string;
+            }[] | undefined;
+            command?: string | undefined;
+            command_reasoning?: string | undefined;
+        }, {
+            agent_id: string;
+            agent_name: string;
+            user_request: string;
+            capabilities?: {
+                name: string;
+                description: string;
+            }[] | undefined;
+            command?: string | undefined;
+            command_reasoning?: string | undefined;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "agent_selected";
+        content: string;
+        from: "coordinator";
+        data: {
+            agent_id: string;
+            agent_name: string;
+            user_request: string;
+            capabilities?: {
+                name: string;
+                description: string;
+            }[] | undefined;
+            command?: string | undefined;
+            command_reasoning?: string | undefined;
+        };
+        reasoning: string;
+        id?: string | undefined;
+        room?: string | undefined;
+        content_type?: "text/plain" | "text/markdown" | "text/html" | "application/json" | "image/*" | "STRING" | "JSON" | "MD" | "ARRAY" | undefined;
+        to?: string | undefined;
+        timestamp?: string | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "agent_selected";
+        content: string;
+        from: "coordinator";
+        data: {
+            agent_id: string;
+            agent_name: string;
+            user_request: string;
+            capabilities?: {
+                name: string;
+                description: string;
+            }[] | undefined;
+            command?: string | undefined;
+            command_reasoning?: string | undefined;
+        };
+        reasoning: string;
+        id?: string | undefined;
+        room?: string | undefined;
+        content_type?: "text/plain" | "text/markdown" | "text/html" | "application/json" | "image/*" | "STRING" | "JSON" | "MD" | "ARRAY" | undefined;
+        to?: string | undefined;
+        timestamp?: string | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(message: AgentSelectedMessage, context: HandlerContext): void;
+}
+//# sourceMappingURL=agent-selected-handler.d.ts.map

package/dist/handlers/message-handlers/agent-selected-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-selected-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/agent-selected-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAA8B,MAAM,aAAa,CAAC;AAE/E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,oBAAqB,SAAQ,kBAAkB,CAAC,oBAAoB,CAAC;IAChF,QAAQ,CAAC,IAAI,EAAG,gBAAgB,CAAU;IAC1C,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA8B;IAE7C,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI;CAyBxF"}

package/dist/handlers/message-handlers/agent-selected-handler.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Handler for agent_selected messages
+ * Processes coordinator's agent selection
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentSelectedHandler = void 0;
+const types_1 = require("../../types");
+const base_handler_1 = require("./base-handler");
+class AgentSelectedHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "agent_selected";
+        this.schema = types_1.AgentSelectedMessageSchema;
+    }
+    handleValidated(message, context) {
+        context.logger.debug("Handling agent_selected message", {
+            agentId: message.data.agent_id,
+            agentName: message.data.agent_name
+        });
+        // Build agent selected data
+        const data = {
+            agentId: message.data.agent_id,
+            agentName: message.data.agent_name,
+            reasoning: message.reasoning || "",
+            userRequest: message.data.user_request,
+            command: message.data.command,
+            commandReasoning: message.data.command_reasoning,
+            capabilities: message.data.capabilities
+        };
+        // Emit agent:selected event
+        this.emit(context, "agent:selected", data);
+        // Send webhook (fire-and-forget)
+        this.sendWebhook(context, "agent_selected", data, {
+            agentId: data.agentId
+        });
+    }
+}
+exports.AgentSelectedHandler = AgentSelectedHandler;
+//# sourceMappingURL=agent-selected-handler.js.map

package/dist/handlers/message-handlers/agent-selected-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-selected-handler.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/agent-selected-handler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uCAA+E;AAE/E,iDAAoD;AAGpD,MAAa,oBAAqB,SAAQ,iCAAwC;IAAlF;;QACW,SAAI,GAAG,gBAAyB,CAAC;QACjC,WAAM,GAAG,kCAA0B,CAAC;IA2B/C,CAAC;IAzBW,eAAe,CAAC,OAA6B,EAAE,OAAuB;QAC9E,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,iCAAiC,EAAE;YACtD,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ;YAC9B,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU;SACnC,CAAC,CAAC;QAEH,4BAA4B;QAC5B,MAAM,IAAI,GAAsB;YAC9B,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ;YAC9B,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,EAAE;YAClC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,YAAY;YACtC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO;YAC7B,gBAAgB,EAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB;YAChD,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,YAAY;SACxC,CAAC;QAEF,4BAA4B;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;QAE3C,iCAAiC;QACjC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE;YAChD,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;IACL,CAAC;CACF;AA7BD,oDA6BC"}

package/dist/handlers/message-handlers/agents-list-handler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Handler for agents list messages
+ * Processes agent list updates from the server
+ */
+import { z } from "zod";
+import { AgentsListMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class AgentsListHandler extends BaseMessageHandler<AgentsListMessage> {
+    readonly type: "agents";
+    readonly schema: z.ZodSchema<AgentsListMessage>;
+    protected handleValidated(message: AgentsListMessage, context: HandlerContext): Promise<void>;
+}
+//# sourceMappingURL=agents-list-handler.d.ts.map

package/dist/handlers/message-handlers/agents-list-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-list-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/agents-list-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iBAAiB,EAA2B,MAAM,aAAa,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,iBAAkB,SAAQ,kBAAkB,CAAC,iBAAiB,CAAC;IAC1E,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAClC,QAAQ,CAAC,MAAM,EAA8B,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;cAE5D,eAAe,CAC7B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CAQjB"}

package/dist/handlers/message-handlers/agents-list-handler.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Handler for agents list messages
+ * Processes agent list updates from the server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentsListHandler = void 0;
+const types_1 = require("../../types");
+const base_handler_1 = require("./base-handler");
+class AgentsListHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "agents";
+        this.schema = types_1.AgentsListMessageSchema;
+    }
+    async handleValidated(message, context) {
+        context.logger.debug("Handling agents list message", {
+            count: message.data.length
+        });
+        // Emit agent:list event with the agents array
+        this.emit(context, "agent:list", message.data);
+    }
+}
+exports.AgentsListHandler = AgentsListHandler;
+//# sourceMappingURL=agents-list-handler.js.map

package/dist/handlers/message-handlers/agents-list-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-list-handler.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/agents-list-handler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,uCAAyE;AACzE,iDAAoD;AAGpD,MAAa,iBAAkB,SAAQ,iCAAqC;IAA5E;;QACW,SAAI,GAAG,QAAiB,CAAC;QACzB,WAAM,GAAG,+BAAyD,CAAC;IAa9E,CAAC;IAXW,KAAK,CAAC,eAAe,CAC7B,OAA0B,EAC1B,OAAuB;QAEvB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE;YACnD,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM;SAC3B,CAAC,CAAC;QAEH,8CAA8C;QAC9C,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;CACF;AAfD,8CAeC"}

package/dist/handlers/message-handlers/auth-error-handler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Handler for auth_error messages
+ * Handles authentication errors
+ */
+import { AuthErrorMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class AuthErrorHandler extends BaseMessageHandler<AuthErrorMessage> {
+    readonly type: "auth_error";
+    readonly schema: import("zod").ZodObject<{
+        content: import("zod").ZodOptional<import("zod").ZodAny>;
+        content_type: import("zod").ZodOptional<import("zod").ZodEnum<["text/plain", "text/markdown", "text/html", "application/json", "image/*", "STRING", "JSON", "MD", "ARRAY"]>>;
+        from: import("zod").ZodOptional<import("zod").ZodString>;
+        to: import("zod").ZodOptional<import("zod").ZodString>;
+        room: import("zod").ZodOptional<import("zod").ZodString>;
+        timestamp: import("zod").ZodOptional<import("zod").ZodString>;
+        signature: import("zod").ZodOptional<import("zod").ZodString>;
+        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
+        reasoning: import("zod").ZodOptional<import("zod").ZodString>;
+        task_id: import("zod").ZodOptional<import("zod").ZodString>;
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+    } & {
+        type: import("zod").ZodLiteral<"auth_error">;
+        data: import("zod").ZodObject<{
+            error: import("zod").ZodString;
+            code: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            error: string;
+            code?: number | undefined;
+        }, {
+            error: string;
+            code?: number | undefined;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "auth_error";
+        data: {
+            error: string;
+            code?: number | undefined;
+        };
+        id?: string | undefined;
+        room?: string | undefined;
+        content?: any;
+        content_type?: "text/plain" | "text/markdown" | "text/html" | "application/json" | "image/*" | "STRING" | "JSON" | "MD" | "ARRAY" | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        timestamp?: string | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "auth_error";
+        data: {
+            error: string;
+            code?: number | undefined;
+        };
+        id?: string | undefined;
+        room?: string | undefined;
+        content?: any;
+        content_type?: "text/plain" | "text/markdown" | "text/html" | "application/json" | "image/*" | "STRING" | "JSON" | "MD" | "ARRAY" | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        timestamp?: string | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(message: AuthErrorMessage, context: HandlerContext): Promise<void>;
+}
+//# sourceMappingURL=auth-error-handler.d.ts.map

package/dist/handlers/message-handlers/auth-error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-error-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/auth-error-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,gBAAgB,EAA0B,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,gBAAiB,SAAQ,kBAAkB,CAAC,gBAAgB,CAAC;IACxE,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IACtC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA0B;cAEzB,eAAe,CAC7B,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CAajB"}