orchestrator-client 5.6.0 → 5.7.1

package/dist/index.cjs

@@ -140,7 +140,10 @@ var OrchestratorAsync = class {
   constructor(opts = {}) {
     this._abortController = null;
     this._insecure = false;
-    this._baseUrl = (opts.baseUrl ?? "http://localhost:8080").replace(/\/+$/, "");
+    this._baseUrl = (opts.baseUrl ?? "http://localhost:8080").replace(
+      /\/+$/,
+      ""
+    );
     this._apiKey = opts.apiKey;
     this._getToken = opts.getToken;
     this._timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -162,11 +165,11 @@ var OrchestratorAsync = class {
   async _resolveHeaders() {
     const headers = {};
     if (this._apiKey) {
-      headers["Authorization"] = `Bearer ${this._apiKey}`;
+      headers.Authorization = `Bearer ${this._apiKey}`;
     } else if (this._getToken) {
       const token = await this._getToken();
       if (token) {
-        headers["Authorization"] = `Bearer ${token}`;
+        headers.Authorization = `Bearer ${token}`;
       }
     }
     return headers;
@@ -314,34 +317,54 @@ var OrchestratorAsync = class {
   // Tasks
   // ------------------------------------------------------------------
   async listTasks(params) {
-    const data = await this._get("/tasks", {
-      workflow_id: params?.workflowId,
-      status: params?.status,
-      limit: params?.limit,
-      offset: params?.offset,
-      sort_by: params?.sortBy,
-      sort_order: params?.sortOrder
+    const headers = {};
+    if (params?.locale) headers["X-Locale"] = params.locale;
+    const data = await this._request("GET", "/tasks", {
+      params: {
+        page: params?.page,
+        limit: params?.limit,
+        order_by: params?.orderBy,
+        order_direction: params?.orderDirection,
+        workflow_id: params?.workflowId
+      },
+      headers
     });
-    const tasks = (data.tasks ?? []).map(buildTaskSummary);
+    const tasks = (data.tasks ?? []).map(
+      buildTaskSummary
+    );
     return { tasks, pagination: buildPagination(data) };
   }
   async createTask(params) {
-    const data = await this._post("/tasks", {
+    const data = await this._post("/task/create", {
       workflow_id: params.workflowId,
       goal_prompt: params.goalPrompt,
       max_iterations: params.maxIterations,
-      options: params.options,
+      reasoning_effort: params.reasoningEffort,
+      system_prompt: params.systemPrompt,
+      developer_prompt: params.developerPrompt,
       ticket_id: params.ticketId,
-      title: params.title,
-      model_id: params.modelId
+      ticket_text: params.ticketText,
+      summary: params.summary,
+      problem_summary: params.problemSummary,
+      solution_strategy: params.solutionStrategy,
+      agent_model_id: params.agentModelId,
+      orchestrator_model_id: params.orchestratorModelId,
+      available_tools: params.availableTools,
+      attachment_ids: params.attachmentIds,
+      options: params.options
     });
     return {
       taskId: data.taskId ?? data.task_id ?? "",
       status: data.status ?? ""
     };
   }
-  async getTaskStatus(taskId) {
-    const data = await this._get(`/tasks/${taskId}`);
+  async getTaskStatus(taskId, locale) {
+    const headers = {};
+    if (locale) headers["X-Locale"] = locale;
+    const data = await this._request("GET", "/task/status", {
+      params: { task_id: taskId },
+      headers
+    });
     return {
       ...buildTaskSummary(data),
       subtaskIds: data.subtaskIds ?? data.subtask_ids ?? [],
@@ -349,26 +372,45 @@ var OrchestratorAsync = class {
       options: data.options ?? null
     };
   }
-  async getTaskConversation(taskId) {
-    const data = await this._get(`/tasks/${taskId}/conversation`);
+  async setTaskStatus(taskId, status) {
+    const data = await this._post("/task/set_status", {
+      task_id: taskId,
+      status
+    });
+    return { message: data.message ?? "" };
+  }
+  async getTaskConversation(taskId, params) {
+    const headers = {};
+    if (params?.locale) headers["X-Locale"] = params.locale;
+    const data = await this._request("GET", "/task/conversation", {
+      params: {
+        task_id: taskId,
+        include_summaries: params?.includeSummaries,
+        exclude_archived: params?.excludeArchived
+      },
+      headers
+    });
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
-      conversation: (data.conversation ?? []).map(
-        (m) => m
-      )
+      conversation: (data.conversation ?? []).map((m) => m)
     };
   }
   async getArchivedMessageContent(taskId, messageId) {
     return this._get(
-      `/tasks/${taskId}/conversation/messages/${messageId}/archived`
+      "/task/message/archived-content",
+      { task_id: taskId, message_id: messageId }
     );
   }
   async getTaskCompactions(taskId) {
-    const data = await this._get(`/tasks/${taskId}/compactions`);
+    const data = await this._get("/task/compactions", {
+      task_id: taskId
+    });
     return data.compactions ?? [];
   }
   async getTaskJournal(taskId) {
-    const data = await this._get(`/tasks/${taskId}/journal`);
+    const data = await this._get("/task/journal", {
+      task_id: taskId
+    });
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
       exists: data.exists ?? false,
@@ -379,11 +421,22 @@ var OrchestratorAsync = class {
     };
   }
   async cancelTask(taskId) {
-    const data = await this._post(`/tasks/${taskId}/cancel`);
-    return { message: data.message ?? "" };
+    const data = await this._post("/task/cancel", {
+      task_id: taskId
+    });
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      killed: data.killed ?? false,
+      via: data.via ?? "none",
+      holderId: data.holderId ?? data.holder_id ?? void 0,
+      reason: data.reason ?? void 0,
+      message: data.message ?? ""
+    };
   }
   async deleteTask(taskId) {
-    const data = await this._delete(`/tasks/${taskId}`);
+    const data = await this._post("/task/delete", {
+      task_id: taskId
+    });
     return {
       deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
       failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
@@ -392,7 +445,10 @@ var OrchestratorAsync = class {
     };
   }
   async deleteTasks(taskIds) {
-    const data = await this._post("/tasks/delete", { task_ids: taskIds });
+    const data = await this._post(
+      "/task/delete/multiple",
+      { task_ids: taskIds }
+    );
     return {
       deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
       failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
@@ -403,11 +459,11 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  async uploadAttachment(taskId, file, filename) {
+  async uploadAttachment(file, filename) {
     const formData = new FormData();
     formData.append("file", file, filename);
     const headers = await this._resolveHeaders();
-    const response = await this._fetch(this._makeUrl(`/tasks/${taskId}/attachments`), {
+    const response = await this._fetch(this._makeUrl("/attachment"), {
       method: "POST",
       headers: { ...headers },
       body: formData
@@ -429,11 +485,12 @@ var OrchestratorAsync = class {
       tokenCount: data.tokenCount ?? data.token_count ?? null
     };
   }
-  async downloadAttachment(taskId, attachmentId) {
+  async downloadAttachment(attachmentId) {
     const headers = await this._resolveHeaders();
-    const response = await this._fetch(this._makeUrl(`/tasks/${taskId}/attachments/${attachmentId}`), {
-      headers
-    });
+    const response = await this._fetch(
+      this._makeUrl(`/attachment/${attachmentId}`),
+      { headers }
+    );
     if (!response.ok) {
       throw new OrchestratorAPIError(
         `Attachment download failed: ${response.statusText}`,
@@ -445,224 +502,363 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   // Interactive workflow
   // ------------------------------------------------------------------
-  async sendInteractiveMessage(taskId, content) {
-    const data = await this._post(`/tasks/${taskId}/interactive/message`, {
-      content
-    });
+  async sendInteractiveMessage(taskId, message, attachmentIds) {
+    const data = await this._post(
+      "/task/interactive/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
+    );
     return { message: data.message ?? "" };
   }
   async markInteractiveComplete(taskId) {
-    const data = await this._post(`/tasks/${taskId}/interactive/complete`);
+    const data = await this._post(
+      "/task/interactive/mark_complete",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markInteractiveFailed(taskId) {
-    const data = await this._post(`/tasks/${taskId}/interactive/failed`);
+    const data = await this._post(
+      "/task/interactive/mark_failed",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
-  async approveInteractiveAction(taskId) {
-    const data = await this._post(`/tasks/${taskId}/interactive/approve`);
+  async approveInteractiveAction(taskId, approved = true) {
+    const data = await this._post(
+      "/task/interactive/action",
+      { task_id: taskId, approved }
+    );
+    return { message: data.message ?? "" };
+  }
+  async stopInteractive(taskId) {
+    const data = await this._post(
+      "/task/interactive/stop",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Proactive workflow
   // ------------------------------------------------------------------
-  async sendProactiveGuide(taskId, guide) {
-    const data = await this._post(`/tasks/${taskId}/proactive/guide`, {
-      guide
-    });
+  async sendProactiveGuide(taskId, message, attachmentIds) {
+    const data = await this._post(
+      "/task/proactive/guide",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
+    );
     return { message: data.message ?? "" };
   }
   async respondProactiveHelp(taskId, response) {
-    const data = await this._post(`/tasks/${taskId}/proactive/respond`, {
-      response
-    });
+    const data = await this._post(
+      "/task/proactive/help",
+      { task_id: taskId, response }
+    );
     return { message: data.message ?? "" };
   }
-  async approveProactiveAction(taskId) {
-    const data = await this._post(`/tasks/${taskId}/proactive/approve`);
+  async approveProactiveAction(taskId, approved = true) {
+    const data = await this._post(
+      "/task/proactive/action",
+      { task_id: taskId, approved }
+    );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Ticket workflow
   // ------------------------------------------------------------------
-  async sendTicketGuide(taskId, guide) {
-    const data = await this._post(`/tasks/${taskId}/ticket/guide`, {
-      guide
-    });
+  async sendTicketGuide(taskId, message, attachmentIds) {
+    const data = await this._post(
+      "/task/ticket/guide",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
+    );
     return { message: data.message ?? "" };
   }
   async respondTicketHelp(taskId, response) {
-    const data = await this._post(`/tasks/${taskId}/ticket/respond`, {
-      response
-    });
+    const data = await this._post(
+      "/task/ticket/help",
+      { task_id: taskId, response }
+    );
     return { message: data.message ?? "" };
   }
-  async approveTicketAction(taskId) {
-    const data = await this._post(`/tasks/${taskId}/ticket/approve`);
+  async approveTicketAction(taskId, approved = true) {
+    const data = await this._post(
+      "/task/ticket/action",
+      { task_id: taskId, approved }
+    );
     return { message: data.message ?? "" };
   }
   async wakeTicket(taskId) {
-    const data = await this._post(`/tasks/${taskId}/ticket/wake`);
+    const data = await this._post(
+      "/task/ticket/wake",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   // ------------------------------------------------------------------
   // Matrix workflow
   // ------------------------------------------------------------------
-  async sendMatrixMessage(taskId, content) {
-    const data = await this._post(`/tasks/${taskId}/matrix/message`, {
-      content
-    });
+  async sendMatrixMessage(taskId, message, attachmentIds) {
+    const data = await this._post(
+      "/task/matrix/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
+    );
     return { message: data.message ?? "" };
   }
   async markMatrixComplete(taskId) {
-    const data = await this._post(`/tasks/${taskId}/matrix/complete`);
+    const data = await this._post(
+      "/task/matrix/mark_complete",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markMatrixFailed(taskId) {
-    const data = await this._post(`/tasks/${taskId}/matrix/failed`);
+    const data = await this._post(
+      "/task/matrix/mark_failed",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
-  async approveMatrixAction(taskId) {
-    const data = await this._post(`/tasks/${taskId}/matrix/approve`);
+  async approveMatrixAction(taskId, approved = true) {
+    const data = await this._post(
+      "/task/matrix/action",
+      { task_id: taskId, approved }
+    );
     return { message: data.message ?? "" };
   }
-  async getMatrixConversation(taskId) {
-    const data = await this._get(`/tasks/${taskId}/matrix/conversation`);
+  async getMatrixConversation(taskId, phase, includeSummaries) {
+    const data = await this._get(
+      "/task/matrix/conversation",
+      {
+        task_id: taskId,
+        phase,
+        include_summaries: includeSummaries
+      }
+    );
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
-      conversation: (data.conversation ?? []).map(
-        (m) => m
-      )
+      conversation: (data.conversation ?? []).map((m) => m)
     };
   }
   // ------------------------------------------------------------------
   // VSA workflow
   // ------------------------------------------------------------------
   async createVSATask(params) {
-    const data = await this._post("/tasks/vsa", {
+    const body = {
+      user_id: params.userId,
       goal_prompt: params.goalPrompt,
       title: params.title,
-      model_id: params.modelId
-    });
+      agent_model_id: params.agentModelId,
+      orchestrator_model_id: params.orchestratorModelId,
+      attachment_ids: params.attachmentIds,
+      options: params.options
+    };
+    if (params.delegatedToken !== void 0) {
+      body.delegated_token = params.delegatedToken;
+    }
+    const data = await this._post(
+      "/task/vsa/create",
+      body
+    );
     return {
       taskId: data.taskId ?? data.task_id ?? "",
       status: data.status ?? ""
     };
   }
-  async sendVSAMessage(taskId, content) {
-    const data = await this._post(`/tasks/${taskId}/vsa/message`, {
-      content
-    });
+  async sendVSAMessage(taskId, message, options) {
+    const body = {
+      task_id: taskId,
+      message,
+      attachment_ids: options?.attachmentIds
+    };
+    if (options?.delegatedToken !== void 0) {
+      body.delegated_token = options.delegatedToken;
+    }
+    const data = await this._post(
+      "/task/vsa/message",
+      body
+    );
     return { message: data.message ?? "" };
   }
   async renameVSATask(taskId, title) {
-    const data = await this._post(`/tasks/${taskId}/vsa/rename`, {
+    const data = await this._post("/task/vsa/rename", {
+      task_id: taskId,
       title
     });
     return { message: data.message ?? "" };
   }
   async regenerateVSATitle(taskId) {
-    const data = await this._post(`/tasks/${taskId}/vsa/regenerate-title`);
+    const data = await this._post(
+      "/task/vsa/regenerate_title",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markVSAComplete(taskId) {
-    const data = await this._post(`/tasks/${taskId}/vsa/complete`);
+    const data = await this._post(
+      "/task/vsa/mark_complete",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markVSAFailed(taskId) {
-    const data = await this._post(`/tasks/${taskId}/vsa/failed`);
+    const data = await this._post(
+      "/task/vsa/mark_failed",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async stopVSA(taskId) {
-    const data = await this._post(`/tasks/${taskId}/vsa/stop`);
+    const data = await this._post("/task/vsa/stop", {
+      task_id: taskId
+    });
     return { message: data.message ?? "" };
   }
   async deleteVSA(taskId) {
-    const data = await this._delete(`/tasks/${taskId}/vsa`);
+    const data = await this._post("/task/vsa/delete", {
+      task_id: taskId
+    });
     return { message: data.message ?? "" };
   }
-  async listVSATasks(params) {
-    const data = await this._get("/tasks/vsa", {
-      status: params?.status,
+  async listVSATasks(userId, params) {
+    const data = await this._get("/task/vsa/list", {
+      user_id: userId,
       limit: params?.limit,
       offset: params?.offset
     });
-    const tasks = (data.tasks ?? []).map(buildTaskSummary);
+    const tasks = (data.tasks ?? []).map(
+      buildTaskSummary
+    );
     return { tasks, pagination: buildPagination(data) };
   }
-  async searchVSATasks(query) {
-    const data = await this._get("/tasks/vsa/search", { q: query });
-    const tasks = (data.tasks ?? []).map(buildTaskSummary);
+  async searchVSATasks(userId, query, limit) {
+    const data = await this._get("/task/vsa/search", {
+      user_id: userId,
+      query,
+      limit
+    });
+    const tasks = (data.tasks ?? []).map(
+      buildTaskSummary
+    );
     return { tasks, pagination: buildPagination(data) };
   }
   async deleteVSATasksBulk(taskIds) {
-    const data = await this._post("/tasks/vsa/delete-bulk", {
-      task_ids: taskIds
-    });
-    return { message: data.message ?? "" };
+    const data = await this._post(
+      "/task/vsa/delete_bulk",
+      { task_ids: taskIds }
+    );
+    return {
+      deletedTasks: data.deletedTasks ?? data.deleted_tasks ?? [],
+      failedTasks: data.failedTasks ?? data.failed_tasks ?? [],
+      totalDeleted: data.totalDeleted ?? data.total_deleted ?? 0,
+      totalFailed: data.totalFailed ?? data.total_failed ?? 0
+    };
   }
   // ------------------------------------------------------------------
-  // MIO workflow
+  // MIO (self_managed) workflow
   // ------------------------------------------------------------------
-  async sendMioMessage(taskId, content) {
-    const data = await this._post(`/tasks/${taskId}/mio/message`, {
-      content
-    });
+  async sendMioMessage(taskId, message, attachmentIds) {
+    const data = await this._post(
+      "/task/self_managed/message",
+      { task_id: taskId, message, attachment_ids: attachmentIds }
+    );
     return { message: data.message ?? "" };
   }
-  async approveMioAction(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/approve`);
+  async approveMioAction(taskId, approved = true, feedback) {
+    const data = await this._post(
+      "/task/self_managed/action",
+      { task_id: taskId, approved, feedback }
+    );
     return { message: data.message ?? "" };
   }
   async wakeMio(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/wake`);
+    const data = await this._post(
+      "/task/self_managed/wake",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async sendMioUserAway(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/user-away`);
+    const data = await this._post(
+      "/task/self_managed/user_away",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markMioComplete(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/complete`);
+    const data = await this._post(
+      "/task/self_managed/mark_complete",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async markMioFailed(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/failed`);
+    const data = await this._post(
+      "/task/self_managed/mark_failed",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async archiveMio(taskId) {
-    const data = await this._post(`/tasks/${taskId}/mio/archive`);
+    const data = await this._post(
+      "/task/self_managed/archive",
+      { task_id: taskId }
+    );
     return { message: data.message ?? "" };
   }
   async getMioContext(taskId) {
-    const data = await this._get(`/tasks/${taskId}/mio/context`);
+    const data = await this._get(
+      "/task/self_managed/context",
+      { task_id: taskId }
+    );
     return {
       taskId: data.taskId ?? data.task_id ?? taskId,
+      modelId: data.modelId ?? data.model_id ?? "",
       currentTokens: data.currentTokens ?? data.current_tokens ?? 0,
       contextLimit: data.contextLimit ?? data.context_limit ?? 0,
       usagePercentage: data.usagePercentage ?? data.usage_percentage ?? 0,
-      archivedCount: data.archivedCount ?? data.archived_count ?? 0,
-      activeCount: data.activeCount ?? data.active_count ?? 0
+      totalMessages: data.totalMessages ?? data.total_messages ?? 0,
+      activeMessages: data.activeMessages ?? data.active_messages ?? 0,
+      archivedMessages: data.archivedMessages ?? data.archived_messages ?? 0,
+      messagesWithoutTokenCount: data.messagesWithoutTokenCount ?? data.messages_without_token_count ?? 0
+    };
+  }
+  async getMioMemories(taskId, includeCommon) {
+    const data = await this._get(
+      "/task/self_managed/memories",
+      { task_id: taskId, include_common: includeCommon }
+    );
+    return {
+      memories: data.memories ?? [],
+      total: data.total ?? 0
     };
   }
   // ------------------------------------------------------------------
   // Tools
   // ------------------------------------------------------------------
   async listTools() {
-    const data = await this._get("/tools");
+    const data = await this._get("/tools/all");
     return {
-      tools: (data.tools ?? data.tools ?? []).map(
+      tools: (data.tools ?? []).map(
         (t) => t
       ),
       totalTools: data.totalTools ?? data.total_tools ?? 0,
       servers: data.servers ?? []
     };
   }
+  async getToolCatalog() {
+    return this._get("/tools/catalog");
+  }
+  async refreshMCPTools() {
+    return this._post("/tools/mcp/refresh");
+  }
+  async validateToolCatalog() {
+    return this._get("/tools/validate");
+  }
   // ------------------------------------------------------------------
   // Debug / Admin
   // ------------------------------------------------------------------
   async getWorkflowStates() {
-    const data = await this._get("/debug/workflow-states");
+    const data = await this._get(
+      "/debug/workflow_states"
+    );
     return {
       validStates: data.validStates ?? data.valid_states ?? {},
       processableStates: data.processableStates ?? data.processable_states ?? {},
@@ -672,79 +868,116 @@ var OrchestratorAsync = class {
     };
   }
   async updateTaskModels(taskId, models) {
-    const data = await this._post(`/tasks/${taskId}/models`, {
-      agent: models.agent,
-      orchestrator: models.orchestrator
-    });
+    const data = await this._post(
+      "/debug/task/models",
+      {
+        task_id: taskId,
+        agent_model_id: models.agentModelId,
+        orchestrator_model_id: models.orchestratorModelId
+      }
+    );
     return { message: data.message ?? "" };
   }
-  async updateTaskIteration(taskId, iteration) {
-    const data = await this._post(`/tasks/${taskId}/iteration`, {
-      iteration
-    });
+  async updateTaskIteration(taskId, iteration, maxIterations) {
+    const data = await this._post(
+      "/debug/task/iteration",
+      { task_id: taskId, iteration, max_iterations: maxIterations }
+    );
     return { message: data.message ?? "" };
   }
   async updateTaskWorkflowData(taskId, workflowData) {
-    const data = await this._post(`/tasks/${taskId}/workflow-data`, {
-      workflow_data: workflowData
-    });
+    const data = await this._post(
+      "/debug/task/workflow_data",
+      { task_id: taskId, workflow_data: workflowData }
+    );
     return { message: data.message ?? "" };
   }
   async deleteMessage(taskId, messageId) {
-    const data = await this._delete(
-      `/tasks/${taskId}/conversation/messages/${messageId}`
+    const data = await this._post(
+      "/debug/task/message/delete",
+      { task_id: taskId, message_id: messageId }
     );
     return { message: data.message ?? "" };
   }
   async deleteMessages(taskId, messageIds) {
     const data = await this._post(
-      `/tasks/${taskId}/conversation/messages/delete`,
-      { message_ids: messageIds }
+      "/debug/task/message/delete/multiple",
+      { task_id: taskId, message_ids: messageIds }
     );
-    return { message: data.message ?? "" };
+    return {
+      deletedIds: data.deletedIds ?? data.deleted_ids ?? [],
+      failedIds: data.failedIds ?? data.failed_ids ?? [],
+      totalDeleted: data.totalDeleted ?? data.total_deleted ?? 0,
+      totalFailed: data.totalFailed ?? data.total_failed ?? 0
+    };
   }
   async updateMessage(taskId, messageId, update) {
-    const data = await this._put(
-      `/tasks/${taskId}/conversation/messages/${messageId}`,
-      update
+    const data = await this._post(
+      "/debug/task/message/update",
+      { task_id: taskId, message_id: messageId, ...update }
     );
     return { message: data.message ?? "" };
   }
   async resetMatrixToPhase(taskId, phase) {
     const data = await this._post(
-      `/tasks/${taskId}/matrix/reset`,
-      { phase }
+      "/debug/task/matrix/reset_to_phase",
+      { task_id: taskId, phase }
     );
     return { message: data.message ?? "" };
   }
-  async getMessageTranslations(taskId, messageId, locale) {
-    const params = {};
-    if (locale) params.locale = locale;
+  async getMessageTranslations(taskId, messageId) {
     const data = await this._get(
-      `/tasks/${taskId}/conversation/messages/${messageId}/translations`,
-      params
+      `/debug/task/${taskId}/message/${messageId}/translations`
     );
     return {
       messageId: data.messageId ?? data.message_id ?? messageId,
-      translations: (data.translations ?? []).map(
-        (t) => t
-      )
+      translations: (data.translations ?? []).map((t) => t)
     };
   }
   // ------------------------------------------------------------------
   // Error events
   // ------------------------------------------------------------------
   async listErrors(params) {
-    const queryParams = {};
-    if (params?.since) queryParams.since = params.since;
-    if (params?.severity) queryParams.severity = params.severity;
-    if (params?.source) queryParams.source = params.source;
-    if (params?.limit) queryParams.limit = params.limit;
-    if (params?.offset) queryParams.offset = params.offset;
-    const data = await this._get("/errors", queryParams);
-    return (data.errors ?? []).map(
-      (e) => e
-    );
+    const authHeaders = await this._resolveHeaders();
+    const url = new URL(this._makeUrl("/errors"));
+    if (params?.page !== void 0)
+      url.searchParams.set("page", String(params.page));
+    if (params?.limit !== void 0)
+      url.searchParams.set("limit", String(params.limit));
+    if (params?.taskId) url.searchParams.set("task_id", params.taskId);
+    if (params?.workflowId)
+      url.searchParams.set("workflow_id", params.workflowId);
+    if (params?.errorCode) url.searchParams.set("error_code", params.errorCode);
+    if (params?.exceptionType)
+      url.searchParams.set("exception_type", params.exceptionType);
+    if (params?.holderId) url.searchParams.set("holder_id", params.holderId);
+    if (params?.requestId) url.searchParams.set("request_id", params.requestId);
+    if (params?.search) url.searchParams.set("search", params.search);
+    if (params?.since) url.searchParams.set("since", params.since);
+    if (params?.until) url.searchParams.set("until", params.until);
+    if (params?.orderDirection)
+      url.searchParams.set("order_direction", params.orderDirection);
+    for (const s of params?.severity ?? []) {
+      url.searchParams.append("severity", s);
+    }
+    for (const s of params?.source ?? []) {
+      url.searchParams.append("source", s);
+    }
+    const response = await this._fetch(url.toString(), {
+      method: "GET",
+      headers: { ...authHeaders }
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `listErrors failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return {
+      items: (data.items ?? data.errors ?? []).map((e) => e),
+      pagination: buildPagination(data)
+    };
   }
   async getErrorDetail(errorId) {
     return this._get(`/errors/${errorId}`);
@@ -769,13 +1002,13 @@ var OrchestratorAsync = class {
     return this._get("/health");
   }
   async healthDetailed() {
-    return this._get("/health/detail");
+    return this._get("/health/detailed");
   }
   async ready() {
     return this._get("/ready");
   }
   async healthLeader() {
-    return this._get("/leader");
+    return this._get("/health/leader");
   }
   async getMetrics(types) {
     const params = {};
@@ -786,82 +1019,122 @@ var OrchestratorAsync = class {
   // Configuration
   // ------------------------------------------------------------------
   async getSystemStatus() {
-    return this._get("/config/status");
+    return this._get("/configuration/system/status");
   }
   async updateSettings(settings) {
-    return this._post("/config/settings", settings);
+    return this._post("/configuration/system/settings", settings);
   }
   async getConfigurationStatus() {
-    return this._get("/config");
+    return this._get("/configuration/status");
   }
   async setAgentModel(model) {
-    const data = await this._post("/config/models/agent", { model });
+    const data = await this._post(
+      "/configuration/agent",
+      { model_name: model }
+    );
     return { message: data.message ?? "" };
   }
   async setOrchestratorModel(model) {
-    const data = await this._post("/config/models/orchestrator", { model });
+    const data = await this._post(
+      "/configuration/orchestrator",
+      { model_name: model }
+    );
     return { message: data.message ?? "" };
   }
   async getLLMBackendStatus() {
-    return this._get("/config/llmbackends");
+    return this._get(
+      "/configuration/llmbackend/status"
+    );
   }
   async addLLMBackend(host, apiKey) {
-    const data = await this._post("/config/llmbackends", {
-      host,
-      api_key: apiKey
-    });
+    const data = await this._post(
+      "/configuration/llmbackend/add",
+      { backends: [{ url: host, api_key: apiKey }] }
+    );
     return { message: data.message ?? "" };
   }
   async removeLLMBackend(host) {
-    const data = await this._delete(`/config/llmbackends/${encodeURIComponent(host)}`);
+    const data = await this._post(
+      "/configuration/llmbackend/remove",
+      { host }
+    );
     return { message: data.message ?? "" };
   }
   async getMCPServerStatus() {
-    return this._get("/config/mcpservers");
+    return this._get(
+      "/configuration/mcpserver/status"
+    );
   }
   async addMCPServer(host, apiKey) {
-    const data = await this._post("/config/mcpservers", {
-      host,
-      api_key: apiKey
-    });
+    const data = await this._post(
+      "/configuration/mcpserver/add",
+      { servers: [{ url: host, api_key: apiKey }] }
+    );
     return { message: data.message ?? "" };
   }
   async removeMCPServer(host) {
-    const data = await this._delete(`/config/mcpservers/${encodeURIComponent(host)}`);
+    const data = await this._post(
+      "/configuration/mcpserver/remove",
+      { host }
+    );
     return { message: data.message ?? "" };
   }
   async getTaskHandlerStatus() {
-    return this._get("/config/taskhandler");
+    return this._get("/configuration/taskhandler/status");
   }
   async getTaskHandlerStatusLocal() {
-    return this._get("/config/taskhandler/local");
+    return this._get(
+      "/configuration/taskhandler/status/local"
+    );
   }
   async setConcurrentTasksPerReplica(maxTasks) {
-    const data = await this._post("/config/taskhandler/concurrency", {
-      max_tasks: maxTasks
-    });
+    const data = await this._request(
+      "POST",
+      "/configuration/taskhandler/concurrent-per-replica",
+      { params: { max_tasks: maxTasks } }
+    );
     return { message: data.message ?? "" };
   }
   async getSummaryWorkerStatus() {
-    return this._get("/config/summary-worker");
+    return this._get(
+      "/configuration/summary-worker/status"
+    );
   }
   async setCompactorModel(modelName) {
-    const data = await this._post("/config/models/compactor", {
-      model_name: modelName
-    });
+    const data = await this._post(
+      "/configuration/summary-worker/model",
+      { model_name: modelName }
+    );
     return { message: data.message ?? "" };
   }
   async setTranslateModel(modelName) {
-    const data = await this._post("/config/models/translate", {
-      model_name: modelName
-    });
+    const data = await this._post(
+      "/configuration/summary-worker/translate-model",
+      { model_name: modelName }
+    );
     return { message: data.message ?? "" };
   }
   async getTokenWorkerStatus() {
-    return this._get("/config/token-worker");
+    return this._get("/configuration/token-worker/status");
   }
   async getSlotsStatus() {
-    return this._get("/config/slots");
+    return this._get("/configuration/slots/status");
+  }
+  async getSubagentsStatus() {
+    return this._get("/configuration/subagents/status");
+  }
+  async setSubagentsEnabled(enabled) {
+    const data = await this._post(
+      "/configuration/subagents",
+      { enabled }
+    );
+    return { message: data.message ?? "" };
+  }
+  async reloadServices() {
+    return this._post("/configuration/reload");
+  }
+  async getReloadStatus() {
+    return this._get("/configuration/reload/status");
   }
   // ------------------------------------------------------------------
   // Auth / WebSocket status
@@ -877,10 +1150,13 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   async *streamTaskStatus(taskId) {
     const headers = await this._resolveHeaders();
-    headers["Accept"] = "text/event-stream";
-    const response = await this._fetch(this._makeUrl(`/tasks/${taskId}/stream`), {
-      headers
-    });
+    headers.Accept = "text/event-stream";
+    const response = await this._fetch(
+      this._makeUrl(
+        `/task/stream_status?task_id=${encodeURIComponent(taskId)}`
+      ),
+      { headers }
+    );
     if (!response.ok) {
       throw new OrchestratorAPIError(
         `Stream connection failed: ${response.statusText}`,
@@ -920,7 +1196,9 @@ function combineSignals(...signals) {
       controller.abort(signal.reason);
       return controller.signal;
     }
-    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+    signal.addEventListener("abort", () => controller.abort(signal.reason), {
+      once: true
+    });
   }
   return controller.signal;
 }
@@ -944,11 +1222,14 @@ var Orchestrator = class {
   createTask(params) {
     return runSync(this._async.createTask(params));
   }
-  getTaskStatus(taskId) {
-    return runSync(this._async.getTaskStatus(taskId));
+  getTaskStatus(taskId, locale) {
+    return runSync(this._async.getTaskStatus(taskId, locale));
   }
-  getTaskConversation(taskId) {
-    return runSync(this._async.getTaskConversation(taskId));
+  setTaskStatus(taskId, status) {
+    return runSync(this._async.setTaskStatus(taskId, status));
+  }
+  getTaskConversation(taskId, params) {
+    return runSync(this._async.getTaskConversation(taskId, params));
   }
   getArchivedMessageContent(taskId, messageId) {
     return runSync(this._async.getArchivedMessageContent(taskId, messageId));
@@ -971,17 +1252,19 @@ var Orchestrator = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  uploadAttachment(taskId, file, filename) {
-    return runSync(this._async.uploadAttachment(taskId, file, filename));
+  uploadAttachment(file, filename) {
+    return runSync(this._async.uploadAttachment(file, filename));
   }
-  downloadAttachment(taskId, attachmentId) {
-    return runSync(this._async.downloadAttachment(taskId, attachmentId));
+  downloadAttachment(attachmentId) {
+    return runSync(this._async.downloadAttachment(attachmentId));
   }
   // ------------------------------------------------------------------
   // Interactive workflow
   // ------------------------------------------------------------------
-  sendInteractiveMessage(taskId, content) {
-    return runSync(this._async.sendInteractiveMessage(taskId, content));
+  sendInteractiveMessage(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendInteractiveMessage(taskId, message, attachmentIds)
+    );
   }
   markInteractiveComplete(taskId) {
     return runSync(this._async.markInteractiveComplete(taskId));
@@ -989,32 +1272,37 @@ var Orchestrator = class {
   markInteractiveFailed(taskId) {
     return runSync(this._async.markInteractiveFailed(taskId));
   }
-  approveInteractiveAction(taskId) {
-    return runSync(this._async.approveInteractiveAction(taskId));
+  approveInteractiveAction(taskId, approved = true) {
+    return runSync(this._async.approveInteractiveAction(taskId, approved));
+  }
+  stopInteractive(taskId) {
+    return runSync(this._async.stopInteractive(taskId));
   }
   // ------------------------------------------------------------------
   // Proactive workflow
   // ------------------------------------------------------------------
-  sendProactiveGuide(taskId, guide) {
-    return runSync(this._async.sendProactiveGuide(taskId, guide));
+  sendProactiveGuide(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendProactiveGuide(taskId, message, attachmentIds)
+    );
   }
   respondProactiveHelp(taskId, response) {
     return runSync(this._async.respondProactiveHelp(taskId, response));
   }
-  approveProactiveAction(taskId) {
-    return runSync(this._async.approveProactiveAction(taskId));
+  approveProactiveAction(taskId, approved = true) {
+    return runSync(this._async.approveProactiveAction(taskId, approved));
   }
   // ------------------------------------------------------------------
   // Ticket workflow
   // ------------------------------------------------------------------
-  sendTicketGuide(taskId, guide) {
-    return runSync(this._async.sendTicketGuide(taskId, guide));
+  sendTicketGuide(taskId, message, attachmentIds) {
+    return runSync(this._async.sendTicketGuide(taskId, message, attachmentIds));
   }
   respondTicketHelp(taskId, response) {
     return runSync(this._async.respondTicketHelp(taskId, response));
   }
-  approveTicketAction(taskId) {
-    return runSync(this._async.approveTicketAction(taskId));
+  approveTicketAction(taskId, approved = true) {
+    return runSync(this._async.approveTicketAction(taskId, approved));
   }
   wakeTicket(taskId) {
     return runSync(this._async.wakeTicket(taskId));
@@ -1022,8 +1310,10 @@ var Orchestrator = class {
   // ------------------------------------------------------------------
   // Matrix workflow
   // ------------------------------------------------------------------
-  sendMatrixMessage(taskId, content) {
-    return runSync(this._async.sendMatrixMessage(taskId, content));
+  sendMatrixMessage(taskId, message, attachmentIds) {
+    return runSync(
+      this._async.sendMatrixMessage(taskId, message, attachmentIds)
+    );
   }
   markMatrixComplete(taskId) {
     return runSync(this._async.markMatrixComplete(taskId));
@@ -1031,11 +1321,13 @@ var Orchestrator = class {
   markMatrixFailed(taskId) {
     return runSync(this._async.markMatrixFailed(taskId));
   }
-  approveMatrixAction(taskId) {
-    return runSync(this._async.approveMatrixAction(taskId));
+  approveMatrixAction(taskId, approved = true) {
+    return runSync(this._async.approveMatrixAction(taskId, approved));
   }
-  getMatrixConversation(taskId) {
-    return runSync(this._async.getMatrixConversation(taskId));
+  getMatrixConversation(taskId, phase, includeSummaries) {
+    return runSync(
+      this._async.getMatrixConversation(taskId, phase, includeSummaries)
+    );
   }
   // ------------------------------------------------------------------
   // VSA workflow
@@ -1043,8 +1335,8 @@ var Orchestrator = class {
   createVSATask(params) {
     return runSync(this._async.createVSATask(params));
   }
-  sendVSAMessage(taskId, content) {
-    return runSync(this._async.sendVSAMessage(taskId, content));
+  sendVSAMessage(taskId, message, options) {
+    return runSync(this._async.sendVSAMessage(taskId, message, options));
   }
   renameVSATask(taskId, title) {
     return runSync(this._async.renameVSATask(taskId, title));
@@ -1064,23 +1356,23 @@ var Orchestrator = class {
   deleteVSA(taskId) {
     return runSync(this._async.deleteVSA(taskId));
   }
-  listVSATasks(params) {
-    return runSync(this._async.listVSATasks(params));
+  listVSATasks(userId, params) {
+    return runSync(this._async.listVSATasks(userId, params));
   }
-  searchVSATasks(query) {
-    return runSync(this._async.searchVSATasks(query));
+  searchVSATasks(userId, query, limit) {
+    return runSync(this._async.searchVSATasks(userId, query, limit));
   }
   deleteVSATasksBulk(taskIds) {
     return runSync(this._async.deleteVSATasksBulk(taskIds));
   }
   // ------------------------------------------------------------------
-  // MIO workflow
+  // MIO (self_managed) workflow
   // ------------------------------------------------------------------
-  sendMioMessage(taskId, content) {
-    return runSync(this._async.sendMioMessage(taskId, content));
+  sendMioMessage(taskId, message, attachmentIds) {
+    return runSync(this._async.sendMioMessage(taskId, message, attachmentIds));
   }
-  approveMioAction(taskId) {
-    return runSync(this._async.approveMioAction(taskId));
+  approveMioAction(taskId, approved = true, feedback) {
+    return runSync(this._async.approveMioAction(taskId, approved, feedback));
   }
   wakeMio(taskId) {
     return runSync(this._async.wakeMio(taskId));
@@ -1100,12 +1392,24 @@ var Orchestrator = class {
   getMioContext(taskId) {
     return runSync(this._async.getMioContext(taskId));
   }
+  getMioMemories(taskId, includeCommon) {
+    return runSync(this._async.getMioMemories(taskId, includeCommon));
+  }
   // ------------------------------------------------------------------
   // Tools
   // ------------------------------------------------------------------
   listTools() {
     return runSync(this._async.listTools());
   }
+  getToolCatalog() {
+    return runSync(this._async.getToolCatalog());
+  }
+  refreshMCPTools() {
+    return runSync(this._async.refreshMCPTools());
+  }
+  validateToolCatalog() {
+    return runSync(this._async.validateToolCatalog());
+  }
   // ------------------------------------------------------------------
   // Debug / Admin
   // ------------------------------------------------------------------
@@ -1115,8 +1419,10 @@ var Orchestrator = class {
   updateTaskModels(taskId, models) {
     return runSync(this._async.updateTaskModels(taskId, models));
   }
-  updateTaskIteration(taskId, iteration) {
-    return runSync(this._async.updateTaskIteration(taskId, iteration));
+  updateTaskIteration(taskId, iteration, maxIterations) {
+    return runSync(
+      this._async.updateTaskIteration(taskId, iteration, maxIterations)
+    );
   }
   updateTaskWorkflowData(taskId, workflowData) {
     return runSync(this._async.updateTaskWorkflowData(taskId, workflowData));
@@ -1133,8 +1439,8 @@ var Orchestrator = class {
   resetMatrixToPhase(taskId, phase) {
     return runSync(this._async.resetMatrixToPhase(taskId, phase));
   }
-  getMessageTranslations(taskId, messageId, locale) {
-    return runSync(this._async.getMessageTranslations(taskId, messageId, locale));
+  getMessageTranslations(taskId, messageId) {
+    return runSync(this._async.getMessageTranslations(taskId, messageId));
   }
   // ------------------------------------------------------------------
   // Error events
@@ -1232,6 +1538,18 @@ var Orchestrator = class {
   getSlotsStatus() {
     return runSync(this._async.getSlotsStatus());
   }
+  getSubagentsStatus() {
+    return runSync(this._async.getSubagentsStatus());
+  }
+  setSubagentsEnabled(enabled) {
+    return runSync(this._async.setSubagentsEnabled(enabled));
+  }
+  reloadServices() {
+    return runSync(this._async.reloadServices());
+  }
+  getReloadStatus() {
+    return runSync(this._async.getReloadStatus());
+  }
   // ------------------------------------------------------------------
   // Auth / WebSocket status
   // ------------------------------------------------------------------
@@ -1403,11 +1721,15 @@ var RealtimeClient = class {
     this._socket.on("disconnect", () => {
       this._connected = false;
     });
+    this._socket.on("message", (payload) => this._dispatch(payload));
     return new Promise((resolve, reject) => {
-      const socket = this._socket;
-      socket.on("connect", () => resolve());
-      socket.on("connect_error", (err) => reject(err));
-      if (socket.connected) {
+      if (!this._socket) {
+        reject(new Error("RealtimeClient not connected"));
+        return;
+      }
+      this._socket.on("connect", () => resolve());
+      this._socket.on("connect_error", (err) => reject(err));
+      if (this._socket.connected) {
         resolve();
       }
     });
@@ -1419,48 +1741,132 @@ var RealtimeClient = class {
     }
     this._connected = false;
   }
+  /**
+   * Dispatch a message envelope to registered handlers.
+   * The server sends: socket.emit("message", {type: "message", event: {..., event_type: "...", ...}})
+   */
+  _dispatch(payload) {
+    const envelope = payload;
+    const event = envelope.event ?? envelope;
+    const eventType = event.event_type;
+    if (!eventType) return;
+    const handlers = this._handlers.get(eventType);
+    if (handlers) {
+      for (const h of handlers) {
+        h(event);
+      }
+    }
+  }
   /**
    * Subscribe to realtime events for a specific task.
+   * Emits a `join` event with `{rooms: ["task:{taskId}"]}`.
    */
-  async subscribeTask(taskId) {
+  subscribeTask(taskId) {
     if (!this._socket) throw new Error("RealtimeClient not connected");
-    return new Promise((resolve, reject) => {
-      this._socket.emit("subscribe", { task_id: taskId }, (response) => {
-        if (response.ok) resolve();
-        else reject(new Error(response.error ?? "Subscription failed"));
-      });
-    });
+    this._socket.emit("join", { rooms: [`task:${taskId}`] });
   }
   /**
    * Unsubscribe from realtime events for a specific task.
+   * Emits a `leave` event with `{rooms: ["task:{taskId}"]}`.
    */
-  async unsubscribeTask(taskId) {
+  unsubscribeTask(taskId) {
     if (!this._socket) throw new Error("RealtimeClient not connected");
-    return new Promise((resolve, reject) => {
-      this._socket.emit("unsubscribe", { task_id: taskId }, (response) => {
-        if (response.ok) resolve();
-        else reject(new Error(response.error ?? "Unsubscription failed"));
-      });
-    });
+    this._socket.emit("leave", { rooms: [`task:${taskId}`] });
+  }
+  /**
+   * Subscribe to event-type-scoped rooms.
+   * e.g. subscribeEvents("task_created", "task_deleted")
+   */
+  subscribeEvents(...eventTypes) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    const rooms = eventTypes.map((t) => `event:${t}`);
+    this._socket.emit("join", { rooms });
+  }
+  /**
+   * Unsubscribe from event-type-scoped rooms.
+   */
+  unsubscribeEvents(...eventTypes) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    const rooms = eventTypes.map((t) => `event:${t}`);
+    this._socket.emit("leave", { rooms });
+  }
+  /**
+   * Subscribe to the `all` broadcast room (receives all events).
+   */
+  subscribeAll() {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms: ["all"] });
+  }
+  /**
+   * Subscribe to a locale-specific room.
+   */
+  subscribeLocale(locale) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms: [`locale:${locale}`] });
+  }
+  /**
+   * Unsubscribe from a locale-specific room.
+   */
+  unsubscribeLocale(locale) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("leave", { rooms: [`locale:${locale}`] });
+  }
+  /**
+   * Join arbitrary rooms by name.
+   */
+  joinRooms(rooms) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("join", { rooms });
+  }
+  /**
+   * Leave arbitrary rooms by name.
+   */
+  leaveRooms(rooms) {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("leave", { rooms });
+  }
+  /**
+   * Send a ping to the server.
+   */
+  ping() {
+    if (!this._socket) throw new Error("RealtimeClient not connected");
+    this._socket.emit("ping");
   }
   /**
    * Register a handler for a specific event type.
+   *
+   * Domain events (task_created, task_status_changed, etc.) are dispatched
+   * via the message envelope. Raw socket events (connect, disconnect,
+   * connection_established, rooms_updated, pong) are wired directly.
    */
   on(event, handler) {
     if (!this._handlers.has(event)) {
       this._handlers.set(event, /* @__PURE__ */ new Set());
       if (this._socket) {
-        this._socket.on(event, (...args) => {
-          const handlers = this._handlers.get(event);
-          if (handlers) {
-            for (const h of handlers) {
-              h(...args);
+        const rawSocketEvents = /* @__PURE__ */ new Set([
+          "connect",
+          "disconnect",
+          "connect_error",
+          "connection_established",
+          "rooms_updated",
+          "pong"
+        ]);
+        if (rawSocketEvents.has(event)) {
+          this._socket.on(event, (...args) => {
+            const handlers2 = this._handlers.get(event);
+            if (handlers2) {
+              for (const h of handlers2) {
+                h(...args);
+              }
             }
-          }
-        });
+          });
+        }
       }
     }
-    this._handlers.get(event).add(handler);
+    const handlers = this._handlers.get(event);
+    if (handlers) {
+      handlers.add(handler);
+    }
   }
   /**
    * Remove a registered handler.
@@ -1482,12 +1888,11 @@ var RealtimeClient = class {
    */
   wait() {
     return new Promise((resolve) => {
-      const socket = this._socket;
-      if (!socket) {
+      if (!this._socket) {
         resolve();
         return;
       }
-      socket.on("disconnect", () => resolve());
+      this._socket.on("disconnect", () => resolve());
     });
   }
 };