@arbidocs/sdk 0.3.10 → 0.3.13

package/dist/index.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
 var fs = require('fs');
-var path = require('path');
+var path2 = require('path');
 var os = require('os');
 var client = require('@arbidocs/client');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var path2__default = /*#__PURE__*/_interopDefault(path2);
 var os__default = /*#__PURE__*/_interopDefault(os);
 
 var __defProp = Object.defineProperty;
@@ -44,14 +44,64 @@ function requireOk(result, message) {
   }
 }
 function getErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+  if (!(err instanceof Error)) return String(err);
+  const rootCause = getDeepestCause(err);
+  if (rootCause !== err) {
+    const rootMsg = rootCause.message || String(rootCause);
+    if (err.message && !err.message.includes(rootMsg)) {
+      return `${err.message}: ${rootMsg}`;
+    }
+  }
+  return err.message;
+}
+function getDeepestCause(err) {
+  let current = err;
+  const seen = /* @__PURE__ */ new Set();
+  while (current.cause instanceof Error && !seen.has(current.cause)) {
+    seen.add(current);
+    current = current.cause;
+  }
+  return current;
+}
+function getErrorCode(err) {
+  if (!(err instanceof Error)) return void 0;
+  let current = err;
+  const seen = /* @__PURE__ */ new Set();
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const code = current.code;
+    if (typeof code === "string") return code;
+    current = current.cause instanceof Error ? current.cause : void 0;
+  }
+  return void 0;
 }
 
 // src/fetch.ts
-var STATUS_MESSAGES = {
+var STATUS_FALLBACKS = {
   401: "Token has expired. Please run: arbi login",
+  403: "Access denied. You may not have permission for this workspace.",
+  404: "Resource not found.",
   503: "The selected LLM is not responding. Please retry or select another model."
 };
+async function extractErrorMessage(res) {
+  let bodyDetail;
+  try {
+    const text = await res.text();
+    if (text) {
+      try {
+        const json = JSON.parse(text);
+        bodyDetail = json.detail || json.message || json.error || void 0;
+      } catch {
+        if (text.length < 200) bodyDetail = text;
+      }
+    }
+  } catch {
+  }
+  if (bodyDetail) return `Request failed (${res.status}): ${bodyDetail}`;
+  const fallback = STATUS_FALLBACKS[res.status];
+  if (fallback) return fallback;
+  return `Request failed: ${res.status} ${res.statusText}`;
+}
 async function authenticatedFetch(options) {
   const { baseUrl, accessToken, workspaceKeyHeader, path: path3, method, body, headers } = options;
   const res = await fetch(`${baseUrl}${path3}`, {
@@ -64,16 +114,15 @@ async function authenticatedFetch(options) {
     body
   });
   if (!res.ok) {
-    const knownMessage = STATUS_MESSAGES[res.status];
-    if (knownMessage) throw new Error(knownMessage);
-    const text = await res.text().catch(() => "");
-    throw new Error(`Request failed: ${res.status} ${text}`);
+    const message = await extractErrorMessage(res);
+    throw new ArbiApiError(message, { status: res.status, statusText: res.statusText });
   }
   return res;
 }
 var DEFAULT_SESSION = {
   lastMessageExtId: null,
-  conversationExtId: null
+  conversationExtId: null,
+  workspaceId: null
 };
 var FileConfigStore = class {
   configDir;
@@ -81,10 +130,10 @@ var FileConfigStore = class {
   credentialsFile;
   sessionFile;
   constructor(configDir) {
-    this.configDir = configDir ?? process.env.ARBI_CONFIG_DIR ?? path__default.default.join(os__default.default.homedir(), ".arbi");
-    this.configFile = path__default.default.join(this.configDir, "config.json");
-    this.credentialsFile = path__default.default.join(this.configDir, "credentials.json");
-    this.sessionFile = path__default.default.join(this.configDir, "session.json");
+    this.configDir = configDir ?? process.env.ARBI_CONFIG_DIR ?? path2__default.default.join(os__default.default.homedir(), ".arbi");
+    this.configFile = path2__default.default.join(this.configDir, "config.json");
+    this.credentialsFile = path2__default.default.join(this.configDir, "credentials.json");
+    this.sessionFile = path2__default.default.join(this.configDir, "session.json");
   }
   ensureConfigDir() {
     if (!fs__default.default.existsSync(this.configDir)) {
@@ -155,6 +204,77 @@ var FileConfigStore = class {
   clearChatSession() {
     this.saveChatSession({ ...DEFAULT_SESSION });
   }
+  /**
+   * Try to resolve config from multiple sources, in priority order:
+   *
+   * 1. Existing `~/.arbi/config.json` (highest priority)
+   * 2. `ARBI_SERVER_URL` environment variable
+   * 3. `.env` file in `searchDir` → read `VITE_DEPLOYMENT_DOMAIN`
+   * 4. `public/config.json` in `searchDir` → read `deployment.domain`
+   * 5. Default to `https://localhost`
+   *
+   * Returns `{ config, source }` where source describes where the config came from.
+   * Saves auto-detected config to disk so subsequent calls use the fast path.
+   */
+  resolveConfigWithFallbacks(searchDir) {
+    const existing = this.getConfig();
+    if (existing?.baseUrl) {
+      return { config: existing, source: "config" };
+    }
+    const envUrl = process.env.ARBI_SERVER_URL;
+    if (envUrl) {
+      const domain = new URL(envUrl).hostname;
+      const config2 = { baseUrl: envUrl.replace(/\/$/, ""), deploymentDomain: domain };
+      this.saveConfig(config2);
+      return { config: config2, source: "ARBI_SERVER_URL env var" };
+    }
+    const dir = searchDir || process.cwd();
+    const dotenvConfig = this.readDotEnvDomain(path2__default.default.join(dir, ".env"));
+    if (dotenvConfig) {
+      this.saveConfig(dotenvConfig);
+      return { config: dotenvConfig, source: ".env file" };
+    }
+    const publicConfig = this.readPublicConfigDomain(path2__default.default.join(dir, "public", "config.json"));
+    if (publicConfig) {
+      this.saveConfig(publicConfig);
+      return { config: publicConfig, source: "public/config.json" };
+    }
+    const config = { baseUrl: "https://localhost", deploymentDomain: "localhost" };
+    this.saveConfig(config);
+    return { config, source: "default (https://localhost)" };
+  }
+  /**
+   * Read VITE_DEPLOYMENT_DOMAIN from a .env file.
+   */
+  readDotEnvDomain(filePath) {
+    try {
+      const content = fs__default.default.readFileSync(filePath, "utf-8");
+      const match = content.match(/^VITE_DEPLOYMENT_DOMAIN\s*=\s*(.+)$/m);
+      if (match) {
+        const domain = match[1].trim().replace(/^["']|["']$/g, "");
+        if (domain) {
+          return { baseUrl: `https://${domain}`, deploymentDomain: domain };
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Read deployment.domain from a public/config.json file.
+   */
+  readPublicConfigDomain(filePath) {
+    try {
+      const content = fs__default.default.readFileSync(filePath, "utf-8");
+      const json = JSON.parse(content);
+      const domain = json?.deployment?.domain;
+      if (domain) {
+        return { baseUrl: `https://${domain}`, deploymentDomain: domain };
+      }
+    } catch {
+    }
+    return null;
+  }
 };
 function formatWorkspaceChoices(wsList) {
   return wsList.map((ws) => {
@@ -180,7 +300,11 @@ async function createAuthenticatedClient(config, creds, store) {
   });
   store.saveCredentials({
     ...creds,
-    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey),
+    accessToken: void 0,
+    workspaceKeyHeader: void 0,
+    workspaceId: void 0,
+    tokenTimestamp: void 0
   });
   return { arbi, loginResult };
 }
@@ -195,7 +319,12 @@ async function performPasswordLogin(config, email, password, store) {
   store.saveCredentials({
     email,
     signingPrivateKeyBase64: arbi.crypto.bytesToBase64(loginResult.signingPrivateKey),
-    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey),
+    // Clear any cached workspace tokens — new session key invalidates them
+    accessToken: void 0,
+    workspaceKeyHeader: void 0,
+    workspaceId: void 0,
+    tokenTimestamp: void 0
   });
   return { arbi, loginResult, config };
 }
@@ -258,6 +387,10 @@ async function resolveAuth(store) {
   const { arbi, loginResult } = await createAuthenticatedClient(config, creds, store);
   return { arbi, loginResult, config };
 }
+var TOKEN_MAX_AGE_MS = 50 * 60 * 1e3;
+function isCachedTokenValid(creds, workspaceId) {
+  return !!(creds.accessToken && creds.workspaceKeyHeader && creds.workspaceId === workspaceId && creds.tokenTimestamp && Date.now() - new Date(creds.tokenTimestamp).getTime() < TOKEN_MAX_AGE_MS);
+}
 async function resolveWorkspace(store, workspaceOpt) {
   const config = store.requireConfig();
   const creds = store.requireCredentials();
@@ -265,6 +398,32 @@ async function resolveWorkspace(store, workspaceOpt) {
   if (!workspaceId) {
     throw new ArbiError("No workspace selected. Run: arbi workspace select <id>");
   }
+  if (isCachedTokenValid(creds, workspaceId)) {
+    const arbi2 = client.createArbiClient({
+      baseUrl: config.baseUrl,
+      deploymentDomain: config.deploymentDomain,
+      credentials: "omit"
+    });
+    await arbi2.crypto.initSodium();
+    arbi2.session.setSelectedWorkspace(workspaceId);
+    arbi2.session.setAccessToken(creds.accessToken);
+    arbi2.session.setCachedWorkspaceHeader(workspaceId, creds.workspaceKeyHeader);
+    const signingPrivateKey = client.base64ToBytes(creds.signingPrivateKeyBase64);
+    const serverSessionKey = client.base64ToBytes(creds.serverSessionKeyBase64);
+    const loginResult2 = {
+      accessToken: creds.accessToken,
+      signingPrivateKey,
+      serverSessionKey
+    };
+    return {
+      arbi: arbi2,
+      loginResult: loginResult2,
+      config,
+      workspaceId,
+      accessToken: creds.accessToken,
+      workspaceKeyHeader: creds.workspaceKeyHeader
+    };
+  }
   const { arbi, loginResult } = await createAuthenticatedClient(config, creds, store);
   await selectWorkspaceById(
     arbi,
@@ -277,10 +436,57 @@ async function resolveWorkspace(store, workspaceOpt) {
   if (!accessToken || !workspaceKeyHeader) {
     throw new ArbiError("Authentication error \u2014 missing token or workspace key");
   }
+  store.saveCredentials({
+    ...store.requireCredentials(),
+    accessToken,
+    workspaceKeyHeader,
+    workspaceId,
+    tokenTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
   return { arbi, loginResult, config, workspaceId, accessToken, workspaceKeyHeader };
 }
 
 // src/sse.ts
+var TOOL_LABELS = {
+  search_documents: "Searching documents",
+  get_document_passages: "Reading document",
+  get_table_of_contents: "Getting table of contents",
+  view_document_pages: "Viewing document pages",
+  get_full_document: "Reading full document",
+  web_search: "Searching the web",
+  read_url: "Reading web pages",
+  ask_user: "Asking user",
+  compaction: "Compacting conversation",
+  personal_agent: "Running agent",
+  create_artifact: "Creating artifact",
+  create_plan: "Creating plan",
+  save_skill: "Saving skill",
+  run_code: "Running code"
+};
+var LIFECYCLE_LABELS = {
+  evaluation: "Evaluating results",
+  answering: "Writing answer",
+  reviewing: "Reviewing answer",
+  planning: "Planning",
+  tool_progress: "Working"
+};
+function formatAgentStepLabel(step) {
+  if (step.focus) return step.focus;
+  const detail = step.detail;
+  if (step.step === "tool_progress" && detail && detail.length > 0) {
+    const toolName = detail[0].tool;
+    const label = toolName && TOOL_LABELS[toolName] || LIFECYCLE_LABELS.tool_progress;
+    const message = detail[0].message;
+    return message ? `${label}: ${message}` : label;
+  }
+  if (step.step) {
+    return LIFECYCLE_LABELS[step.step] || step.step;
+  }
+  if (detail && detail.length > 0 && detail[0].tool) {
+    return TOOL_LABELS[detail[0].tool] || detail[0].tool;
+  }
+  return "";
+}
 function parseSSEEvents(chunk, buffer) {
   const combined = buffer + chunk;
   const events = [];
@@ -351,6 +557,11 @@ async function streamSSE(response, callbacks = {}) {
         usage = data.response.usage;
         callbacks.onUsage?.(data.response.usage);
       }
+      if (data.response?.metadata) {
+        const meta = data.response.metadata;
+        metadata = meta;
+        callbacks.onMetadata?.(meta);
+      }
       if (data.t != null) callbacks.onElapsedTime?.(data.t);
       callbacks.onComplete?.();
     },
@@ -363,8 +574,8 @@ async function streamSSE(response, callbacks = {}) {
     // ARBI-specific events (dot-prefixed from server)
     "arbi.agent_step": (raw) => {
       const data = JSON.parse(raw);
-      const focus = data.focus || data.step || "";
-      if (focus) agentSteps.push(focus);
+      const label = formatAgentStepLabel(data);
+      if (label) agentSteps.push(label);
       callbacks.onAgentStep?.(data);
       if (data.t != null) callbacks.onElapsedTime?.(data.t);
     },
@@ -642,16 +853,34 @@ function formatUserName(user) {
 // src/operations/documents.ts
 var documents_exports = {};
 __export(documents_exports, {
+  SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
   deleteDocuments: () => deleteDocuments,
   downloadDocument: () => downloadDocument,
   getDocuments: () => getDocuments,
   getParsedContent: () => getParsedContent,
   listDocuments: () => listDocuments,
+  sanitizeFolderPath: () => sanitizeFolderPath,
   updateDocuments: () => updateDocuments,
   uploadFile: () => uploadFile,
-  uploadLocalFile: () => uploadLocalFile,
+  uploadFiles: () => uploadFiles,
   uploadUrl: () => uploadUrl
 });
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".txt",
+  ".md",
+  ".html",
+  ".doc",
+  ".docx",
+  ".rtf",
+  ".ppt",
+  ".pptx",
+  ".xls",
+  ".xlsx"
+]);
+function sanitizeFolderPath(folderPath) {
+  return folderPath.replace(/[^a-zA-Z0-9_\-/]/g, "_").replace(/_{2,}/g, "_");
+}
 async function listDocuments(arbi) {
   return requireData(await arbi.fetch.GET("/v1/document/list"), "Failed to fetch documents");
 }
@@ -690,22 +919,31 @@ async function getParsedContent(auth, docId, stage) {
   });
   return res.json();
 }
-async function uploadFile(auth, workspaceId, fileData, fileName) {
+async function uploadFile(auth, workspaceId, fileData, fileName, options) {
   const formData = new FormData();
   formData.append("files", fileData, fileName);
+  const params = new URLSearchParams({ workspace_ext_id: workspaceId });
+  if (options?.folder) params.set("folder", sanitizeFolderPath(options.folder));
   const res = await authenticatedFetch({
     ...auth,
-    path: `/v1/document/upload?workspace_ext_id=${workspaceId}`,
+    path: `/v1/document/upload?${params.toString()}`,
     method: "POST",
     body: formData
   });
   return res.json();
 }
-async function uploadLocalFile(auth, workspaceId, filePath) {
-  const fileBuffer = fs__default.default.readFileSync(filePath);
-  const fileName = path__default.default.basename(filePath);
-  const result = await uploadFile(auth, workspaceId, new Blob([fileBuffer]), fileName);
-  return { ...result, fileName };
+async function uploadFiles(auth, workspaceId, files, options) {
+  const formData = new FormData();
+  for (const f of files) formData.append("files", f.data, f.name);
+  const params = new URLSearchParams({ workspace_ext_id: workspaceId });
+  if (options?.folder) params.set("folder", sanitizeFolderPath(options.folder));
+  const res = await authenticatedFetch({
+    ...auth,
+    path: `/v1/document/upload?${params.toString()}`,
+    method: "POST",
+    body: formData
+  });
+  return res.json();
 }
 async function downloadDocument(auth, docId) {
   return authenticatedFetch({
@@ -905,6 +1143,8 @@ async function retrieve(options) {
     input: query,
     workspace_ext_id: workspaceId,
     stream: false,
+    background: false,
+    store: true,
     tools,
     ...model ? { model } : {}
   };
@@ -920,6 +1160,8 @@ async function queryAssistant(options) {
     input: question,
     workspace_ext_id: workspaceId,
     stream: true,
+    background: false,
+    store: true,
     tools: {
       retrieval_chunk: buildRetrievalChunkTool(docIds),
       retrieval_full_context: buildRetrievalFullContextTool([])
@@ -1379,11 +1621,12 @@ var Arbi = class {
       workspaceId ?? this.requireWorkspace(),
       shared
     ),
-    uploadFile: (fileData, fileName, workspaceId) => uploadFile(
+    uploadFile: (fileData, fileName, options) => uploadFile(
       this.getAuthHeaders(),
-      workspaceId ?? this.requireWorkspace(),
+      options?.workspaceId ?? this.requireWorkspace(),
       fileData,
-      fileName
+      fileName,
+      options?.folder ? { folder: options.folder } : void 0
     ),
     download: (docId) => downloadDocument(this.getAuthHeaders(), docId),
     getParsedContent: (docId, stage) => getParsedContent(this.getAuthHeaders(), docId, stage)
@@ -1525,10 +1768,129 @@ var Arbi = class {
   }
 };
 
+// src/operations/documents-node.ts
+var documents_node_exports = {};
+__export(documents_node_exports, {
+  uploadDirectory: () => uploadDirectory,
+  uploadLocalFile: () => uploadLocalFile,
+  uploadZip: () => uploadZip
+});
+function collectFiles(dirPath, baseDir) {
+  const root = baseDir ?? dirPath;
+  const results = [];
+  for (const entry of fs__default.default.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = path2__default.default.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, root));
+    } else if (entry.isFile()) {
+      const ext = path2__default.default.extname(entry.name).toLowerCase();
+      if (SUPPORTED_EXTENSIONS.has(ext)) {
+        results.push({ absolutePath: fullPath, relativePath: path2__default.default.relative(root, fullPath) });
+      }
+    }
+  }
+  return results;
+}
+async function uploadLocalFile(auth, workspaceId, filePath, options) {
+  const fileBuffer = fs__default.default.readFileSync(filePath);
+  const fileName = path2__default.default.basename(filePath);
+  const result = await uploadFile(auth, workspaceId, new Blob([fileBuffer]), fileName, options);
+  return { ...result, fileName };
+}
+async function uploadDirectory(auth, workspaceId, dirPath) {
+  const resolvedDir = path2__default.default.resolve(dirPath);
+  const dirName = path2__default.default.basename(resolvedDir);
+  const entries = collectFiles(resolvedDir);
+  if (entries.length === 0) {
+    return { doc_ext_ids: [], duplicates: [], folders: /* @__PURE__ */ new Map() };
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const relDir = path2__default.default.dirname(entry.relativePath);
+    const folder = relDir === "." ? dirName : `${dirName}/${relDir}`;
+    if (!groups.has(folder)) groups.set(folder, []);
+    groups.get(folder).push({ absolutePath: entry.absolutePath, name: path2__default.default.basename(entry.relativePath) });
+  }
+  const allDocIds = [];
+  const allDuplicates = [];
+  const folders = /* @__PURE__ */ new Map();
+  for (const [folder, files] of groups) {
+    const blobs = files.map((f) => ({
+      data: new Blob([fs__default.default.readFileSync(f.absolutePath)]),
+      name: f.name
+    }));
+    const result = await uploadFiles(auth, workspaceId, blobs, { folder });
+    const dups = result.duplicates ?? [];
+    allDocIds.push(...result.doc_ext_ids);
+    allDuplicates.push(...dups);
+    folders.set(folder, {
+      fileCount: files.length,
+      doc_ext_ids: result.doc_ext_ids,
+      duplicates: dups
+    });
+  }
+  return { doc_ext_ids: allDocIds, duplicates: allDuplicates, folders };
+}
+async function uploadZip(auth, workspaceId, zipPath) {
+  const JSZip = (await import('jszip')).default;
+  const zipBuffer = fs__default.default.readFileSync(zipPath);
+  const zip = await JSZip.loadAsync(zipBuffer);
+  const zipBaseName = path2__default.default.basename(zipPath).replace(/\.zip$/i, "");
+  const entries = [];
+  zip.forEach((relativePath, zipEntry) => {
+    if (zipEntry.dir) return;
+    const ext = path2__default.default.extname(relativePath).toLowerCase();
+    if (SUPPORTED_EXTENSIONS.has(ext)) {
+      entries.push({ zipEntryPath: relativePath, zipEntry });
+    }
+  });
+  if (entries.length === 0) {
+    return { doc_ext_ids: [], duplicates: [], folders: /* @__PURE__ */ new Map() };
+  }
+  const firstParts = new Set(entries.map((e) => e.zipEntryPath.split("/")[0]));
+  const hasSingleRoot = firstParts.size === 1 && entries.every((e) => e.zipEntryPath.includes("/"));
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const data = await entry.zipEntry.async("uint8array");
+    const fileName = path2__default.default.basename(entry.zipEntryPath);
+    const relDir = path2__default.default.dirname(entry.zipEntryPath);
+    let folder;
+    if (hasSingleRoot) {
+      folder = relDir === "." ? zipBaseName : relDir;
+    } else {
+      folder = relDir === "." ? zipBaseName : `${zipBaseName}/${relDir}`;
+    }
+    folder = sanitizeFolderPath(folder);
+    if (!groups.has(folder)) groups.set(folder, []);
+    groups.get(folder).push({ name: fileName, data });
+  }
+  const allDocIds = [];
+  const allDuplicates = [];
+  const folders = /* @__PURE__ */ new Map();
+  for (const [folder, files] of groups) {
+    const blobs = files.map((f) => ({
+      data: new Blob([f.data]),
+      name: f.name
+    }));
+    const result = await uploadFiles(auth, workspaceId, blobs, { folder });
+    const dups = result.duplicates ?? [];
+    allDocIds.push(...result.doc_ext_ids);
+    allDuplicates.push(...dups);
+    folders.set(folder, {
+      fileCount: files.length,
+      doc_ext_ids: result.doc_ext_ids,
+      duplicates: dups
+    });
+  }
+  return { doc_ext_ids: allDocIds, duplicates: allDuplicates, folders };
+}
+
 exports.Arbi = Arbi;
 exports.ArbiApiError = ArbiApiError;
 exports.ArbiError = ArbiError;
 exports.FileConfigStore = FileConfigStore;
+exports.LIFECYCLE_LABELS = LIFECYCLE_LABELS;
+exports.TOOL_LABELS = TOOL_LABELS;
 exports.agentconfig = agentconfig_exports;
 exports.assistant = assistant_exports;
 exports.authenticatedFetch = authenticatedFetch;
@@ -1545,12 +1907,15 @@ exports.createDocumentWaiter = createDocumentWaiter;
 exports.dm = dm_exports;
 exports.doctags = doctags_exports;
 exports.documents = documents_exports;
+exports.documentsNode = documents_node_exports;
 exports.files = files_exports;
+exports.formatAgentStepLabel = formatAgentStepLabel;
 exports.formatFileSize = formatFileSize;
 exports.formatUserName = formatUserName;
 exports.formatWorkspaceChoices = formatWorkspaceChoices;
 exports.formatWsMessage = formatWsMessage;
 exports.generateEncryptedWorkspaceKey = generateEncryptedWorkspaceKey;
+exports.getErrorCode = getErrorCode;
 exports.getErrorMessage = getErrorMessage;
 exports.health = health_exports;
 exports.parseSSEEvents = parseSSEEvents;