orchestrator-client 5.7.2 → 5.7.4

package/dist/index.js

@@ -15,8 +15,8 @@ var OrchestratorConnectionError = class extends OrchestratorError {
   }
 };
 var OrchestratorAuthError = class extends OrchestratorError {
-  constructor(message, statusCode = 401) {
-    super(message, { statusCode });
+  constructor(message, statusCode = 401, errorCode) {
+    super(message, { statusCode, errorCode });
     this.name = "OrchestratorAuthError";
   }
 };
@@ -43,6 +43,28 @@ var OrchestratorConfigError = class extends OrchestratorError {
   }
 };
 
+// src/utils.ts
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function deepCamelCase(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(deepCamelCase);
+  }
+  if (typeof obj === "object" && obj !== null) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        snakeToCamel(key),
+        deepCamelCase(value)
+      ])
+    );
+  }
+  return obj;
+}
+
 // src/client.ts
 var RETRY_BACKOFF_BASE = 500;
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -62,22 +84,66 @@ function buildTaskSummary(t) {
   return {
     id: t.id ?? "",
     status: t.status ?? "",
-    workflowId: t.workflowId ?? t.workflow_id ?? "",
+    workflowId: t.workflowId ?? "",
     iteration: t.iteration ?? 0,
-    maxIterations: t.maxIterations ?? t.max_iterations ?? 0,
-    goalPrompt: t.goalPrompt ?? t.goal_prompt ?? "",
+    maxIterations: t.maxIterations ?? 0,
+    goalPrompt: t.goalPrompt ?? "",
     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,
+    resultLocalized: t.resultLocalized ?? null,
+    approvalReason: t.approvalReason ?? "",
+    ticketId: t.ticketId ?? null,
+    availableTools: t.availableTools ?? 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
+    insightLocalized: t.insightLocalized ?? null,
+    createdAt: t.createdAt ?? "",
+    updatedAt: t.updatedAt ?? "",
+    pendingTranslationsForLocales: t.pendingTranslationsForLocales ?? null
   };
 }
+function parseApiErrorBody(body, fallbackMessage) {
+  let errorCode = body.error_code ?? null;
+  if (!errorCode && body.error && typeof body.error === "object") {
+    const nested = body.error;
+    errorCode = nested.code ?? null;
+  }
+  let message = null;
+  if (typeof body.error === "string") {
+    message = body.error;
+  } else if (typeof body.message === "string") {
+    message = body.message;
+  }
+  let details = body.details ?? null;
+  const detail = body.detail;
+  if (typeof detail === "string") {
+    message = detail;
+  } else if (detail && typeof detail === "object" && !Array.isArray(detail)) {
+    const detailObj = detail;
+    if (!errorCode) {
+      errorCode = detailObj.error_code ?? null;
+    }
+    if (typeof detailObj.error === "string") {
+      message = detailObj.error;
+    } else if (typeof detailObj.message === "string") {
+      message = detailObj.message;
+    }
+    if (!details) {
+      details = detailObj;
+    }
+  }
+  if (!message) {
+    message = fallbackMessage;
+  }
+  const missingFields = body.missing_fields;
+  if (Array.isArray(missingFields) && missingFields.length > 0) {
+    const fields = missingFields.filter(
+      (f) => typeof f === "string"
+    );
+    if (fields.length > 0) {
+      message = `${message} (missing: ${fields.join(", ")})`;
+    }
+  }
+  return { message, errorCode, details };
+}
 var OrchestratorAsync = class {
   constructor(opts = {}) {
     this._abortController = null;
@@ -91,7 +157,7 @@ var OrchestratorAsync = class {
     this._timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this._maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
     this._locale = opts.locale;
-    this._fetch = opts.fetch ?? globalThis.fetch;
+    this._fetch = opts.fetch ?? globalThis.fetch.bind(globalThis);
     if (opts.insecure && !opts.fetch && typeof process !== "undefined" && process.versions?.node) {
       this._insecure = true;
     }
@@ -149,16 +215,21 @@ var OrchestratorAsync = class {
           signal
         });
         clearTimeout(timeoutId);
-        if (response.status === 401) {
-          throw new OrchestratorAuthError(
-            `Authentication failed for ${method} ${path}`,
-            401
-          );
-        }
-        if (response.status === 403) {
+        if (response.status === 401 || response.status === 403) {
+          const defaultAuthMsg = response.status === 401 ? `Authentication failed for ${method} ${path}` : `Access denied for ${method} ${path}`;
+          let authErrorCode = null;
+          let authErrorMsg = defaultAuthMsg;
+          try {
+            const body = await response.clone().json();
+            const parsed = parseApiErrorBody(body, defaultAuthMsg);
+            authErrorMsg = parsed.message;
+            authErrorCode = parsed.errorCode;
+          } catch {
+          }
           throw new OrchestratorAuthError(
-            `Access denied for ${method} ${path}`,
-            403
+            authErrorMsg,
+            response.status,
+            authErrorCode
           );
         }
         if (response.status === 404) {
@@ -185,21 +256,27 @@ var OrchestratorAsync = class {
         if (response.ok) {
           const contentType = response.headers.get("content-type") ?? "";
           if (contentType.includes("application/json")) {
-            return response.json();
+            return deepCamelCase(await response.json());
           }
           return { _text: await response.text() };
         }
-        let errorMessage;
+        const defaultMessage = `API Error with status ${response.status}`;
+        let errorMessage = defaultMessage;
         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;
+          const clonedResponse = response.clone();
+          const body = await clonedResponse.json();
+          const parsed = parseApiErrorBody(body, JSON.stringify(body));
+          errorMessage = parsed.message;
+          errorCode = parsed.errorCode;
+          errorDetails = parsed.details;
         } catch {
-          errorMessage = await response.text();
+          try {
+            errorMessage = await response.text();
+          } catch {
+            errorMessage = defaultMessage;
+          }
         }
         throw new OrchestratorAPIError(
           errorMessage,
@@ -269,7 +346,7 @@ var OrchestratorAsync = class {
       params: {
         page: params?.page,
         limit: params?.limit,
-        order_by: params?.orderBy,
+        order_by: params?.orderBy ? camelToSnake(params.orderBy) : void 0,
         order_direction: params?.orderDirection,
         workflow_id: params?.workflowId
       },
@@ -342,10 +419,10 @@ var OrchestratorAsync = class {
     };
   }
   async getArchivedMessageContent(taskId, messageId) {
-    return this._get(
-      "/task/message/archived-content",
-      { task_id: taskId, message_id: messageId }
-    );
+    return this._get("/task/message/archived-content", {
+      task_id: taskId,
+      message_id: messageId
+    });
   }
   async getTaskCompactions(taskId) {
     return this._get("/task/compactions", {
@@ -404,19 +481,39 @@ var OrchestratorAsync = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  async uploadAttachment(file, filename) {
+  async uploadAttachment(file, filename, options) {
     const formData = new FormData();
     formData.append("file", file, filename);
     const headers = await this._resolveHeaders();
     const response = await this._fetch(this._makeUrl("/attachment"), {
       method: "POST",
       headers: { ...headers },
-      body: formData
+      body: formData,
+      signal: options?.signal
     });
     if (!response.ok) {
+      const defaultMessage = `Attachment upload failed: ${response.statusText}`;
+      let errorMessage = defaultMessage;
+      let errorCode = null;
+      let errorDetails = null;
+      try {
+        const body = await response.clone().json();
+        const parsed = parseApiErrorBody(body, defaultMessage);
+        errorMessage = parsed.message;
+        errorCode = parsed.errorCode;
+        errorDetails = parsed.details;
+      } catch {
+        try {
+          errorMessage = await response.text() || defaultMessage;
+        } catch {
+          errorMessage = defaultMessage;
+        }
+      }
       throw new OrchestratorAPIError(
-        `Attachment upload failed: ${response.statusText}`,
-        response.status
+        errorMessage,
+        response.status,
+        errorCode,
+        errorDetails ?? void 0
       );
     }
     const data = await response.json();
@@ -934,10 +1031,24 @@ var OrchestratorAsync = class {
     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 countErrors(since, severity) {
+    const authHeaders = await this._resolveHeaders();
+    const url = new URL(this._makeUrl("/errors/count"));
+    if (since) url.searchParams.set("since", since);
+    for (const s of severity ?? []) {
+      url.searchParams.append("severity", s);
+    }
+    const response = await this._fetch(url.toString(), {
+      method: "GET",
+      headers: { ...authHeaders }
+    });
+    if (!response.ok) {
+      throw new OrchestratorAPIError(
+        `countErrors failed: ${response.statusText}`,
+        response.status
+      );
+    }
+    return deepCamelCase(await response.json());
   }
   async purgeErrors() {
     return this._delete("/errors");
@@ -969,7 +1080,35 @@ var OrchestratorAsync = class {
     return this._get("/configuration/system/status");
   }
   async updateSettings(settings) {
-    return this._post("/configuration/system/settings", settings);
+    const body = {};
+    if (settings.agentModelId !== void 0) {
+      body.agent_model_id = settings.agentModelId;
+    }
+    if (settings.orchestratorModelId !== void 0) {
+      body.orchestrator_model_id = settings.orchestratorModelId;
+    }
+    if (settings.compactorModelId !== void 0) {
+      body.compactor_model_id = settings.compactorModelId;
+    }
+    if (settings.journalModelId !== void 0) {
+      body.journal_model_id = settings.journalModelId;
+    }
+    if (settings.summaryModelId !== void 0) {
+      body.summary_model_id = settings.summaryModelId;
+    }
+    if (settings.translateModelId !== void 0) {
+      body.translate_model_id = settings.translateModelId;
+    }
+    if (settings.maxConcurrentTasksPerReplica !== void 0) {
+      body.max_concurrent_tasks_per_replica = settings.maxConcurrentTasksPerReplica;
+    }
+    if (settings.subagentsEnabled !== void 0) {
+      body.subagents_enabled = settings.subagentsEnabled;
+    }
+    if (settings.localizationTargets !== void 0) {
+      body.localization_targets = settings.localizationTargets;
+    }
+    return this._post("/configuration/system/settings", body);
   }
   async getConfigurationStatus() {
     return this._get("/configuration/status");
@@ -989,9 +1128,7 @@ var OrchestratorAsync = class {
     return { message: data.message ?? "" };
   }
   async getLLMBackendStatus() {
-    return this._get(
-      "/configuration/llmbackend/status"
-    );
+    return this._get("/configuration/llmbackend/status");
   }
   async addLLMBackend(host, apiKey) {
     const data = await this._post(
@@ -1008,9 +1145,7 @@ var OrchestratorAsync = class {
     return { message: data.message ?? "" };
   }
   async getMCPServerStatus() {
-    return this._get(
-      "/configuration/mcpserver/status"
-    );
+    return this._get("/configuration/mcpserver/status");
   }
   async addMCPServer(host, apiKey) {
     const data = await this._post(
@@ -1199,8 +1334,8 @@ var Orchestrator = class {
   // ------------------------------------------------------------------
   // Attachments
   // ------------------------------------------------------------------
-  uploadAttachment(file, filename) {
-    return runSync(this._async.uploadAttachment(file, filename));
+  uploadAttachment(file, filename, options) {
+    return runSync(this._async.uploadAttachment(file, filename, options));
   }
   downloadAttachment(attachmentId) {
     return runSync(this._async.downloadAttachment(attachmentId));
@@ -1401,8 +1536,8 @@ var Orchestrator = class {
   getErrorStats(since) {
     return runSync(this._async.getErrorStats(since));
   }
-  countErrors(since) {
-    return runSync(this._async.countErrors(since));
+  countErrors(since, severity) {
+    return runSync(this._async.countErrors(since, severity));
   }
   purgeErrors() {
     return runSync(this._async.purgeErrors());
@@ -1705,12 +1840,18 @@ var RealtimeClient = class {
   /**
    * Dispatch a message envelope to registered handlers and subscribers.
    * The server sends: socket.emit("message", {type: "message", event: {..., event_type: "...", ...}})
+   *
+   * All event payloads are deep-converted from snake_case to camelCase so
+   * consumers receive consistent camelCase objects (same convention as the
+   * REST responses from _request).  The raw event_type string is extracted
+   * before conversion so the handler-map lookup still works.
    */
   _dispatch(payload) {
     const envelope = payload;
-    const event = envelope.event ?? envelope;
-    const eventType = event.event_type;
+    const rawEvent = envelope.event ?? envelope;
+    const eventType = rawEvent.event_type;
     if (!eventType) return;
+    const event = deepCamelCase(rawEvent);
     const handlers = this._handlers.get(eventType);
     if (handlers) {
       for (const h of handlers) {
@@ -1943,7 +2084,10 @@ export {
   OrchestratorNotFoundError,
   RealtimeClient,
   VERSION,
+  camelToSnake,
   createInsecureFetch,
-  loadConfig
+  deepCamelCase,
+  loadConfig,
+  snakeToCamel
 };
 //# sourceMappingURL=index.js.map