orchestrator-client 5.6.0

package/dist/index.cjs

@@ -0,0 +1,1523 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EVENT_ERROR_EVENT_RECORDED: () => EVENT_ERROR_EVENT_RECORDED,
+  EVENT_MESSAGE_ADDED: () => EVENT_MESSAGE_ADDED,
+  EVENT_MESSAGE_STREAMING: () => EVENT_MESSAGE_STREAMING,
+  EVENT_MESSAGE_SUMMARY_GENERATED: () => EVENT_MESSAGE_SUMMARY_GENERATED,
+  EVENT_MESSAGE_TRANSLATION_READY: () => EVENT_MESSAGE_TRANSLATION_READY,
+  EVENT_TASK_CREATED: () => EVENT_TASK_CREATED,
+  EVENT_TASK_DELETED: () => EVENT_TASK_DELETED,
+  EVENT_TASK_INSIGHT_UPDATED: () => EVENT_TASK_INSIGHT_UPDATED,
+  EVENT_TASK_ITERATION_CHANGED: () => EVENT_TASK_ITERATION_CHANGED,
+  EVENT_TASK_RESULT_UPDATED: () => EVENT_TASK_RESULT_UPDATED,
+  EVENT_TASK_STATUS_CHANGED: () => EVENT_TASK_STATUS_CHANGED,
+  Orchestrator: () => Orchestrator,
+  OrchestratorAPIError: () => OrchestratorAPIError,
+  OrchestratorAsync: () => OrchestratorAsync,
+  OrchestratorAuthError: () => OrchestratorAuthError,
+  OrchestratorConfigError: () => OrchestratorConfigError,
+  OrchestratorConnectionError: () => OrchestratorConnectionError,
+  OrchestratorError: () => OrchestratorError,
+  OrchestratorNotFoundError: () => OrchestratorNotFoundError,
+  RealtimeClient: () => RealtimeClient,
+  VERSION: () => VERSION,
+  createInsecureFetch: () => createInsecureFetch,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var OrchestratorError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "OrchestratorError";
+    this.statusCode = opts?.statusCode ?? null;
+    this.errorCode = opts?.errorCode ?? null;
+    this.details = opts?.details ?? {};
+  }
+};
+var OrchestratorConnectionError = class extends OrchestratorError {
+  constructor(message) {
+    super(message, { statusCode: null });
+    this.name = "OrchestratorConnectionError";
+  }
+};
+var OrchestratorAuthError = class extends OrchestratorError {
+  constructor(message, statusCode = 401) {
+    super(message, { statusCode });
+    this.name = "OrchestratorAuthError";
+  }
+};
+var OrchestratorNotFoundError = class extends OrchestratorError {
+  constructor(resourceType, resourceId, message) {
+    super(message ?? `${resourceType} not found: ${resourceId}`, {
+      statusCode: 404
+    });
+    this.name = "OrchestratorNotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var OrchestratorAPIError = class extends OrchestratorError {
+  constructor(message, statusCode, errorCode, details) {
+    super(message, { statusCode, errorCode, details });
+    this.name = "OrchestratorAPIError";
+  }
+};
+var OrchestratorConfigError = class extends OrchestratorError {
+  constructor(message) {
+    super(message, { statusCode: null });
+    this.name = "OrchestratorConfigError";
+  }
+};
+
+// src/client.ts
+var RETRY_BACKOFF_BASE = 500;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+function buildPagination(data) {
+  const p = data.pagination ?? {};
+  return {
+    currentPage: p.currentPage ?? 1,
+    perPage: p.perPage ?? 25,
+    totalItems: p.totalItems ?? 0,
+    totalPages: p.totalPages ?? 1,
+    hasNext: p.hasNext ?? false,
+    hasPrev: p.hasPrev ?? false
+  };
+}
+function buildTaskSummary(t) {
+  return {
+    id: t.id ?? "",
+    status: t.status ?? "",
+    workflowId: t.workflowId ?? t.workflow_id ?? "",
+    iteration: t.iteration ?? 0,
+    maxIterations: t.maxIterations ?? t.max_iterations ?? 0,
+    goalPrompt: t.goalPrompt ?? t.goal_prompt ?? "",
+    result: t.result ?? "",
+    resultLocalized: t.resultLocalized ?? t.result_localized ?? null,
+    approvalReason: t.approvalReason ?? t.approval_reason ?? "",
+    ticketId: t.ticketId ?? t.ticket_id ?? null,
+    availableTools: t.availableTools ?? t.available_tools ?? null,
+    insight: t.insight ?? null,
+    insightLocalized: t.insightLocalized ?? t.insight_localized ?? null,
+    createdAt: t.createdAt ?? t.created_at ?? "",
+    updatedAt: t.updatedAt ?? t.updated_at ?? "",
+    pendingTranslationsForLocales: t.pendingTranslationsForLocales ?? t.pending_translations_for_locales ?? null
+  };
+}
+var OrchestratorAsync = class {
+  constructor(opts = {}) {
+    this._abortController = null;
+    this._insecure = false;
+    this._baseUrl = (opts.baseUrl ?? "http://localhost:8080").replace(/\/+$/, "");
+    this._apiKey = opts.apiKey;
+    this._getToken = opts.getToken;
+    this._timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this._maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this._fetch = opts.fetch ?? globalThis.fetch;
+    if (opts.insecure && !opts.fetch && typeof process !== "undefined" && process.versions?.node) {
+      this._insecure = true;
+    }
+  }
+  async close() {
+    this._abortController?.abort();
+  }
+  // ------------------------------------------------------------------
+  // Internal helpers
+  // ------------------------------------------------------------------
+  _makeUrl(path) {
+    return `${this._baseUrl}${path}`;
+  }
+  async _resolveHeaders() {
+    const headers = {};
+    if (this._apiKey) {
+      headers["Authorization"] = `Bearer ${this._apiKey}`;
+    } else if (this._getToken) {
+      const token = await this._getToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    return headers;
+  }
+  async _request(method, path, opts) {
+    const url = new URL(this._makeUrl(path));
+    if (opts?.params) {
+      for (const [key, value] of Object.entries(opts.params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const extraHeaders = await this._resolveHeaders();
+    const mergedHeaders = {
+      ...extraHeaders,
+      ...opts?.headers ?? {}
+    };
+    if (opts?.jsonBody !== void 0 && !mergedHeaders["Content-Type"]) {
+      mergedHeaders["Content-Type"] = "application/json";
+    }
+    for (let attempt = 1; attempt <= this._maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this._timeoutMs);
+        const signal = opts?.signal ? combineSignals(opts.signal, controller.signal) : controller.signal;
+        const response = await this._fetch(url.toString(), {
+          method,
+          headers: mergedHeaders,
+          body: opts?.jsonBody !== void 0 ? JSON.stringify(opts.jsonBody) : void 0,
+          signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401) {
+          throw new OrchestratorAuthError(
+            `Authentication failed for ${method} ${path}`,
+            401
+          );
+        }
+        if (response.status === 403) {
+          throw new OrchestratorAuthError(
+            `Access denied for ${method} ${path}`,
+            403
+          );
+        }
+        if (response.status === 404) {
+          throw new OrchestratorNotFoundError(
+            "resource",
+            path,
+            `Endpoint returned 404: ${method} ${path}`
+          );
+        }
+        if (response.status >= 500) {
+          if (attempt === this._maxRetries) {
+          } else {
+            const delay = RETRY_BACKOFF_BASE * 2 ** (attempt - 1);
+            console.warn(
+              `Server error ${response.status} (attempt ${attempt}/${this._maxRetries}), retrying in ${delay}ms`
+            );
+            await sleep(delay);
+            continue;
+          }
+        }
+        if (opts?.rawResponse) {
+          return response;
+        }
+        if (response.ok) {
+          const contentType = response.headers.get("content-type") ?? "";
+          if (contentType.includes("application/json")) {
+            return response.json();
+          }
+          return { _text: await response.text() };
+        }
+        let errorMessage;
+        let errorCode = null;
+        let errorDetails = null;
+        try {
+          const body = await response.json();
+          const error = body.error ?? body;
+          errorCode = error.code ?? null;
+          errorMessage = error.message ?? await response.text();
+          errorDetails = error.details ?? null;
+        } catch {
+          errorMessage = await response.text();
+        }
+        throw new OrchestratorAPIError(
+          errorMessage,
+          response.status,
+          errorCode,
+          errorDetails ?? void 0
+        );
+      } catch (err) {
+        if (err instanceof OrchestratorAPIError || err instanceof OrchestratorAuthError || err instanceof OrchestratorNotFoundError) {
+          throw err;
+        }
+        if (err instanceof OrchestratorConnectionError) {
+          throw err;
+        }
+        if (err instanceof DOMException && err.name === "AbortError") {
+          if (attempt === this._maxRetries) {
+            throw new OrchestratorConnectionError(
+              `Request timed out after ${this._timeoutMs}ms (${this._maxRetries} attempts): ${method} ${path}`
+            );
+          }
+          const delay = RETRY_BACKOFF_BASE * 2 ** (attempt - 1);
+          console.warn(
+            `Request timed out (attempt ${attempt}/${this._maxRetries}), retrying in ${delay}ms`
+          );
+          await sleep(delay);
+          continue;
+        }
+        if (err instanceof TypeError) {
+          if (attempt === this._maxRetries) {
+            throw new OrchestratorConnectionError(
+              `Orchestrator unreachable after ${this._maxRetries} attempts: ${err.message}`
+            );
+          }
+          const delay = RETRY_BACKOFF_BASE * 2 ** (attempt - 1);
+          console.warn(
+            `Request failed (attempt ${attempt}/${this._maxRetries}), retrying in ${delay}ms: ${err.message}`
+          );
+          await sleep(delay);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw new OrchestratorConnectionError(
+      `Request failed after ${this._maxRetries} attempts: ${method} ${path}`
+    );
+  }
+  async _get(path, params) {
+    return await this._request("GET", path, { params });
+  }
+  async _post(path, body) {
+    return await this._request("POST", path, { jsonBody: body });
+  }
+  async _put(path, body) {
+    return await this._request("PUT", path, { jsonBody: body });
+  }
+  async _delete(path) {
+    return await this._request("DELETE", path);
+  }
+  // ------------------------------------------------------------------
+  // 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 tasks = (data.tasks ?? []).map(buildTaskSummary);
+    return { tasks, pagination: buildPagination(data) };
+  }
+  async createTask(params) {
+    const data = await this._post("/tasks", {
+      workflow_id: params.workflowId,
+      goal_prompt: params.goalPrompt,
+      max_iterations: params.maxIterations,
+      options: params.options,
+      ticket_id: params.ticketId,
+      title: params.title,
+      model_id: params.modelId
+    });
+    return {
+      taskId: data.taskId ?? data.task_id ?? "",
+      status: data.status ?? ""
+    };
+  }
+  async getTaskStatus(taskId) {
+    const data = await this._get(`/tasks/${taskId}`);
+    return {
+      ...buildTaskSummary(data),
+      subtaskIds: data.subtaskIds ?? data.subtask_ids ?? [],
+      workflowData: data.workflowData ?? data.workflow_data ?? null,
+      options: data.options ?? null
+    };
+  }
+  async getTaskConversation(taskId) {
+    const data = await this._get(`/tasks/${taskId}/conversation`);
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      conversation: (data.conversation ?? []).map(
+        (m) => m
+      )
+    };
+  }
+  async getArchivedMessageContent(taskId, messageId) {
+    return this._get(
+      `/tasks/${taskId}/conversation/messages/${messageId}/archived`
+    );
+  }
+  async getTaskCompactions(taskId) {
+    const data = await this._get(`/tasks/${taskId}/compactions`);
+    return data.compactions ?? [];
+  }
+  async getTaskJournal(taskId) {
+    const data = await this._get(`/tasks/${taskId}/journal`);
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      exists: data.exists ?? false,
+      content: data.content ?? null,
+      updatedAt: data.updated_at ?? data.updatedAt ?? null,
+      version: data.version ?? null,
+      sectionsOverBudget: data.sections_over_budget ?? data.sectionsOverBudget ?? null
+    };
+  }
+  async cancelTask(taskId) {
+    const data = await this._post(`/tasks/${taskId}/cancel`);
+    return { message: data.message ?? "" };
+  }
+  async deleteTask(taskId) {
+    const data = await this._delete(`/tasks/${taskId}`);
+    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
+    };
+  }
+  async deleteTasks(taskIds) {
+    const data = await this._post("/tasks/delete", { 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
+    };
+  }
+  // ------------------------------------------------------------------
+  // Attachments
+  // ------------------------------------------------------------------
+  async uploadAttachment(taskId, 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`), {
+      method: "POST",
+      headers: { ...headers },
+      body: formData
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `Attachment upload failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return {
+      id: data.id ?? "",
+      filename: data.filename ?? "",
+      mimeType: data.mimeType ?? data.mime_type ?? "",
+      size: data.size ?? 0,
+      width: data.width ?? null,
+      height: data.height ?? null,
+      tokenCount: data.tokenCount ?? data.token_count ?? null
+    };
+  }
+  async downloadAttachment(taskId, attachmentId) {
+    const headers = await this._resolveHeaders();
+    const response = await this._fetch(this._makeUrl(`/tasks/${taskId}/attachments/${attachmentId}`), {
+      headers
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `Attachment download failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    return response.blob();
+  }
+  // ------------------------------------------------------------------
+  // Interactive workflow
+  // ------------------------------------------------------------------
+  async sendInteractiveMessage(taskId, content) {
+    const data = await this._post(`/tasks/${taskId}/interactive/message`, {
+      content
+    });
+    return { message: data.message ?? "" };
+  }
+  async markInteractiveComplete(taskId) {
+    const data = await this._post(`/tasks/${taskId}/interactive/complete`);
+    return { message: data.message ?? "" };
+  }
+  async markInteractiveFailed(taskId) {
+    const data = await this._post(`/tasks/${taskId}/interactive/failed`);
+    return { message: data.message ?? "" };
+  }
+  async approveInteractiveAction(taskId) {
+    const data = await this._post(`/tasks/${taskId}/interactive/approve`);
+    return { message: data.message ?? "" };
+  }
+  // ------------------------------------------------------------------
+  // Proactive workflow
+  // ------------------------------------------------------------------
+  async sendProactiveGuide(taskId, guide) {
+    const data = await this._post(`/tasks/${taskId}/proactive/guide`, {
+      guide
+    });
+    return { message: data.message ?? "" };
+  }
+  async respondProactiveHelp(taskId, response) {
+    const data = await this._post(`/tasks/${taskId}/proactive/respond`, {
+      response
+    });
+    return { message: data.message ?? "" };
+  }
+  async approveProactiveAction(taskId) {
+    const data = await this._post(`/tasks/${taskId}/proactive/approve`);
+    return { message: data.message ?? "" };
+  }
+  // ------------------------------------------------------------------
+  // Ticket workflow
+  // ------------------------------------------------------------------
+  async sendTicketGuide(taskId, guide) {
+    const data = await this._post(`/tasks/${taskId}/ticket/guide`, {
+      guide
+    });
+    return { message: data.message ?? "" };
+  }
+  async respondTicketHelp(taskId, response) {
+    const data = await this._post(`/tasks/${taskId}/ticket/respond`, {
+      response
+    });
+    return { message: data.message ?? "" };
+  }
+  async approveTicketAction(taskId) {
+    const data = await this._post(`/tasks/${taskId}/ticket/approve`);
+    return { message: data.message ?? "" };
+  }
+  async wakeTicket(taskId) {
+    const data = await this._post(`/tasks/${taskId}/ticket/wake`);
+    return { message: data.message ?? "" };
+  }
+  // ------------------------------------------------------------------
+  // Matrix workflow
+  // ------------------------------------------------------------------
+  async sendMatrixMessage(taskId, content) {
+    const data = await this._post(`/tasks/${taskId}/matrix/message`, {
+      content
+    });
+    return { message: data.message ?? "" };
+  }
+  async markMatrixComplete(taskId) {
+    const data = await this._post(`/tasks/${taskId}/matrix/complete`);
+    return { message: data.message ?? "" };
+  }
+  async markMatrixFailed(taskId) {
+    const data = await this._post(`/tasks/${taskId}/matrix/failed`);
+    return { message: data.message ?? "" };
+  }
+  async approveMatrixAction(taskId) {
+    const data = await this._post(`/tasks/${taskId}/matrix/approve`);
+    return { message: data.message ?? "" };
+  }
+  async getMatrixConversation(taskId) {
+    const data = await this._get(`/tasks/${taskId}/matrix/conversation`);
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      conversation: (data.conversation ?? []).map(
+        (m) => m
+      )
+    };
+  }
+  // ------------------------------------------------------------------
+  // VSA workflow
+  // ------------------------------------------------------------------
+  async createVSATask(params) {
+    const data = await this._post("/tasks/vsa", {
+      goal_prompt: params.goalPrompt,
+      title: params.title,
+      model_id: params.modelId
+    });
+    return {
+      taskId: data.taskId ?? data.task_id ?? "",
+      status: data.status ?? ""
+    };
+  }
+  async sendVSAMessage(taskId, content) {
+    const data = await this._post(`/tasks/${taskId}/vsa/message`, {
+      content
+    });
+    return { message: data.message ?? "" };
+  }
+  async renameVSATask(taskId, title) {
+    const data = await this._post(`/tasks/${taskId}/vsa/rename`, {
+      title
+    });
+    return { message: data.message ?? "" };
+  }
+  async regenerateVSATitle(taskId) {
+    const data = await this._post(`/tasks/${taskId}/vsa/regenerate-title`);
+    return { message: data.message ?? "" };
+  }
+  async markVSAComplete(taskId) {
+    const data = await this._post(`/tasks/${taskId}/vsa/complete`);
+    return { message: data.message ?? "" };
+  }
+  async markVSAFailed(taskId) {
+    const data = await this._post(`/tasks/${taskId}/vsa/failed`);
+    return { message: data.message ?? "" };
+  }
+  async stopVSA(taskId) {
+    const data = await this._post(`/tasks/${taskId}/vsa/stop`);
+    return { message: data.message ?? "" };
+  }
+  async deleteVSA(taskId) {
+    const data = await this._delete(`/tasks/${taskId}/vsa`);
+    return { message: data.message ?? "" };
+  }
+  async listVSATasks(params) {
+    const data = await this._get("/tasks/vsa", {
+      status: params?.status,
+      limit: params?.limit,
+      offset: params?.offset
+    });
+    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);
+    return { tasks, pagination: buildPagination(data) };
+  }
+  async deleteVSATasksBulk(taskIds) {
+    const data = await this._post("/tasks/vsa/delete-bulk", {
+      task_ids: taskIds
+    });
+    return { message: data.message ?? "" };
+  }
+  // ------------------------------------------------------------------
+  // MIO workflow
+  // ------------------------------------------------------------------
+  async sendMioMessage(taskId, content) {
+    const data = await this._post(`/tasks/${taskId}/mio/message`, {
+      content
+    });
+    return { message: data.message ?? "" };
+  }
+  async approveMioAction(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/approve`);
+    return { message: data.message ?? "" };
+  }
+  async wakeMio(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/wake`);
+    return { message: data.message ?? "" };
+  }
+  async sendMioUserAway(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/user-away`);
+    return { message: data.message ?? "" };
+  }
+  async markMioComplete(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/complete`);
+    return { message: data.message ?? "" };
+  }
+  async markMioFailed(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/failed`);
+    return { message: data.message ?? "" };
+  }
+  async archiveMio(taskId) {
+    const data = await this._post(`/tasks/${taskId}/mio/archive`);
+    return { message: data.message ?? "" };
+  }
+  async getMioContext(taskId) {
+    const data = await this._get(`/tasks/${taskId}/mio/context`);
+    return {
+      taskId: data.taskId ?? data.task_id ?? taskId,
+      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
+    };
+  }
+  // ------------------------------------------------------------------
+  // Tools
+  // ------------------------------------------------------------------
+  async listTools() {
+    const data = await this._get("/tools");
+    return {
+      tools: (data.tools ?? data.tools ?? []).map(
+        (t) => t
+      ),
+      totalTools: data.totalTools ?? data.total_tools ?? 0,
+      servers: data.servers ?? []
+    };
+  }
+  // ------------------------------------------------------------------
+  // Debug / Admin
+  // ------------------------------------------------------------------
+  async getWorkflowStates() {
+    const data = await this._get("/debug/workflow-states");
+    return {
+      validStates: data.validStates ?? data.valid_states ?? {},
+      processableStates: data.processableStates ?? data.processable_states ?? {},
+      waitingStates: data.waitingStates ?? data.waiting_states ?? {},
+      stoppedStates: data.stoppedStates ?? data.stopped_states ?? {},
+      intermediateStates: data.intermediateStates ?? data.intermediate_states ?? {}
+    };
+  }
+  async updateTaskModels(taskId, models) {
+    const data = await this._post(`/tasks/${taskId}/models`, {
+      agent: models.agent,
+      orchestrator: models.orchestrator
+    });
+    return { message: data.message ?? "" };
+  }
+  async updateTaskIteration(taskId, iteration) {
+    const data = await this._post(`/tasks/${taskId}/iteration`, {
+      iteration
+    });
+    return { message: data.message ?? "" };
+  }
+  async updateTaskWorkflowData(taskId, workflowData) {
+    const data = await this._post(`/tasks/${taskId}/workflow-data`, {
+      workflow_data: workflowData
+    });
+    return { message: data.message ?? "" };
+  }
+  async deleteMessage(taskId, messageId) {
+    const data = await this._delete(
+      `/tasks/${taskId}/conversation/messages/${messageId}`
+    );
+    return { message: data.message ?? "" };
+  }
+  async deleteMessages(taskId, messageIds) {
+    const data = await this._post(
+      `/tasks/${taskId}/conversation/messages/delete`,
+      { message_ids: messageIds }
+    );
+    return { message: data.message ?? "" };
+  }
+  async updateMessage(taskId, messageId, update) {
+    const data = await this._put(
+      `/tasks/${taskId}/conversation/messages/${messageId}`,
+      update
+    );
+    return { message: data.message ?? "" };
+  }
+  async resetMatrixToPhase(taskId, phase) {
+    const data = await this._post(
+      `/tasks/${taskId}/matrix/reset`,
+      { phase }
+    );
+    return { message: data.message ?? "" };
+  }
+  async getMessageTranslations(taskId, messageId, locale) {
+    const params = {};
+    if (locale) params.locale = locale;
+    const data = await this._get(
+      `/tasks/${taskId}/conversation/messages/${messageId}/translations`,
+      params
+    );
+    return {
+      messageId: data.messageId ?? data.message_id ?? messageId,
+      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
+    );
+  }
+  async getErrorDetail(errorId) {
+    return this._get(`/errors/${errorId}`);
+  }
+  async getErrorStats(since) {
+    const params = {};
+    if (since) params.since = since;
+    return this._get("/errors/stats", params);
+  }
+  async countErrors(since) {
+    const params = {};
+    if (since) params.since = since;
+    return this._get("/errors/count", params);
+  }
+  async purgeErrors() {
+    return this._delete("/errors");
+  }
+  // ------------------------------------------------------------------
+  // Health / Metrics
+  // ------------------------------------------------------------------
+  async health() {
+    return this._get("/health");
+  }
+  async healthDetailed() {
+    return this._get("/health/detail");
+  }
+  async ready() {
+    return this._get("/ready");
+  }
+  async healthLeader() {
+    return this._get("/leader");
+  }
+  async getMetrics(types) {
+    const params = {};
+    if (types) params.types = types;
+    return this._get("/metrics", params);
+  }
+  // ------------------------------------------------------------------
+  // Configuration
+  // ------------------------------------------------------------------
+  async getSystemStatus() {
+    return this._get("/config/status");
+  }
+  async updateSettings(settings) {
+    return this._post("/config/settings", settings);
+  }
+  async getConfigurationStatus() {
+    return this._get("/config");
+  }
+  async setAgentModel(model) {
+    const data = await this._post("/config/models/agent", { model });
+    return { message: data.message ?? "" };
+  }
+  async setOrchestratorModel(model) {
+    const data = await this._post("/config/models/orchestrator", { model });
+    return { message: data.message ?? "" };
+  }
+  async getLLMBackendStatus() {
+    return this._get("/config/llmbackends");
+  }
+  async addLLMBackend(host, apiKey) {
+    const data = await this._post("/config/llmbackends", {
+      host,
+      api_key: apiKey
+    });
+    return { message: data.message ?? "" };
+  }
+  async removeLLMBackend(host) {
+    const data = await this._delete(`/config/llmbackends/${encodeURIComponent(host)}`);
+    return { message: data.message ?? "" };
+  }
+  async getMCPServerStatus() {
+    return this._get("/config/mcpservers");
+  }
+  async addMCPServer(host, apiKey) {
+    const data = await this._post("/config/mcpservers", {
+      host,
+      api_key: apiKey
+    });
+    return { message: data.message ?? "" };
+  }
+  async removeMCPServer(host) {
+    const data = await this._delete(`/config/mcpservers/${encodeURIComponent(host)}`);
+    return { message: data.message ?? "" };
+  }
+  async getTaskHandlerStatus() {
+    return this._get("/config/taskhandler");
+  }
+  async getTaskHandlerStatusLocal() {
+    return this._get("/config/taskhandler/local");
+  }
+  async setConcurrentTasksPerReplica(maxTasks) {
+    const data = await this._post("/config/taskhandler/concurrency", {
+      max_tasks: maxTasks
+    });
+    return { message: data.message ?? "" };
+  }
+  async getSummaryWorkerStatus() {
+    return this._get("/config/summary-worker");
+  }
+  async setCompactorModel(modelName) {
+    const data = await this._post("/config/models/compactor", {
+      model_name: modelName
+    });
+    return { message: data.message ?? "" };
+  }
+  async setTranslateModel(modelName) {
+    const data = await this._post("/config/models/translate", {
+      model_name: modelName
+    });
+    return { message: data.message ?? "" };
+  }
+  async getTokenWorkerStatus() {
+    return this._get("/config/token-worker");
+  }
+  async getSlotsStatus() {
+    return this._get("/config/slots");
+  }
+  // ------------------------------------------------------------------
+  // Auth / WebSocket status
+  // ------------------------------------------------------------------
+  async getAuthConfig() {
+    return this._get("/auth/config");
+  }
+  async getWebSocketStatus() {
+    return this._get("/websocket/status");
+  }
+  // ------------------------------------------------------------------
+  // SSE stream
+  // ------------------------------------------------------------------
+  async *streamTaskStatus(taskId) {
+    const headers = await this._resolveHeaders();
+    headers["Accept"] = "text/event-stream";
+    const response = await this._fetch(this._makeUrl(`/tasks/${taskId}/stream`), {
+      headers
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `Stream connection failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new OrchestratorConnectionError("Stream body is not readable");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          try {
+            yield JSON.parse(line.slice(6));
+          } catch {
+          }
+        }
+      }
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function combineSignals(...signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+
+// src/sync-client.ts
+var Orchestrator = class {
+  constructor(opts = {}) {
+    this._async = new OrchestratorAsync(opts);
+  }
+  /** Close the underlying resources. */
+  close() {
+    this._async.close().catch(() => {
+    });
+  }
+  // ------------------------------------------------------------------
+  // Tasks
+  // ------------------------------------------------------------------
+  listTasks(params) {
+    return runSync(this._async.listTasks(params));
+  }
+  createTask(params) {
+    return runSync(this._async.createTask(params));
+  }
+  getTaskStatus(taskId) {
+    return runSync(this._async.getTaskStatus(taskId));
+  }
+  getTaskConversation(taskId) {
+    return runSync(this._async.getTaskConversation(taskId));
+  }
+  getArchivedMessageContent(taskId, messageId) {
+    return runSync(this._async.getArchivedMessageContent(taskId, messageId));
+  }
+  getTaskCompactions(taskId) {
+    return runSync(this._async.getTaskCompactions(taskId));
+  }
+  getTaskJournal(taskId) {
+    return runSync(this._async.getTaskJournal(taskId));
+  }
+  cancelTask(taskId) {
+    return runSync(this._async.cancelTask(taskId));
+  }
+  deleteTask(taskId) {
+    return runSync(this._async.deleteTask(taskId));
+  }
+  deleteTasks(taskIds) {
+    return runSync(this._async.deleteTasks(taskIds));
+  }
+  // ------------------------------------------------------------------
+  // Attachments
+  // ------------------------------------------------------------------
+  uploadAttachment(taskId, file, filename) {
+    return runSync(this._async.uploadAttachment(taskId, file, filename));
+  }
+  downloadAttachment(taskId, attachmentId) {
+    return runSync(this._async.downloadAttachment(taskId, attachmentId));
+  }
+  // ------------------------------------------------------------------
+  // Interactive workflow
+  // ------------------------------------------------------------------
+  sendInteractiveMessage(taskId, content) {
+    return runSync(this._async.sendInteractiveMessage(taskId, content));
+  }
+  markInteractiveComplete(taskId) {
+    return runSync(this._async.markInteractiveComplete(taskId));
+  }
+  markInteractiveFailed(taskId) {
+    return runSync(this._async.markInteractiveFailed(taskId));
+  }
+  approveInteractiveAction(taskId) {
+    return runSync(this._async.approveInteractiveAction(taskId));
+  }
+  // ------------------------------------------------------------------
+  // Proactive workflow
+  // ------------------------------------------------------------------
+  sendProactiveGuide(taskId, guide) {
+    return runSync(this._async.sendProactiveGuide(taskId, guide));
+  }
+  respondProactiveHelp(taskId, response) {
+    return runSync(this._async.respondProactiveHelp(taskId, response));
+  }
+  approveProactiveAction(taskId) {
+    return runSync(this._async.approveProactiveAction(taskId));
+  }
+  // ------------------------------------------------------------------
+  // Ticket workflow
+  // ------------------------------------------------------------------
+  sendTicketGuide(taskId, guide) {
+    return runSync(this._async.sendTicketGuide(taskId, guide));
+  }
+  respondTicketHelp(taskId, response) {
+    return runSync(this._async.respondTicketHelp(taskId, response));
+  }
+  approveTicketAction(taskId) {
+    return runSync(this._async.approveTicketAction(taskId));
+  }
+  wakeTicket(taskId) {
+    return runSync(this._async.wakeTicket(taskId));
+  }
+  // ------------------------------------------------------------------
+  // Matrix workflow
+  // ------------------------------------------------------------------
+  sendMatrixMessage(taskId, content) {
+    return runSync(this._async.sendMatrixMessage(taskId, content));
+  }
+  markMatrixComplete(taskId) {
+    return runSync(this._async.markMatrixComplete(taskId));
+  }
+  markMatrixFailed(taskId) {
+    return runSync(this._async.markMatrixFailed(taskId));
+  }
+  approveMatrixAction(taskId) {
+    return runSync(this._async.approveMatrixAction(taskId));
+  }
+  getMatrixConversation(taskId) {
+    return runSync(this._async.getMatrixConversation(taskId));
+  }
+  // ------------------------------------------------------------------
+  // VSA workflow
+  // ------------------------------------------------------------------
+  createVSATask(params) {
+    return runSync(this._async.createVSATask(params));
+  }
+  sendVSAMessage(taskId, content) {
+    return runSync(this._async.sendVSAMessage(taskId, content));
+  }
+  renameVSATask(taskId, title) {
+    return runSync(this._async.renameVSATask(taskId, title));
+  }
+  regenerateVSATitle(taskId) {
+    return runSync(this._async.regenerateVSATitle(taskId));
+  }
+  markVSAComplete(taskId) {
+    return runSync(this._async.markVSAComplete(taskId));
+  }
+  markVSAFailed(taskId) {
+    return runSync(this._async.markVSAFailed(taskId));
+  }
+  stopVSA(taskId) {
+    return runSync(this._async.stopVSA(taskId));
+  }
+  deleteVSA(taskId) {
+    return runSync(this._async.deleteVSA(taskId));
+  }
+  listVSATasks(params) {
+    return runSync(this._async.listVSATasks(params));
+  }
+  searchVSATasks(query) {
+    return runSync(this._async.searchVSATasks(query));
+  }
+  deleteVSATasksBulk(taskIds) {
+    return runSync(this._async.deleteVSATasksBulk(taskIds));
+  }
+  // ------------------------------------------------------------------
+  // MIO workflow
+  // ------------------------------------------------------------------
+  sendMioMessage(taskId, content) {
+    return runSync(this._async.sendMioMessage(taskId, content));
+  }
+  approveMioAction(taskId) {
+    return runSync(this._async.approveMioAction(taskId));
+  }
+  wakeMio(taskId) {
+    return runSync(this._async.wakeMio(taskId));
+  }
+  sendMioUserAway(taskId) {
+    return runSync(this._async.sendMioUserAway(taskId));
+  }
+  markMioComplete(taskId) {
+    return runSync(this._async.markMioComplete(taskId));
+  }
+  markMioFailed(taskId) {
+    return runSync(this._async.markMioFailed(taskId));
+  }
+  archiveMio(taskId) {
+    return runSync(this._async.archiveMio(taskId));
+  }
+  getMioContext(taskId) {
+    return runSync(this._async.getMioContext(taskId));
+  }
+  // ------------------------------------------------------------------
+  // Tools
+  // ------------------------------------------------------------------
+  listTools() {
+    return runSync(this._async.listTools());
+  }
+  // ------------------------------------------------------------------
+  // Debug / Admin
+  // ------------------------------------------------------------------
+  getWorkflowStates() {
+    return runSync(this._async.getWorkflowStates());
+  }
+  updateTaskModels(taskId, models) {
+    return runSync(this._async.updateTaskModels(taskId, models));
+  }
+  updateTaskIteration(taskId, iteration) {
+    return runSync(this._async.updateTaskIteration(taskId, iteration));
+  }
+  updateTaskWorkflowData(taskId, workflowData) {
+    return runSync(this._async.updateTaskWorkflowData(taskId, workflowData));
+  }
+  deleteMessage(taskId, messageId) {
+    return runSync(this._async.deleteMessage(taskId, messageId));
+  }
+  deleteMessages(taskId, messageIds) {
+    return runSync(this._async.deleteMessages(taskId, messageIds));
+  }
+  updateMessage(taskId, messageId, update) {
+    return runSync(this._async.updateMessage(taskId, messageId, update));
+  }
+  resetMatrixToPhase(taskId, phase) {
+    return runSync(this._async.resetMatrixToPhase(taskId, phase));
+  }
+  getMessageTranslations(taskId, messageId, locale) {
+    return runSync(this._async.getMessageTranslations(taskId, messageId, locale));
+  }
+  // ------------------------------------------------------------------
+  // Error events
+  // ------------------------------------------------------------------
+  listErrors(params) {
+    return runSync(this._async.listErrors(params));
+  }
+  getErrorDetail(errorId) {
+    return runSync(this._async.getErrorDetail(errorId));
+  }
+  getErrorStats(since) {
+    return runSync(this._async.getErrorStats(since));
+  }
+  countErrors(since) {
+    return runSync(this._async.countErrors(since));
+  }
+  purgeErrors() {
+    return runSync(this._async.purgeErrors());
+  }
+  // ------------------------------------------------------------------
+  // Health / Metrics
+  // ------------------------------------------------------------------
+  health() {
+    return runSync(this._async.health());
+  }
+  healthDetailed() {
+    return runSync(this._async.healthDetailed());
+  }
+  ready() {
+    return runSync(this._async.ready());
+  }
+  healthLeader() {
+    return runSync(this._async.healthLeader());
+  }
+  getMetrics(types) {
+    return runSync(this._async.getMetrics(types));
+  }
+  // ------------------------------------------------------------------
+  // Configuration
+  // ------------------------------------------------------------------
+  getSystemStatus() {
+    return runSync(this._async.getSystemStatus());
+  }
+  updateSettings(settings) {
+    return runSync(this._async.updateSettings(settings));
+  }
+  getConfigurationStatus() {
+    return runSync(this._async.getConfigurationStatus());
+  }
+  setAgentModel(model) {
+    return runSync(this._async.setAgentModel(model));
+  }
+  setOrchestratorModel(model) {
+    return runSync(this._async.setOrchestratorModel(model));
+  }
+  getLLMBackendStatus() {
+    return runSync(this._async.getLLMBackendStatus());
+  }
+  addLLMBackend(host, apiKey) {
+    return runSync(this._async.addLLMBackend(host, apiKey));
+  }
+  removeLLMBackend(host) {
+    return runSync(this._async.removeLLMBackend(host));
+  }
+  getMCPServerStatus() {
+    return runSync(this._async.getMCPServerStatus());
+  }
+  addMCPServer(host, apiKey) {
+    return runSync(this._async.addMCPServer(host, apiKey));
+  }
+  removeMCPServer(host) {
+    return runSync(this._async.removeMCPServer(host));
+  }
+  getTaskHandlerStatus() {
+    return runSync(this._async.getTaskHandlerStatus());
+  }
+  getTaskHandlerStatusLocal() {
+    return runSync(this._async.getTaskHandlerStatusLocal());
+  }
+  setConcurrentTasksPerReplica(maxTasks) {
+    return runSync(this._async.setConcurrentTasksPerReplica(maxTasks));
+  }
+  getSummaryWorkerStatus() {
+    return runSync(this._async.getSummaryWorkerStatus());
+  }
+  setCompactorModel(modelName) {
+    return runSync(this._async.setCompactorModel(modelName));
+  }
+  setTranslateModel(modelName) {
+    return runSync(this._async.setTranslateModel(modelName));
+  }
+  getTokenWorkerStatus() {
+    return runSync(this._async.getTokenWorkerStatus());
+  }
+  getSlotsStatus() {
+    return runSync(this._async.getSlotsStatus());
+  }
+  // ------------------------------------------------------------------
+  // Auth / WebSocket status
+  // ------------------------------------------------------------------
+  getAuthConfig() {
+    return runSync(this._async.getAuthConfig());
+  }
+  getWebSocketStatus() {
+    return runSync(this._async.getWebSocketStatus());
+  }
+  // ------------------------------------------------------------------
+  // SSE stream (collects all events into an array)
+  // ------------------------------------------------------------------
+  streamTaskStatus(_taskId) {
+    const events = [];
+    return events;
+  }
+};
+function runSync(promise) {
+  let result;
+  let error;
+  let done = false;
+  promise.then(
+    (r) => {
+      result = r;
+      done = true;
+    },
+    (e) => {
+      error = e;
+      done = true;
+    }
+  );
+  if (!done) {
+    const start = Date.now();
+    while (!done && Date.now() - start < 1e4) {
+    }
+  }
+  if (!done) {
+    throw new Error("Orchestrator sync: operation timed out");
+  }
+  if (error) throw error;
+  return result;
+}
+
+// src/config.ts
+var DEFAULTS = {
+  baseUrl: "http://localhost:8080",
+  apiKey: void 0,
+  timeoutMs: 3e4,
+  maxRetries: 3
+};
+function loadConfig(overrides) {
+  return {
+    baseUrl: (process.env.ORCHESTRATOR_URL ?? overrides?.baseUrl ?? DEFAULTS.baseUrl).replace(/\/+$/, ""),
+    apiKey: process.env.ORCHESTRATOR_API_KEY ?? overrides?.apiKey ?? DEFAULTS.apiKey,
+    timeoutMs: Number(
+      process.env.ORCHESTRATOR_TIMEOUT_MS ?? overrides?.timeoutMs ?? DEFAULTS.timeoutMs
+    ),
+    maxRetries: Number(
+      process.env.ORCHESTRATOR_MAX_RETRIES ?? overrides?.maxRetries ?? DEFAULTS.maxRetries
+    )
+  };
+}
+
+// src/fetch.ts
+var _insecureFetch;
+async function createInsecureFetch() {
+  if (_insecureFetch) return _insecureFetch;
+  if (typeof process === "undefined" || process.versions?.node == null) {
+    _insecureFetch = globalThis.fetch;
+    return _insecureFetch;
+  }
+  const https = await import("https");
+  const http = await import("http");
+  const agent = new https.Agent({ rejectUnauthorized: false });
+  _insecureFetch = async (input, init) => {
+    const urlStr = typeof input === "string" ? input : input.toString();
+    const urlObj = new URL(urlStr);
+    const isHttps = urlObj.protocol === "https:";
+    return new Promise((resolve, reject) => {
+      const mod = isHttps ? https : http;
+      const req = mod.request(
+        urlStr,
+        {
+          method: init?.method ?? "GET",
+          headers: init?.headers,
+          rejectUnauthorized: false,
+          agent: isHttps ? agent : void 0
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(chunk));
+          res.on("end", () => {
+            const body = Buffer.concat(chunks);
+            const headers = new Headers();
+            const resHeaders = res.headers;
+            if (resHeaders) {
+              for (const [key, value] of Object.entries(resHeaders)) {
+                if (value != null) {
+                  if (Array.isArray(value)) {
+                    for (const v of value) headers.append(key, v);
+                  } else {
+                    headers.set(key, value);
+                  }
+                }
+              }
+            }
+            resolve(
+              new Response(body, {
+                status: res.statusCode,
+                statusText: res.statusMessage,
+                headers
+              })
+            );
+          });
+        }
+      );
+      req.on("error", reject);
+      if (init?.body != null) {
+        req.write(init.body);
+      }
+      req.end();
+    });
+  };
+  return _insecureFetch;
+}
+
+// src/socketio.ts
+var EVENT_TASK_CREATED = "task_created";
+var EVENT_TASK_STATUS_CHANGED = "task_status_changed";
+var EVENT_TASK_ITERATION_CHANGED = "task_iteration_changed";
+var EVENT_TASK_DELETED = "task_deleted";
+var EVENT_TASK_RESULT_UPDATED = "task_result_updated";
+var EVENT_TASK_INSIGHT_UPDATED = "task_insight_updated";
+var EVENT_MESSAGE_ADDED = "message_added";
+var EVENT_MESSAGE_STREAMING = "message_streaming";
+var EVENT_MESSAGE_SUMMARY_GENERATED = "message_summary_generated";
+var EVENT_MESSAGE_TRANSLATION_READY = "message_translation_ready";
+var EVENT_ERROR_EVENT_RECORDED = "error_event_recorded";
+var RealtimeClient = class {
+  constructor(baseUrl, opts) {
+    this._socket = null;
+    this._handlers = /* @__PURE__ */ new Map();
+    this._connected = false;
+    this._baseUrl = baseUrl.replace(/\/+$/, "");
+    this._socketOptions = opts.socketOptions ?? {};
+    this._getToken = opts.getToken;
+    if (opts.autoConnect) {
+      this.connect();
+    }
+  }
+  get connected() {
+    return this._connected;
+  }
+  async connect() {
+    const auth = {};
+    if (this._getToken) {
+      auth.token = typeof this._getToken === "function" ? await this._getToken() : this._getToken;
+    }
+    const { io } = await import("socket.io-client");
+    this._socket = io(this._baseUrl, {
+      path: "/socket.io",
+      auth,
+      transports: ["websocket", "polling"],
+      ...this._socketOptions
+    });
+    this._socket.on("connect", () => {
+      this._connected = true;
+    });
+    this._socket.on("disconnect", () => {
+      this._connected = false;
+    });
+    return new Promise((resolve, reject) => {
+      const socket = this._socket;
+      socket.on("connect", () => resolve());
+      socket.on("connect_error", (err) => reject(err));
+      if (socket.connected) {
+        resolve();
+      }
+    });
+  }
+  async disconnect() {
+    if (this._socket) {
+      this._socket.disconnect();
+      this._socket = null;
+    }
+    this._connected = false;
+  }
+  /**
+   * Subscribe to realtime events for a specific task.
+   */
+  async 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"));
+      });
+    });
+  }
+  /**
+   * Unsubscribe from realtime events for a specific task.
+   */
+  async 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"));
+      });
+    });
+  }
+  /**
+   * Register a handler for a specific event type.
+   */
+  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);
+            }
+          }
+        });
+      }
+    }
+    this._handlers.get(event).add(handler);
+  }
+  /**
+   * Remove a registered handler.
+   */
+  off(event, handler) {
+    const handlers = this._handlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this._handlers.delete(event);
+        if (this._socket) {
+          this._socket.off(event);
+        }
+      }
+    }
+  }
+  /**
+   * Wait for the connection to close (for long-running listeners).
+   */
+  wait() {
+    return new Promise((resolve) => {
+      const socket = this._socket;
+      if (!socket) {
+        resolve();
+        return;
+      }
+      socket.on("disconnect", () => resolve());
+    });
+  }
+};
+
+// src/index.ts
+var VERSION = "5.6.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVENT_ERROR_EVENT_RECORDED,
+  EVENT_MESSAGE_ADDED,
+  EVENT_MESSAGE_STREAMING,
+  EVENT_MESSAGE_SUMMARY_GENERATED,
+  EVENT_MESSAGE_TRANSLATION_READY,
+  EVENT_TASK_CREATED,
+  EVENT_TASK_DELETED,
+  EVENT_TASK_INSIGHT_UPDATED,
+  EVENT_TASK_ITERATION_CHANGED,
+  EVENT_TASK_RESULT_UPDATED,
+  EVENT_TASK_STATUS_CHANGED,
+  Orchestrator,
+  OrchestratorAPIError,
+  OrchestratorAsync,
+  OrchestratorAuthError,
+  OrchestratorConfigError,
+  OrchestratorConnectionError,
+  OrchestratorError,
+  OrchestratorNotFoundError,
+  RealtimeClient,
+  VERSION,
+  createInsecureFetch,
+  loadConfig
+});
+//# sourceMappingURL=index.cjs.map