@teneo-protocol/sdk 1.0.0

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

@@ -0,0 +1,76 @@
+/**
+ * Handler for error messages
+ * Processes error messages from the server
+ */
+import { ErrorMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class ErrorMessageHandler extends BaseMessageHandler<ErrorMessage> {
+    readonly type: "error";
+    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>;
+        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<"error">;
+        content: import("zod").ZodString;
+        from: import("zod").ZodLiteral<"system">;
+        data: import("zod").ZodObject<{
+            code: import("zod").ZodNumber;
+            message: import("zod").ZodString;
+            details: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strip", import("zod").ZodTypeAny, {
+            code: number;
+            message: string;
+            details?: any;
+        }, {
+            code: number;
+            message: string;
+            details?: any;
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "error";
+        content: string;
+        from: "system";
+        data: {
+            code: number;
+            message: string;
+            details?: any;
+        };
+        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;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "error";
+        content: string;
+        from: "system";
+        data: {
+            code: number;
+            message: string;
+            details?: any;
+        };
+        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;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(message: ErrorMessage, context: HandlerContext): Promise<void>;
+}
+//# sourceMappingURL=error-message-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-message-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/error-message-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAsB,MAAM,aAAa,CAAC;AAE/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,mBAAoB,SAAQ,kBAAkB,CAAC,YAAY,CAAC;IACvE,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IACjC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAsB;cAErB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAY/F"}

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

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Handler for error messages
+ * Processes error messages from the server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorMessageHandler = void 0;
+const types_1 = require("../../types");
+const events_1 = require("../../types/events");
+const base_handler_1 = require("./base-handler");
+class ErrorMessageHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "error";
+        this.schema = types_1.ErrorMessageSchema;
+    }
+    async handleValidated(message, context) {
+        context.logger.error("Received error message from server", {
+            code: message.data.code,
+            message: message.data.message
+        });
+        // Create error object
+        const error = new events_1.MessageError(message.content || message.data.message, message.data);
+        // Emit error event
+        this.emit(context, "error", error);
+    }
+}
+exports.ErrorMessageHandler = ErrorMessageHandler;
+//# sourceMappingURL=error-message-handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-message-handler.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/error-message-handler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uCAA+D;AAC/D,+CAAkD;AAClD,iDAAoD;AAGpD,MAAa,mBAAoB,SAAQ,iCAAgC;IAAzE;;QACW,SAAI,GAAG,OAAgB,CAAC;QACxB,WAAM,GAAG,0BAAkB,CAAC;IAcvC,CAAC;IAZW,KAAK,CAAC,eAAe,CAAC,OAAqB,EAAE,OAAuB;QAC5E,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE;YACzD,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI;YACvB,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO;SAC9B,CAAC,CAAC;QAEH,sBAAsB;QACtB,MAAM,KAAK,GAAG,IAAI,qBAAY,CAAC,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAEtF,mBAAmB;QACnB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;CACF;AAhBD,kDAgBC"}

package/dist/handlers/message-handlers/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Message handlers index
+ * Exports all message handlers and provides convenience functions
+ */
+export * from "./types";
+export * from "./base-handler";
+export { TaskResponseHandler } from "./task-response-handler";
+export { AgentSelectedHandler } from "./agent-selected-handler";
+export { ChallengeHandler } from "./challenge-handler";
+export { AuthMessageHandler } from "./auth-message-handler";
+export { AuthSuccessHandler } from "./auth-success-handler";
+export { AuthErrorHandler } from "./auth-error-handler";
+export { AuthRequiredHandler } from "./auth-required-handler";
+export { AgentsListHandler } from "./agents-list-handler";
+export { ErrorMessageHandler } from "./error-message-handler";
+export { RegularMessageHandler } from "./regular-message-handler";
+export { PingHandler, PongHandler } from "./ping-pong-handler";
+export { SubscribeResponseHandler } from "./subscribe-response-handler";
+export { UnsubscribeResponseHandler } from "./unsubscribe-response-handler";
+export { ListRoomsResponseHandler } from "./list-rooms-response-handler";
+import { MessageHandler } from "./types";
+/**
+ * Get all default message handlers
+ * @param clientType - The client type for authentication (default: "user")
+ * @returns Array of all default handlers
+ */
+export declare function getDefaultHandlers(clientType?: "user" | "agent" | "coordinator"): MessageHandler[];
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/message-handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAiBzE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,GAAE,MAAM,GAAG,OAAO,GAAG,aAAsB,GACpD,cAAc,EAAE,CA2BlB"}

package/dist/handlers/message-handlers/index.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Message handlers index
+ * Exports all message handlers and provides convenience functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListRoomsResponseHandler = exports.UnsubscribeResponseHandler = exports.SubscribeResponseHandler = exports.PongHandler = exports.PingHandler = exports.RegularMessageHandler = exports.ErrorMessageHandler = exports.AgentsListHandler = exports.AuthRequiredHandler = exports.AuthErrorHandler = exports.AuthSuccessHandler = exports.AuthMessageHandler = exports.ChallengeHandler = exports.AgentSelectedHandler = exports.TaskResponseHandler = void 0;
+exports.getDefaultHandlers = getDefaultHandlers;
+// Export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./base-handler"), exports);
+// Export all handlers
+var task_response_handler_1 = require("./task-response-handler");
+Object.defineProperty(exports, "TaskResponseHandler", { enumerable: true, get: function () { return task_response_handler_1.TaskResponseHandler; } });
+var agent_selected_handler_1 = require("./agent-selected-handler");
+Object.defineProperty(exports, "AgentSelectedHandler", { enumerable: true, get: function () { return agent_selected_handler_1.AgentSelectedHandler; } });
+var challenge_handler_1 = require("./challenge-handler");
+Object.defineProperty(exports, "ChallengeHandler", { enumerable: true, get: function () { return challenge_handler_1.ChallengeHandler; } });
+var auth_message_handler_1 = require("./auth-message-handler");
+Object.defineProperty(exports, "AuthMessageHandler", { enumerable: true, get: function () { return auth_message_handler_1.AuthMessageHandler; } });
+var auth_success_handler_1 = require("./auth-success-handler");
+Object.defineProperty(exports, "AuthSuccessHandler", { enumerable: true, get: function () { return auth_success_handler_1.AuthSuccessHandler; } });
+var auth_error_handler_1 = require("./auth-error-handler");
+Object.defineProperty(exports, "AuthErrorHandler", { enumerable: true, get: function () { return auth_error_handler_1.AuthErrorHandler; } });
+var auth_required_handler_1 = require("./auth-required-handler");
+Object.defineProperty(exports, "AuthRequiredHandler", { enumerable: true, get: function () { return auth_required_handler_1.AuthRequiredHandler; } });
+var agents_list_handler_1 = require("./agents-list-handler");
+Object.defineProperty(exports, "AgentsListHandler", { enumerable: true, get: function () { return agents_list_handler_1.AgentsListHandler; } });
+var error_message_handler_1 = require("./error-message-handler");
+Object.defineProperty(exports, "ErrorMessageHandler", { enumerable: true, get: function () { return error_message_handler_1.ErrorMessageHandler; } });
+var regular_message_handler_1 = require("./regular-message-handler");
+Object.defineProperty(exports, "RegularMessageHandler", { enumerable: true, get: function () { return regular_message_handler_1.RegularMessageHandler; } });
+var ping_pong_handler_1 = require("./ping-pong-handler");
+Object.defineProperty(exports, "PingHandler", { enumerable: true, get: function () { return ping_pong_handler_1.PingHandler; } });
+Object.defineProperty(exports, "PongHandler", { enumerable: true, get: function () { return ping_pong_handler_1.PongHandler; } });
+var subscribe_response_handler_1 = require("./subscribe-response-handler");
+Object.defineProperty(exports, "SubscribeResponseHandler", { enumerable: true, get: function () { return subscribe_response_handler_1.SubscribeResponseHandler; } });
+var unsubscribe_response_handler_1 = require("./unsubscribe-response-handler");
+Object.defineProperty(exports, "UnsubscribeResponseHandler", { enumerable: true, get: function () { return unsubscribe_response_handler_1.UnsubscribeResponseHandler; } });
+var list_rooms_response_handler_1 = require("./list-rooms-response-handler");
+Object.defineProperty(exports, "ListRoomsResponseHandler", { enumerable: true, get: function () { return list_rooms_response_handler_1.ListRoomsResponseHandler; } });
+// Import for convenience function
+const task_response_handler_2 = require("./task-response-handler");
+const agent_selected_handler_2 = require("./agent-selected-handler");
+const challenge_handler_2 = require("./challenge-handler");
+const auth_message_handler_2 = require("./auth-message-handler");
+const auth_success_handler_2 = require("./auth-success-handler");
+const auth_error_handler_2 = require("./auth-error-handler");
+const auth_required_handler_2 = require("./auth-required-handler");
+const agents_list_handler_2 = require("./agents-list-handler");
+const error_message_handler_2 = require("./error-message-handler");
+const regular_message_handler_2 = require("./regular-message-handler");
+const ping_pong_handler_2 = require("./ping-pong-handler");
+const subscribe_response_handler_2 = require("./subscribe-response-handler");
+const unsubscribe_response_handler_2 = require("./unsubscribe-response-handler");
+const list_rooms_response_handler_2 = require("./list-rooms-response-handler");
+/**
+ * Get all default message handlers
+ * @param clientType - The client type for authentication (default: "user")
+ * @returns Array of all default handlers
+ */
+function getDefaultHandlers(clientType = "user") {
+    return [
+        // Authentication handlers
+        new challenge_handler_2.ChallengeHandler(clientType),
+        new auth_message_handler_2.AuthMessageHandler(),
+        new auth_success_handler_2.AuthSuccessHandler(),
+        new auth_error_handler_2.AuthErrorHandler(),
+        new auth_required_handler_2.AuthRequiredHandler(),
+        // Agent/coordinator handlers
+        new task_response_handler_2.TaskResponseHandler(),
+        new agent_selected_handler_2.AgentSelectedHandler(),
+        new agents_list_handler_2.AgentsListHandler(),
+        // Message handlers
+        new regular_message_handler_2.RegularMessageHandler(),
+        new error_message_handler_2.ErrorMessageHandler(),
+        // Room handlers
+        new subscribe_response_handler_2.SubscribeResponseHandler(),
+        new unsubscribe_response_handler_2.UnsubscribeResponseHandler(),
+        new list_rooms_response_handler_2.ListRoomsResponseHandler(),
+        // Keepalive handlers
+        new ping_pong_handler_2.PingHandler(),
+        new ping_pong_handler_2.PongHandler()
+    ];
+}
+//# sourceMappingURL=index.js.map

package/dist/handlers/message-handlers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;AA4CH,gDA6BC;AAvED,eAAe;AACf,0CAAwB;AACxB,iDAA+B;AAE/B,sBAAsB;AACtB,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,mEAAgE;AAAvD,8HAAA,oBAAoB,OAAA;AAC7B,yDAAuD;AAA9C,qHAAA,gBAAgB,OAAA;AACzB,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAC3B,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAC3B,2DAAwD;AAA/C,sHAAA,gBAAgB,OAAA;AACzB,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,6DAA0D;AAAjD,wHAAA,iBAAiB,OAAA;AAC1B,iEAA8D;AAArD,4HAAA,mBAAmB,OAAA;AAC5B,qEAAkE;AAAzD,gIAAA,qBAAqB,OAAA;AAC9B,yDAA+D;AAAtD,gHAAA,WAAW,OAAA;AAAE,gHAAA,WAAW,OAAA;AACjC,2EAAwE;AAA/D,sIAAA,wBAAwB,OAAA;AACjC,+EAA4E;AAAnE,0IAAA,0BAA0B,OAAA;AACnC,6EAAyE;AAAhE,uIAAA,wBAAwB,OAAA;AAEjC,kCAAkC;AAClC,mEAA8D;AAC9D,qEAAgE;AAChE,2DAAuD;AACvD,iEAA4D;AAC5D,iEAA4D;AAC5D,6DAAwD;AACxD,mEAA8D;AAC9D,+DAA0D;AAC1D,mEAA8D;AAC9D,uEAAkE;AAClE,2DAA+D;AAC/D,6EAAwE;AACxE,iFAA4E;AAC5E,+EAAyE;AAGzE;;;;GAIG;AACH,SAAgB,kBAAkB,CAChC,aAA+C,MAAM;IAErD,OAAO;QACL,0BAA0B;QAC1B,IAAI,oCAAgB,CAAC,UAAU,CAAC;QAChC,IAAI,yCAAkB,EAAE;QACxB,IAAI,yCAAkB,EAAE;QACxB,IAAI,qCAAgB,EAAE;QACtB,IAAI,2CAAmB,EAAE;QAEzB,6BAA6B;QAC7B,IAAI,2CAAmB,EAAE;QACzB,IAAI,6CAAoB,EAAE;QAC1B,IAAI,uCAAiB,EAAE;QAEvB,mBAAmB;QACnB,IAAI,+CAAqB,EAAE;QAC3B,IAAI,2CAAmB,EAAE;QAEzB,gBAAgB;QAChB,IAAI,qDAAwB,EAAE;QAC9B,IAAI,yDAA0B,EAAE;QAChC,IAAI,sDAAwB,EAAE;QAE9B,qBAAqB;QACrB,IAAI,+BAAW,EAAE;QACjB,IAAI,+BAAW,EAAE;KAClB,CAAC;AACJ,CAAC"}

package/dist/handlers/message-handlers/list-rooms-response-handler.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Handler for list_rooms response messages
+ * Processes room list from server
+ */
+import { ListRoomsResponse } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class ListRoomsResponseHandler extends BaseMessageHandler<ListRoomsResponse> {
+    readonly type: "list_rooms";
+    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<"list_rooms">;
+        data: import("zod").ZodObject<{
+            rooms: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+                is_public: import("zod").ZodBoolean;
+                created_at: import("zod").ZodString;
+                updated_at: import("zod").ZodString;
+                is_owner: import("zod").ZodBoolean;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | undefined;
+            }, {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | undefined;
+            }>, "many">;
+        }, "strip", import("zod").ZodTypeAny, {
+            rooms: {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | undefined;
+            }[];
+        }, {
+            rooms: {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | undefined;
+            }[];
+        }>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "list_rooms";
+        data: {
+            rooms: {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | 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: "list_rooms";
+        data: {
+            rooms: {
+                name: string;
+                id: string;
+                is_public: boolean;
+                created_at: string;
+                updated_at: string;
+                is_owner: boolean;
+                description?: string | null | 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: ListRoomsResponse, context: HandlerContext): void;
+}
+//# sourceMappingURL=list-rooms-response-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-rooms-response-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/list-rooms-response-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,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,wBAAyB,SAAQ,kBAAkB,CAAC,iBAAiB,CAAC;IACjF,QAAQ,CAAC,IAAI,EAAG,YAAY,CAAU;IACtC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA2B;IAE1C,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI;CAcrF"}

package/dist/handlers/message-handlers/list-rooms-response-handler.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Handler for list_rooms response messages
+ * Processes room list from server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListRoomsResponseHandler = void 0;
+const types_1 = require("../../types");
+const base_handler_1 = require("./base-handler");
+class ListRoomsResponseHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "list_rooms";
+        this.schema = types_1.ListRoomsResponseSchema;
+    }
+    handleValidated(message, context) {
+        context.logger.debug("Handling list_rooms response", {
+            roomCount: message.data.rooms.length
+        });
+        // Emit room:list event with room info array
+        this.emit(context, "room:list", message.data.rooms);
+        // Send webhook (fire-and-forget)
+        this.sendWebhook(context, "room_list", {
+            rooms: message.data.rooms,
+            count: message.data.rooms.length
+        });
+    }
+}
+exports.ListRoomsResponseHandler = ListRoomsResponseHandler;
+//# sourceMappingURL=list-rooms-response-handler.js.map

package/dist/handlers/message-handlers/list-rooms-response-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-rooms-response-handler.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/list-rooms-response-handler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uCAAyE;AACzE,iDAAoD;AAGpD,MAAa,wBAAyB,SAAQ,iCAAqC;IAAnF;;QACW,SAAI,GAAG,YAAqB,CAAC;QAC7B,WAAM,GAAG,+BAAuB,CAAC;IAgB5C,CAAC;IAdW,eAAe,CAAC,OAA0B,EAAE,OAAuB;QAC3E,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE;YACnD,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;SACrC,CAAC,CAAC;QAEH,4CAA4C;QAC5C,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEpD,iCAAiC;QACjC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE;YACrC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK;YACzB,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM;SACjC,CAAC,CAAC;IACL,CAAC;CACF;AAlBD,4DAkBC"}

package/dist/handlers/message-handlers/ping-pong-handler.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Handler for ping and pong messages
+ * These are keepalive messages that don't require special handling
+ */
+import { PingMessage, PongMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class PingHandler extends BaseMessageHandler<PingMessage> {
+    readonly type: "ping";
+    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>;
+        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        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<"ping">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "ping";
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "ping";
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(_message: PingMessage, context: HandlerContext): Promise<void>;
+}
+export declare class PongHandler extends BaseMessageHandler<PongMessage> {
+    readonly type: "pong";
+    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>;
+        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        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<"pong">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "pong";
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "pong";
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(_message: PongMessage, context: HandlerContext): Promise<void>;
+}
+//# sourceMappingURL=ping-pong-handler.d.ts.map

package/dist/handlers/message-handlers/ping-pong-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping-pong-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/ping-pong-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAwC,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,WAAY,SAAQ,kBAAkB,CAAC,WAAW,CAAC;IAC9D,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAChC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAqB;cAEpB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAK/F;AAED,qBAAa,WAAY,SAAQ,kBAAkB,CAAC,WAAW,CAAC;IAC9D,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAChC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAqB;cAEpB,eAAe,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAK/F"}

package/dist/handlers/message-handlers/ping-pong-handler.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Handler for ping and pong messages
+ * These are keepalive messages that don't require special handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PongHandler = exports.PingHandler = void 0;
+const types_1 = require("../../types");
+const base_handler_1 = require("./base-handler");
+class PingHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "ping";
+        this.schema = types_1.PingMessageSchema;
+    }
+    async handleValidated(_message, context) {
+        // Ping messages are handled at the WebSocket level (ws library)
+        // No special processing needed here
+        context.logger.debug("Received ping");
+    }
+}
+exports.PingHandler = PingHandler;
+class PongHandler extends base_handler_1.BaseMessageHandler {
+    constructor() {
+        super(...arguments);
+        this.type = "pong";
+        this.schema = types_1.PongMessageSchema;
+    }
+    async handleValidated(_message, context) {
+        // Pong messages are handled at the WebSocket level (ws library)
+        // No special processing needed here
+        context.logger.debug("Received pong");
+    }
+}
+exports.PongHandler = PongHandler;
+//# sourceMappingURL=ping-pong-handler.js.map

package/dist/handlers/message-handlers/ping-pong-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping-pong-handler.js","sourceRoot":"","sources":["../../../src/handlers/message-handlers/ping-pong-handler.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,uCAA6F;AAC7F,iDAAoD;AAGpD,MAAa,WAAY,SAAQ,iCAA+B;IAAhE;;QACW,SAAI,GAAG,MAAe,CAAC;QACvB,WAAM,GAAG,yBAAiB,CAAC;IAOtC,CAAC;IALW,KAAK,CAAC,eAAe,CAAC,QAAqB,EAAE,OAAuB;QAC5E,gEAAgE;QAChE,oCAAoC;QACpC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACxC,CAAC;CACF;AATD,kCASC;AAED,MAAa,WAAY,SAAQ,iCAA+B;IAAhE;;QACW,SAAI,GAAG,MAAe,CAAC;QACvB,WAAM,GAAG,yBAAiB,CAAC;IAOtC,CAAC;IALW,KAAK,CAAC,eAAe,CAAC,QAAqB,EAAE,OAAuB;QAC5E,gEAAgE;QAChE,oCAAoC;QACpC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACxC,CAAC;CACF;AATD,kCASC"}

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

@@ -0,0 +1,56 @@
+/**
+ * Handler for regular 'message' type messages
+ * Processes messages from agents (when they send 'message' instead of 'task_response')
+ */
+import { UserMessage } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+export declare class RegularMessageHandler extends BaseMessageHandler<UserMessage> {
+    readonly type: "message";
+    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"]>>;
+        from: import("zod").ZodOptional<import("zod").ZodString>;
+        to: import("zod").ZodOptional<import("zod").ZodString>;
+        timestamp: import("zod").ZodOptional<import("zod").ZodString>;
+        data: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        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<"message">;
+        content: import("zod").ZodString;
+        room: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "message";
+        content: string;
+        id?: string | undefined;
+        room?: string | undefined;
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }, {
+        type: "message";
+        content: string;
+        id?: string | undefined;
+        room?: string | undefined;
+        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;
+        data?: Record<string, any> | undefined;
+        signature?: string | undefined;
+        publicKey?: string | undefined;
+        reasoning?: string | undefined;
+        task_id?: string | undefined;
+    }>;
+    protected handleValidated(message: UserMessage, context: HandlerContext): Promise<void>;
+}
+//# sourceMappingURL=regular-message-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regular-message-handler.d.ts","sourceRoot":"","sources":["../../../src/handlers/message-handlers/regular-message-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAqB,MAAM,aAAa,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,qBAAsB,SAAQ,kBAAkB,CAAC,WAAW,CAAC;IACxE,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAU;IACnC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAAqB;cAEpB,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAkD9F"}