@arbidocs/sdk 0.3.9 → 0.3.10

package/dist/browser.cjs

@@ -0,0 +1,1369 @@
+'use strict';
+
+var client = require('@arbidocs/client');
+var fs = require('fs');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var ArbiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArbiError";
+  }
+};
+var ArbiApiError = class extends ArbiError {
+  apiError;
+  constructor(message, apiError) {
+    super(message);
+    this.name = "ArbiApiError";
+    this.apiError = apiError;
+  }
+};
+function requireData(result, message) {
+  if (result.error || !result.data) {
+    throw new ArbiApiError(message, result.error);
+  }
+  return result.data;
+}
+function requireOk(result, message) {
+  if (result.error) {
+    throw new ArbiApiError(message, result.error);
+  }
+}
+function getErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/fetch.ts
+var STATUS_MESSAGES = {
+  401: "Token has expired. Please run: arbi login",
+  503: "The selected LLM is not responding. Please retry or select another model."
+};
+async function authenticatedFetch(options) {
+  const { baseUrl, accessToken, workspaceKeyHeader, path: path2, method, body, headers } = options;
+  const res = await fetch(`${baseUrl}${path2}`, {
+    method: method ?? (body ? "POST" : "GET"),
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "workspace-key": workspaceKeyHeader,
+      ...headers
+    },
+    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}`);
+  }
+  return res;
+}
+function formatWorkspaceChoices(wsList) {
+  return wsList.map((ws) => {
+    const totalDocs = ws.shared_document_count + ws.private_document_count;
+    return {
+      name: `${ws.name} (${totalDocs} docs)`,
+      value: ws.external_id,
+      description: ws.external_id
+    };
+  });
+}
+async function createAuthenticatedClient(config, creds, store) {
+  const arbi = client.createArbiClient({
+    baseUrl: config.baseUrl,
+    deploymentDomain: config.deploymentDomain,
+    credentials: "omit"
+  });
+  await arbi.crypto.initSodium();
+  const signingPrivateKey = client.base64ToBytes(creds.signingPrivateKeyBase64);
+  const loginResult = await arbi.auth.loginWithKey({
+    email: creds.email,
+    signingPrivateKey
+  });
+  store.saveCredentials({
+    ...creds,
+    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+  });
+  return { arbi, loginResult };
+}
+async function performPasswordLogin(config, email, password, store) {
+  const arbi = client.createArbiClient({
+    baseUrl: config.baseUrl,
+    deploymentDomain: config.deploymentDomain,
+    credentials: "omit"
+  });
+  await arbi.crypto.initSodium();
+  const loginResult = await arbi.auth.login({ email, password });
+  store.saveCredentials({
+    email,
+    signingPrivateKeyBase64: arbi.crypto.bytesToBase64(loginResult.signingPrivateKey),
+    serverSessionKeyBase64: arbi.crypto.bytesToBase64(loginResult.serverSessionKey)
+  });
+  return { arbi, loginResult, config };
+}
+async function selectWorkspace(arbi, workspaceId, wrappedKey, serverSessionKey, signingPrivateKeyBase64) {
+  const signingPrivateKey = client.base64ToBytes(signingPrivateKeyBase64);
+  const ed25519PublicKey = signingPrivateKey.slice(32, 64);
+  const encryptionKeyPair = client.deriveEncryptionKeypairFromSigning({
+    publicKey: ed25519PublicKey,
+    secretKey: signingPrivateKey
+  });
+  const workspaceKey = client.sealedBoxDecrypt(wrappedKey, encryptionKeyPair.secretKey);
+  const header = await client.createWorkspaceKeyHeader(workspaceKey, serverSessionKey);
+  arbi.session.setSelectedWorkspace(workspaceId);
+  arbi.session.setCachedWorkspaceHeader(workspaceId, header);
+}
+async function selectWorkspaceById(arbi, workspaceId, serverSessionKey, signingPrivateKeyBase64) {
+  const { data: workspaces, error } = await arbi.fetch.GET("/v1/user/workspaces");
+  if (error || !workspaces) {
+    throw new ArbiError("Failed to fetch workspaces");
+  }
+  const ws = workspaces.find((w) => w.external_id === workspaceId);
+  if (!ws || !ws.wrapped_key) {
+    throw new ArbiError(`Workspace ${workspaceId} not found or has no encryption key`);
+  }
+  await selectWorkspace(
+    arbi,
+    ws.external_id,
+    ws.wrapped_key,
+    serverSessionKey,
+    signingPrivateKeyBase64
+  );
+  const workspaceKeyHeader = arbi.session.getWorkspaceKeyHeader();
+  if (workspaceKeyHeader) {
+    const { data: openResult, error: openError } = await arbi.fetch.POST(
+      "/v1/workspace/{workspace_ext_id}/open",
+      {
+        params: { path: { workspace_ext_id: ws.external_id } },
+        body: { workspace_key: workspaceKeyHeader }
+      }
+    );
+    if (!openError && openResult?.access_token) {
+      arbi.session.setAccessToken(openResult.access_token);
+    }
+  }
+  return { external_id: ws.external_id, name: ws.name, wrapped_key: ws.wrapped_key };
+}
+async function resolveAuth(store) {
+  const config = store.requireConfig();
+  const creds = store.requireCredentials();
+  const { arbi, loginResult } = await createAuthenticatedClient(config, creds, store);
+  return { arbi, loginResult, config };
+}
+async function resolveWorkspace(store, workspaceOpt) {
+  const config = store.requireConfig();
+  const creds = store.requireCredentials();
+  const workspaceId = workspaceOpt || config.selectedWorkspaceId;
+  if (!workspaceId) {
+    throw new ArbiError("No workspace selected. Run: arbi workspace select <id>");
+  }
+  const { arbi, loginResult } = await createAuthenticatedClient(config, creds, store);
+  await selectWorkspaceById(
+    arbi,
+    workspaceId,
+    loginResult.serverSessionKey,
+    creds.signingPrivateKeyBase64
+  );
+  const accessToken = arbi.session.getState().accessToken;
+  const workspaceKeyHeader = arbi.session.getWorkspaceKeyHeader();
+  if (!accessToken || !workspaceKeyHeader) {
+    throw new ArbiError("Authentication error \u2014 missing token or workspace key");
+  }
+  return { arbi, loginResult, config, workspaceId, accessToken, workspaceKeyHeader };
+}
+
+// src/sse.ts
+function parseSSEEvents(chunk, buffer) {
+  const combined = buffer + chunk;
+  const events = [];
+  const parts = combined.split("\n\n");
+  const remaining = parts.pop() || "";
+  for (const part of parts) {
+    if (!part.trim()) continue;
+    let eventType = "";
+    let eventData = "";
+    for (const line of part.split("\n")) {
+      if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+      else if (line.startsWith("data: ")) eventData = line.slice(6);
+    }
+    if (eventType && eventData) events.push({ event: eventType, data: eventData });
+  }
+  return { events, remaining };
+}
+async function streamSSE(response, callbacks = {}) {
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let sseBuffer = "";
+  let text = "";
+  let assistantMessageExtId = null;
+  const agentSteps = [];
+  const errors = [];
+  const artifacts = [];
+  let userMessage = null;
+  let metadata = null;
+  let usage = null;
+  const eventHandlers = {
+    // OpenAI Responses API events (dot-separated names from server)
+    "response.created": (raw) => {
+      const data = JSON.parse(raw);
+      const id = data.response?.id;
+      if (id) assistantMessageExtId = id;
+      callbacks.onStreamStart?.({ assistant_message_ext_id: id });
+      if (data.t != null) callbacks.onElapsedTime?.(data.t);
+    },
+    "response.output_item.added": (raw) => {
+      const data = JSON.parse(raw);
+      callbacks.onOutputItemAdded?.(data);
+    },
+    "response.content_part.added": (raw) => {
+      const data = JSON.parse(raw);
+      callbacks.onContentPartAdded?.(data);
+    },
+    "response.output_text.delta": (raw) => {
+      const data = JSON.parse(raw);
+      if (data.delta) {
+        text += data.delta;
+        callbacks.onToken?.(data.delta);
+      }
+    },
+    "response.output_text.done": (raw) => {
+      const data = JSON.parse(raw);
+      callbacks.onTextDone?.(data.text);
+    },
+    "response.output_item.done": (raw) => {
+      const data = JSON.parse(raw);
+      callbacks.onOutputItemDone?.(data);
+    },
+    "response.completed": (raw) => {
+      const data = JSON.parse(raw);
+      if (data.response?.usage) {
+        usage = data.response.usage;
+        callbacks.onUsage?.(data.response.usage);
+      }
+      if (data.t != null) callbacks.onElapsedTime?.(data.t);
+      callbacks.onComplete?.();
+    },
+    "response.failed": (raw) => {
+      const data = JSON.parse(raw);
+      const message = data.response?.error?.message || "Unknown streaming error";
+      errors.push(message);
+      callbacks.onError?.(message);
+    },
+    // 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);
+      callbacks.onAgentStep?.(data);
+      if (data.t != null) callbacks.onElapsedTime?.(data.t);
+    },
+    "arbi.user_message": (raw) => {
+      const data = JSON.parse(raw);
+      userMessage = data;
+      callbacks.onUserMessage?.(data);
+    },
+    "arbi.message_metadata": (raw) => {
+      const data = JSON.parse(raw);
+      metadata = data;
+      callbacks.onMetadata?.(data);
+    },
+    "arbi.user_input_request": (raw) => {
+      const data = JSON.parse(raw);
+      callbacks.onUserInputRequest?.(data);
+    },
+    "arbi.artifact": (raw) => {
+      const data = JSON.parse(raw);
+      artifacts.push(data);
+      callbacks.onArtifact?.(data);
+    },
+    "response.complete": () => {
+      callbacks.onComplete?.();
+    }
+  };
+  const processEvents = (events) => {
+    for (const { event, data } of events) {
+      try {
+        const handler = eventHandlers[event];
+        if (handler) handler(data);
+      } catch {
+      }
+    }
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const { events, remaining } = parseSSEEvents(decoder.decode(value, { stream: true }), sseBuffer);
+    sseBuffer = remaining;
+    processEvents(events);
+  }
+  if (sseBuffer.trim()) {
+    const { events } = parseSSEEvents(sseBuffer + "\n\n", "");
+    processEvents(events);
+  }
+  return {
+    text,
+    assistantMessageExtId,
+    agentSteps,
+    errors,
+    userMessage,
+    metadata,
+    artifacts,
+    usage
+  };
+}
+var consumeSSEStream = streamSSE;
+var AUTH_TIMEOUT_MS = 1e4;
+var MAX_BACKOFF_MS = 3e4;
+function connectWebSocket(options) {
+  const { baseUrl, accessToken, onMessage, onClose } = options;
+  const url = client.buildWebSocketUrl(baseUrl);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    let authenticated = false;
+    const timeout = setTimeout(() => {
+      if (!authenticated) {
+        ws.close();
+        reject(new Error("WebSocket auth timed out"));
+      }
+    }, AUTH_TIMEOUT_MS);
+    ws.addEventListener("open", () => {
+      ws.send(client.createAuthMessage(accessToken));
+    });
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data);
+      const msg = client.parseServerMessage(data);
+      if (!msg) return;
+      if (!authenticated) {
+        if (client.isMessageType(msg, "auth_result")) {
+          clearTimeout(timeout);
+          if (msg.success) {
+            authenticated = true;
+            resolve({ close: () => ws.close() });
+          } else {
+            ws.close();
+            reject(new Error(`WebSocket auth failed: ${msg.reason || "unknown"}`));
+          }
+        }
+        return;
+      }
+      onMessage(msg);
+    });
+    ws.addEventListener("close", (event) => {
+      clearTimeout(timeout);
+      if (!authenticated) {
+        reject(new Error(`WebSocket closed before auth (code ${event.code})`));
+        return;
+      }
+      onClose?.(event.code, event.reason);
+    });
+    ws.addEventListener("error", () => {
+    });
+  });
+}
+async function connectWithReconnect(options) {
+  const {
+    maxRetries = 10,
+    initialDelayMs = 1e3,
+    onReconnecting,
+    onReconnected,
+    onReconnectFailed,
+    onClose,
+    ...connectOpts
+  } = options;
+  let closed = false;
+  let reconnectTimer = null;
+  let currentConnection = null;
+  const scheduleReconnect = async () => {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      if (closed) return;
+      const delay = Math.min(initialDelayMs * Math.pow(2, attempt - 1), MAX_BACKOFF_MS);
+      onReconnecting?.(attempt, maxRetries);
+      await new Promise((resolve) => {
+        reconnectTimer = setTimeout(resolve, delay);
+      });
+      if (closed) return;
+      try {
+        currentConnection = await connectWebSocket({
+          ...connectOpts,
+          onClose: (code, reason) => {
+            currentConnection = null;
+            onClose?.(code, reason);
+            if (!closed) scheduleReconnect();
+          }
+        });
+        onReconnected?.();
+        return;
+      } catch {
+      }
+    }
+    if (!closed) onReconnectFailed?.();
+  };
+  currentConnection = await connectWebSocket({
+    ...connectOpts,
+    onClose: (code, reason) => {
+      currentConnection = null;
+      onClose?.(code, reason);
+      if (!closed) scheduleReconnect();
+    }
+  });
+  return {
+    close: () => {
+      closed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      currentConnection?.close();
+      currentConnection = null;
+    }
+  };
+}
+
+// src/format.ts
+function formatFileSize(bytes, fallback = "N/A") {
+  if (bytes === null || bytes === void 0) return fallback;
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function formatUserName(user) {
+  if (!user) return "";
+  return [user.given_name, user.family_name].filter(Boolean).join(" ");
+}
+
+// src/operations/documents.ts
+var documents_exports = {};
+__export(documents_exports, {
+  deleteDocuments: () => deleteDocuments,
+  downloadDocument: () => downloadDocument,
+  getDocuments: () => getDocuments,
+  getParsedContent: () => getParsedContent,
+  listDocuments: () => listDocuments,
+  updateDocuments: () => updateDocuments,
+  uploadFile: () => uploadFile,
+  uploadLocalFile: () => uploadLocalFile,
+  uploadUrl: () => uploadUrl
+});
+async function listDocuments(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/document/list"), "Failed to fetch documents");
+}
+async function getDocuments(arbi, externalIds) {
+  return requireData(
+    await arbi.fetch.GET("/v1/document/", { params: { query: { external_ids: externalIds } } }),
+    "Failed to fetch documents"
+  );
+}
+async function deleteDocuments(arbi, externalIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/document/", { body: { external_ids: externalIds } }),
+    "Failed to delete documents"
+  );
+}
+async function updateDocuments(arbi, documents) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/document/", { body: { documents } }),
+    "Failed to update documents"
+  );
+}
+async function uploadUrl(arbi, urls, workspaceId, shared = false) {
+  return requireData(
+    await arbi.fetch.POST("/v1/document/upload-url", {
+      params: {
+        query: { urls, workspace_ext_id: workspaceId, shared }
+      }
+    }),
+    "Failed to upload from URLs"
+  );
+}
+async function getParsedContent(auth, docId, stage) {
+  const res = await authenticatedFetch({
+    ...auth,
+    path: `/v1/document/${docId}/parsed-${stage}`
+  });
+  return res.json();
+}
+async function uploadFile(auth, workspaceId, fileData, fileName) {
+  const formData = new FormData();
+  formData.append("files", fileData, fileName);
+  const res = await authenticatedFetch({
+    ...auth,
+    path: `/v1/document/upload?workspace_ext_id=${workspaceId}`,
+    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 downloadDocument(auth, docId) {
+  return authenticatedFetch({
+    ...auth,
+    path: `/v1/document/${docId}/download`
+  });
+}
+
+// src/operations/workspaces.ts
+var workspaces_exports = {};
+__export(workspaces_exports, {
+  addWorkspaceUsers: () => addWorkspaceUsers,
+  copyDocuments: () => copyDocuments,
+  createWorkspace: () => createWorkspace,
+  deleteWorkspaces: () => deleteWorkspaces,
+  listWorkspaceUsers: () => listWorkspaceUsers,
+  listWorkspaces: () => listWorkspaces,
+  removeWorkspaceUsers: () => removeWorkspaceUsers,
+  setUserRole: () => setUserRole,
+  updateWorkspace: () => updateWorkspace
+});
+async function listWorkspaces(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/user/workspaces"), "Failed to fetch workspaces");
+}
+async function createWorkspace(arbi, name, description, isPublic = false) {
+  return requireData(
+    await arbi.fetch.POST("/v1/workspace/create_protected", {
+      body: { name, description: description ?? null, is_public: isPublic }
+    }),
+    "Failed to create workspace"
+  );
+}
+async function deleteWorkspaces(arbi, workspaceIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/workspace/", {
+      body: { external_ids: workspaceIds }
+    }),
+    "Failed to delete workspace(s)"
+  );
+}
+async function updateWorkspace(arbi, body) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/workspace/", { body }),
+    "Failed to update workspace"
+  );
+}
+async function listWorkspaceUsers(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/workspace/users"), "Failed to fetch workspace users");
+}
+async function addWorkspaceUsers(arbi, emails, role = "collaborator") {
+  return requireData(
+    await arbi.fetch.POST("/v1/workspace/users", {
+      body: { emails, role }
+    }),
+    "Failed to add users"
+  );
+}
+async function removeWorkspaceUsers(arbi, userIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/workspace/users", {
+      body: { users: userIds.map((id) => ({ user_ext_id: id })) }
+    }),
+    "Failed to remove users"
+  );
+}
+async function setUserRole(arbi, userIds, role) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/workspace/users", {
+      body: { user_ext_ids: userIds, role }
+    }),
+    "Failed to update roles"
+  );
+}
+async function copyDocuments(arbi, targetWorkspaceId, docIds, targetWorkspaceKey) {
+  return requireData(
+    await arbi.fetch.POST("/v1/workspace/copy", {
+      body: {
+        target_workspace_ext_id: targetWorkspaceId,
+        target_workspace_key: targetWorkspaceKey,
+        items: docIds
+      }
+    }),
+    "Failed to copy documents"
+  );
+}
+
+// src/operations/conversations.ts
+var conversations_exports = {};
+__export(conversations_exports, {
+  deleteConversation: () => deleteConversation,
+  deleteMessage: () => deleteMessage,
+  getConversationThreads: () => getConversationThreads,
+  getMessage: () => getMessage,
+  listConversations: () => listConversations,
+  shareConversation: () => shareConversation,
+  updateConversationTitle: () => updateConversationTitle
+});
+async function listConversations(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/conversation/list"), "Failed to fetch conversations");
+}
+async function getConversationThreads(arbi, conversationId) {
+  return requireData(
+    await arbi.fetch.GET("/v1/conversation/{conversation_ext_id}/threads", {
+      params: { path: { conversation_ext_id: conversationId } }
+    }),
+    "Failed to fetch threads"
+  );
+}
+async function deleteConversation(arbi, conversationId) {
+  return requireData(
+    await arbi.fetch.DELETE("/v1/conversation/{conversation_ext_id}", {
+      params: { path: { conversation_ext_id: conversationId } }
+    }),
+    "Failed to delete conversation"
+  );
+}
+async function shareConversation(arbi, conversationId) {
+  return requireData(
+    await arbi.fetch.POST("/v1/conversation/{conversation_ext_id}/share", {
+      params: { path: { conversation_ext_id: conversationId } }
+    }),
+    "Failed to share conversation"
+  );
+}
+async function updateConversationTitle(arbi, conversationId, title) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/conversation/{conversation_ext_id}/title", {
+      params: { path: { conversation_ext_id: conversationId } },
+      body: { title }
+    }),
+    "Failed to update title"
+  );
+}
+async function getMessage(arbi, messageId) {
+  return requireData(
+    await arbi.fetch.GET("/v1/conversation/message/{message_ext_id}", {
+      params: { path: { message_ext_id: messageId } }
+    }),
+    "Failed to fetch message"
+  );
+}
+async function deleteMessage(arbi, messageId) {
+  return requireData(
+    await arbi.fetch.DELETE("/v1/conversation/message/{message_ext_id}", {
+      params: { path: { message_ext_id: messageId } }
+    }),
+    "Failed to delete message"
+  );
+}
+
+// src/operations/assistant.ts
+var assistant_exports = {};
+__export(assistant_exports, {
+  buildRetrievalChunkTool: () => buildRetrievalChunkTool,
+  buildRetrievalFullContextTool: () => buildRetrievalFullContextTool,
+  buildRetrievalTocTool: () => buildRetrievalTocTool,
+  queryAssistant: () => queryAssistant,
+  respondToAgent: () => respondToAgent,
+  retrieve: () => retrieve
+});
+function buildRetrievalChunkTool(docIds, searchMode) {
+  return {
+    name: "retrieval_chunk",
+    description: "retrieval chunk",
+    tool_args: { doc_ext_ids: docIds, ...searchMode ? { search_mode: searchMode } : {} },
+    tool_responses: {}
+  };
+}
+function buildRetrievalFullContextTool(docIds) {
+  return {
+    name: "retrieval_full_context",
+    description: "retrieval full context",
+    tool_args: { doc_ext_ids: docIds },
+    tool_responses: {}
+  };
+}
+function buildRetrievalTocTool(docIds) {
+  return {
+    name: "retrieval_toc",
+    description: "retrieval toc",
+    tool_args: { doc_ext_ids: docIds },
+    tool_responses: {}
+  };
+}
+async function retrieve(options) {
+  const { arbi, workspaceId, query, docIds, searchMode, fullContextDocIds, tocDocIds, model } = options;
+  const tools = {
+    retrieval_chunk: buildRetrievalChunkTool(docIds, searchMode)
+  };
+  if (fullContextDocIds && fullContextDocIds.length > 0) {
+    tools.retrieval_full_context = buildRetrievalFullContextTool(fullContextDocIds);
+  }
+  if (tocDocIds && tocDocIds.length > 0) {
+    tools.retrieval_toc = buildRetrievalTocTool(tocDocIds);
+  }
+  const body = {
+    input: query,
+    workspace_ext_id: workspaceId,
+    stream: false,
+    tools,
+    ...model ? { model } : {}
+  };
+  const { data, error } = await arbi.fetch.POST("/v1/assistant/retrieve", { body });
+  if (error) {
+    throw new Error(`Retrieve failed: ${JSON.stringify(error)}`);
+  }
+  return data;
+}
+async function queryAssistant(options) {
+  const { workspaceId, question, docIds, previousResponseId, model, ...auth } = options;
+  const body = {
+    input: question,
+    workspace_ext_id: workspaceId,
+    stream: true,
+    tools: {
+      retrieval_chunk: buildRetrievalChunkTool(docIds),
+      retrieval_full_context: buildRetrievalFullContextTool([])
+    },
+    ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+    ...model ? { model } : {}
+  };
+  return authenticatedFetch({
+    ...auth,
+    path: "/v1/assistant/query",
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: { "Content-Type": "application/json" }
+  });
+}
+async function respondToAgent(arbi, assistantMessageExtId, answer) {
+  return requireData(
+    await arbi.fetch.POST("/v1/assistant/respond", {
+      body: { assistant_message_ext_id: assistantMessageExtId, answer }
+    }),
+    "Failed to respond to agent"
+  );
+}
+
+// src/operations/tags.ts
+var tags_exports = {};
+__export(tags_exports, {
+  createTag: () => createTag,
+  deleteTag: () => deleteTag,
+  listTags: () => listTags,
+  updateTag: () => updateTag
+});
+async function listTags(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/tag/list"), "Failed to fetch tags");
+}
+async function createTag(arbi, options) {
+  return requireData(
+    await arbi.fetch.POST("/v1/tag/", {
+      body: {
+        name: options.name,
+        tag_type: options.tagType ?? { type: "checkbox", options: [] },
+        instruction: options.instruction ?? null,
+        shared: options.shared ?? false
+      }
+    }),
+    "Failed to create tag"
+  );
+}
+async function deleteTag(arbi, tagId) {
+  return requireData(
+    await arbi.fetch.DELETE("/v1/tag/{tag_ext_id}", {
+      params: { path: { tag_ext_id: tagId } }
+    }),
+    "Failed to delete tag"
+  );
+}
+async function updateTag(arbi, tagId, body) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/tag/{tag_ext_id}", {
+      params: { path: { tag_ext_id: tagId } },
+      body
+    }),
+    "Failed to update tag"
+  );
+}
+
+// src/operations/contacts.ts
+var contacts_exports = {};
+__export(contacts_exports, {
+  addContacts: () => addContacts,
+  groupContactsByStatus: () => groupContactsByStatus,
+  listContacts: () => listContacts,
+  removeContacts: () => removeContacts
+});
+async function listContacts(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/user/contacts"), "Failed to fetch contacts");
+}
+async function addContacts(arbi, emails) {
+  return requireData(
+    await arbi.fetch.POST("/v1/user/contacts", { body: { emails } }),
+    "Failed to add contacts"
+  );
+}
+async function removeContacts(arbi, contactIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/user/contacts", { body: { contact_ids: contactIds } }),
+    "Failed to remove contacts"
+  );
+}
+function groupContactsByStatus(contactList) {
+  const registered = [];
+  const pending = [];
+  for (const c of contactList) {
+    if (c.status === "registered") {
+      registered.push(c);
+    } else {
+      pending.push(c);
+    }
+  }
+  return { registered, pending };
+}
+
+// src/operations/doctags.ts
+var doctags_exports = {};
+__export(doctags_exports, {
+  assignDocTags: () => assignDocTags,
+  generateDocTags: () => generateDocTags,
+  removeDocTags: () => removeDocTags,
+  updateDocTag: () => updateDocTag
+});
+async function assignDocTags(arbi, tagId, docIds, note) {
+  return requireData(
+    await arbi.fetch.POST("/v1/document/doctag", {
+      body: { tag_ext_id: tagId, doc_ext_ids: docIds, note: note ?? null }
+    }),
+    "Failed to create doctags"
+  );
+}
+async function removeDocTags(arbi, tagId, docIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/document/doctag", {
+      body: { tag_ext_id: tagId, doc_ext_ids: docIds }
+    }),
+    "Failed to delete doctags"
+  );
+}
+async function updateDocTag(arbi, tagId, docId, updates) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/document/doctag", {
+      body: { tag_ext_id: tagId, doc_ext_id: docId, ...updates }
+    }),
+    "Failed to update doctag"
+  );
+}
+async function generateDocTags(arbi, tagIds, docIds) {
+  return requireData(
+    await arbi.fetch.POST("/v1/document/doctag/generate", {
+      body: { tag_ext_ids: tagIds, doc_ext_ids: docIds }
+    }),
+    "Failed to generate doctags"
+  );
+}
+
+// src/operations/dm.ts
+var dm_exports = {};
+__export(dm_exports, {
+  deleteDMs: () => deleteDMs,
+  listDMs: () => listDMs,
+  markRead: () => markRead,
+  sendDM: () => sendDM
+});
+async function listDMs(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/notifications/"), "Failed to fetch messages");
+}
+async function sendDM(arbi, messages) {
+  return requireData(
+    await arbi.fetch.POST("/v1/notifications/", {
+      body: { messages }
+    }),
+    "Failed to send message"
+  );
+}
+async function markRead(arbi, messageIds) {
+  return requireData(
+    await arbi.fetch.PATCH("/v1/notifications/", {
+      body: { updates: messageIds.map((id) => ({ external_id: id, read: true })) }
+    }),
+    "Failed to update messages"
+  );
+}
+async function deleteDMs(arbi, messageIds) {
+  requireOk(
+    await arbi.fetch.DELETE("/v1/notifications/", { body: { external_ids: messageIds } }),
+    "Failed to delete messages"
+  );
+}
+
+// src/operations/settings.ts
+var settings_exports = {};
+__export(settings_exports, {
+  getSettings: () => getSettings,
+  updateSettings: () => updateSettings
+});
+async function getSettings(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/user/settings"), "Failed to fetch settings");
+}
+async function updateSettings(arbi, body) {
+  requireOk(await arbi.fetch.PATCH("/v1/user/settings", { body }), "Failed to update settings");
+}
+
+// src/operations/agentconfig.ts
+var agentconfig_exports = {};
+__export(agentconfig_exports, {
+  deleteConfig: () => deleteConfig,
+  getConfig: () => getConfig,
+  getModels: () => getModels,
+  getSchema: () => getSchema,
+  listConfigs: () => listConfigs,
+  saveConfig: () => saveConfig
+});
+async function listConfigs(arbi) {
+  return requireData(
+    await arbi.fetch.GET("/v1/configs/versions"),
+    "Failed to fetch config versions"
+  );
+}
+async function getConfig(arbi, configId) {
+  return requireData(
+    await arbi.fetch.GET("/v1/configs/{config_ext_id}", {
+      params: { path: { config_ext_id: configId } }
+    }),
+    "Failed to fetch configuration"
+  );
+}
+async function saveConfig(arbi, body) {
+  return requireData(
+    await arbi.fetch.POST("/v1/configs/", { body }),
+    "Failed to save configuration"
+  );
+}
+async function deleteConfig(arbi, configId) {
+  return requireData(
+    await arbi.fetch.DELETE("/v1/configs/{config_ext_id}", {
+      params: { path: { config_ext_id: configId } }
+    }),
+    "Failed to delete configuration"
+  );
+}
+async function getSchema(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/configs/schema"), "Failed to fetch config schema");
+}
+async function getModels(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/health/models"), "Failed to fetch models");
+}
+
+// src/operations/health.ts
+var health_exports = {};
+__export(health_exports, {
+  getHealth: () => getHealth,
+  getHealthModels: () => getHealthModels,
+  getMcpTools: () => getMcpTools,
+  getRemoteModels: () => getRemoteModels
+});
+async function getHealth(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/health/"), "Failed to fetch health status");
+}
+async function getHealthModels(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/health/models"), "Failed to fetch models");
+}
+async function getRemoteModels(arbi) {
+  return requireData(
+    await arbi.fetch.GET("/v1/health/remote-models"),
+    "Failed to fetch remote models"
+  );
+}
+async function getMcpTools(arbi) {
+  return requireData(await arbi.fetch.GET("/v1/health/mcp-tools"), "Failed to fetch MCP tools");
+}
+
+// src/operations/files.ts
+var files_exports = {};
+__export(files_exports, {
+  deleteFile: () => deleteFile,
+  getFile: () => getFile,
+  getFileContent: () => getFileContent,
+  listFiles: () => listFiles,
+  uploadFile: () => uploadFile2
+});
+async function listFiles(arbi, options) {
+  return requireData(
+    await arbi.fetch.GET("/v1/files", {
+      params: { query: options ?? {} }
+    }),
+    "Failed to list files"
+  );
+}
+async function getFile(arbi, fileId) {
+  return requireData(
+    await arbi.fetch.GET("/v1/files/{file_id}", {
+      params: { path: { file_id: fileId } }
+    }),
+    "Failed to get file"
+  );
+}
+async function deleteFile(arbi, fileId) {
+  return requireData(
+    await arbi.fetch.DELETE("/v1/files/{file_id}", {
+      params: { path: { file_id: fileId } }
+    }),
+    "Failed to delete file"
+  );
+}
+async function uploadFile2(auth, fileData, fileName, purpose = "assistants") {
+  const formData = new FormData();
+  formData.append("file", fileData, fileName);
+  formData.append("purpose", purpose);
+  const res = await authenticatedFetch({
+    ...auth,
+    path: "/v1/files",
+    method: "POST",
+    body: formData
+  });
+  return res.json();
+}
+async function getFileContent(auth, fileId) {
+  return authenticatedFetch({
+    ...auth,
+    path: `/v1/files/${fileId}/content`
+  });
+}
+
+// src/arbi.ts
+var Arbi = class {
+  client = null;
+  loginResult = null;
+  currentWorkspaceId = null;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+  /** Initialize the SDK client and sodium crypto. Called automatically by login(). */
+  async init() {
+    if (this.client) return this.client;
+    const domain = this.options.deploymentDomain ?? new URL(this.options.url).hostname;
+    this.client = client.createArbiClient({
+      baseUrl: this.options.url,
+      deploymentDomain: domain,
+      credentials: this.options.credentials ?? "omit"
+    });
+    await this.client.crypto.initSodium();
+    return this.client;
+  }
+  /**
+   * Request a verification email for registration.
+   * The user will receive an email with a 3-word verification code.
+   */
+  async requestVerification(email) {
+    const client = await this.init();
+    await client.fetch.POST("/v1/user/verify-email", { body: { email } });
+  }
+  /**
+   * Register a new account using the verification code received by email.
+   */
+  async register(params) {
+    const client = await this.init();
+    await client.auth.register(params);
+  }
+  /**
+   * Log in with email and password.
+   * Initializes the SDK client if not already done.
+   */
+  async login(email, password) {
+    const client = await this.init();
+    this.loginResult = await client.auth.login({ email, password });
+  }
+  /**
+   * Recover a session using a stored signing private key (base64).
+   * Useful for session recovery without re-entering the password.
+   */
+  async loginWithKey(email, signingPrivateKeyBase64) {
+    const client = await this.init();
+    const signingPrivateKey = client.crypto.base64ToBytes(signingPrivateKeyBase64);
+    this.loginResult = await client.auth.loginWithKey({ email, signingPrivateKey });
+  }
+  /**
+   * Select a workspace by ID. Fetches the workspace list, finds the matching
+   * workspace, decrypts the wrapped key, and sets up auth headers.
+   */
+  async selectWorkspace(workspaceId) {
+    const client = this.requireClient();
+    const lr = this.requireLogin();
+    const allWorkspaces = await listWorkspaces(client);
+    const ws = allWorkspaces.find((w) => w.external_id === workspaceId);
+    if (!ws || !ws.wrapped_key) {
+      throw new ArbiError(`Workspace ${workspaceId} not found or has no encryption key`);
+    }
+    const signingPrivateKeyBase64 = client.crypto.bytesToBase64(lr.signingPrivateKey);
+    await selectWorkspace(
+      client,
+      ws.external_id,
+      ws.wrapped_key,
+      lr.serverSessionKey,
+      signingPrivateKeyBase64
+    );
+    this.currentWorkspaceId = ws.external_id;
+  }
+  /** Log out and clear internal state. */
+  async logout() {
+    if (this.client) {
+      await this.client.auth.logout();
+    }
+    if (this.loginResult) {
+      this.loginResult.signingPrivateKey.fill(0);
+      this.loginResult.serverSessionKey.fill(0);
+    }
+    this.loginResult = null;
+    this.currentWorkspaceId = null;
+  }
+  // ── Accessors ─────────────────────────────────────────────────────────
+  /** Get the underlying ArbiClient (throws if not initialized). */
+  getClient() {
+    return this.requireClient();
+  }
+  /** Get the current workspace ID (throws if none selected). */
+  getWorkspaceId() {
+    return this.requireWorkspace();
+  }
+  /** Check if the user is logged in. */
+  get isLoggedIn() {
+    return this.loginResult !== null;
+  }
+  /** Check if a workspace is selected. */
+  get hasWorkspace() {
+    return this.currentWorkspaceId !== null;
+  }
+  // ── Auth headers (for raw fetch operations) ───────────────────────────
+  getAuthHeaders() {
+    const client = this.requireClient();
+    const accessToken = client.session.getState().accessToken;
+    const workspaceKeyHeader = client.session.getWorkspaceKeyHeader();
+    if (!accessToken || !workspaceKeyHeader) {
+      throw new ArbiError("Missing access token or workspace key header");
+    }
+    return {
+      baseUrl: this.options.url,
+      accessToken,
+      workspaceKeyHeader
+    };
+  }
+  // ── Workspaces ────────────────────────────────────────────────────────
+  workspaces = {
+    list: () => listWorkspaces(this.requireClient()),
+    create: (name, description, isPublic) => createWorkspace(this.requireClient(), name, description, isPublic),
+    delete: (workspaceIds) => deleteWorkspaces(this.requireClient(), workspaceIds),
+    update: (body) => updateWorkspace(this.requireClient(), body),
+    listUsers: () => listWorkspaceUsers(this.requireClient()),
+    addUsers: (emails, role) => addWorkspaceUsers(this.requireClient(), emails, role),
+    removeUsers: (userIds) => removeWorkspaceUsers(this.requireClient(), userIds),
+    setUserRole: (userIds, role) => setUserRole(this.requireClient(), userIds, role),
+    copyDocuments: (targetWorkspaceId, docIds, targetWorkspaceKey) => copyDocuments(
+      this.requireClient(),
+      targetWorkspaceId,
+      docIds,
+      targetWorkspaceKey
+    )
+  };
+  // ── Documents ─────────────────────────────────────────────────────────
+  documents = {
+    list: () => listDocuments(this.requireClient()),
+    get: (externalIds) => getDocuments(this.requireClient(), externalIds),
+    delete: (externalIds) => deleteDocuments(this.requireClient(), externalIds),
+    update: (documents) => updateDocuments(this.requireClient(), documents),
+    uploadUrl: (urls, shared, workspaceId) => uploadUrl(
+      this.requireClient(),
+      urls,
+      workspaceId ?? this.requireWorkspace(),
+      shared
+    ),
+    uploadFile: (fileData, fileName, workspaceId) => uploadFile(
+      this.getAuthHeaders(),
+      workspaceId ?? this.requireWorkspace(),
+      fileData,
+      fileName
+    ),
+    download: (docId) => downloadDocument(this.getAuthHeaders(), docId),
+    getParsedContent: (docId, stage) => getParsedContent(this.getAuthHeaders(), docId, stage)
+  };
+  // ── Conversations ─────────────────────────────────────────────────────
+  conversations = {
+    list: () => listConversations(this.requireClient()),
+    getThreads: (conversationId) => getConversationThreads(this.requireClient(), conversationId),
+    delete: (conversationId) => deleteConversation(this.requireClient(), conversationId),
+    share: (conversationId) => shareConversation(this.requireClient(), conversationId),
+    updateTitle: (conversationId, title) => updateConversationTitle(this.requireClient(), conversationId, title),
+    getMessage: (messageId) => getMessage(this.requireClient(), messageId),
+    deleteMessage: (messageId) => deleteMessage(this.requireClient(), messageId)
+  };
+  // ── Assistant ─────────────────────────────────────────────────────────
+  assistant = {
+    /**
+     * Send a question to the RAG assistant with streaming support.
+     * Returns the accumulated result after the stream completes.
+     */
+    query: async (question, options) => {
+      const auth = this.getAuthHeaders();
+      const workspaceId = this.requireWorkspace();
+      const response = await queryAssistant({
+        ...auth,
+        workspaceId,
+        question,
+        docIds: options.docIds,
+        previousResponseId: options.previousResponseId,
+        model: options.model
+      });
+      const callbacks = {
+        onToken: options.onToken,
+        onStreamStart: options.onStreamStart,
+        onAgentStep: options.onAgentStep,
+        onError: options.onError,
+        onUserMessage: options.onUserMessage,
+        onMetadata: options.onMetadata,
+        onUserInputRequest: options.onUserInputRequest,
+        onArtifact: options.onArtifact,
+        onElapsedTime: options.onElapsedTime,
+        onComplete: options.onComplete
+      };
+      return streamSSE(response, callbacks);
+    },
+    /**
+     * Respond to an agent's question during a human-in-the-loop workflow.
+     */
+    respond: (assistantMessageExtId, answer) => respondToAgent(this.requireClient(), assistantMessageExtId, answer),
+    /**
+     * Search documents without LLM generation (retrieval only).
+     */
+    retrieve: (query, docIds, options) => retrieve({
+      arbi: this.requireClient(),
+      workspaceId: this.requireWorkspace(),
+      query,
+      docIds,
+      ...options
+    })
+  };
+  // ── Tags ──────────────────────────────────────────────────────────────
+  tags = {
+    list: () => listTags(this.requireClient()),
+    create: (options) => createTag(this.requireClient(), {
+      ...options,
+      workspaceId: options.workspaceId ?? this.requireWorkspace()
+    }),
+    delete: (tagId) => deleteTag(this.requireClient(), tagId),
+    update: (tagId, body) => updateTag(this.requireClient(), tagId, body)
+  };
+  // ── Document Tags ─────────────────────────────────────────────────────
+  doctags = {
+    assign: (tagId, docIds, note) => assignDocTags(this.requireClient(), tagId, docIds, note),
+    remove: (tagId, docIds) => removeDocTags(this.requireClient(), tagId, docIds),
+    update: (tagId, docId, updates) => updateDocTag(this.requireClient(), tagId, docId, updates),
+    generate: (tagIds, docIds) => generateDocTags(this.requireClient(), tagIds, docIds)
+  };
+  // ── Contacts ──────────────────────────────────────────────────────────
+  contacts = {
+    list: () => listContacts(this.requireClient()),
+    add: (emails) => addContacts(this.requireClient(), emails),
+    remove: (contactIds) => removeContacts(this.requireClient(), contactIds),
+    groupByStatus: groupContactsByStatus
+  };
+  // ── Direct Messages ───────────────────────────────────────────────────
+  dm = {
+    list: () => listDMs(this.requireClient()),
+    send: (messages) => sendDM(this.requireClient(), messages),
+    markRead: (messageIds) => markRead(this.requireClient(), messageIds),
+    delete: (messageIds) => deleteDMs(this.requireClient(), messageIds)
+  };
+  // ── Settings ──────────────────────────────────────────────────────────
+  settings = {
+    get: () => getSettings(this.requireClient()),
+    update: (body) => updateSettings(this.requireClient(), body)
+  };
+  // ── Agent Configuration ───────────────────────────────────────────────
+  agentConfig = {
+    list: () => listConfigs(this.requireClient()),
+    get: (configId) => getConfig(this.requireClient(), configId),
+    save: (body) => saveConfig(this.requireClient(), body),
+    delete: (configId) => deleteConfig(this.requireClient(), configId),
+    getSchema: () => getSchema(this.requireClient()),
+    getModels: () => getModels(this.requireClient())
+  };
+  // ── Health ────────────────────────────────────────────────────────────
+  health = {
+    check: () => getHealth(this.requireClient()),
+    models: () => getHealthModels(this.requireClient()),
+    remoteModels: () => getRemoteModels(this.requireClient()),
+    mcpTools: () => getMcpTools(this.requireClient())
+  };
+  // ── Files (OpenAI-compatible) ────────────────────────────────────────
+  files = {
+    list: (options) => listFiles(this.requireClient(), options),
+    get: (fileId) => getFile(this.requireClient(), fileId),
+    delete: (fileId) => deleteFile(this.requireClient(), fileId),
+    upload: (fileData, fileName, purpose) => uploadFile2(this.getAuthHeaders(), fileData, fileName, purpose),
+    getContent: (fileId) => getFileContent(this.getAuthHeaders(), fileId)
+  };
+  // ── Internal guards ───────────────────────────────────────────────────
+  requireClient() {
+    if (!this.client) {
+      throw new ArbiError("Not initialized. Call login() or init() first.");
+    }
+    return this.client;
+  }
+  requireLogin() {
+    if (!this.loginResult) {
+      throw new ArbiError("Not logged in. Call login() first.");
+    }
+    return this.loginResult;
+  }
+  requireWorkspace() {
+    if (!this.currentWorkspaceId) {
+      throw new ArbiError("No workspace selected. Call selectWorkspace() first.");
+    }
+    return this.currentWorkspaceId;
+  }
+};
+
+exports.Arbi = Arbi;
+exports.ArbiApiError = ArbiApiError;
+exports.ArbiError = ArbiError;
+exports.agentconfig = agentconfig_exports;
+exports.assistant = assistant_exports;
+exports.authenticatedFetch = authenticatedFetch;
+exports.buildRetrievalChunkTool = buildRetrievalChunkTool;
+exports.buildRetrievalFullContextTool = buildRetrievalFullContextTool;
+exports.buildRetrievalTocTool = buildRetrievalTocTool;
+exports.connectWebSocket = connectWebSocket;
+exports.connectWithReconnect = connectWithReconnect;
+exports.consumeSSEStream = consumeSSEStream;
+exports.contacts = contacts_exports;
+exports.conversations = conversations_exports;
+exports.createAuthenticatedClient = createAuthenticatedClient;
+exports.dm = dm_exports;
+exports.doctags = doctags_exports;
+exports.documents = documents_exports;
+exports.files = files_exports;
+exports.formatFileSize = formatFileSize;
+exports.formatUserName = formatUserName;
+exports.formatWorkspaceChoices = formatWorkspaceChoices;
+exports.getErrorMessage = getErrorMessage;
+exports.health = health_exports;
+exports.parseSSEEvents = parseSSEEvents;
+exports.performPasswordLogin = performPasswordLogin;
+exports.requireData = requireData;
+exports.requireOk = requireOk;
+exports.resolveAuth = resolveAuth;
+exports.resolveWorkspace = resolveWorkspace;
+exports.selectWorkspace = selectWorkspace;
+exports.selectWorkspaceById = selectWorkspaceById;
+exports.settings = settings_exports;
+exports.streamSSE = streamSSE;
+exports.tags = tags_exports;
+exports.workspaces = workspaces_exports;
+//# sourceMappingURL=browser.cjs.map
+//# sourceMappingURL=browser.cjs.map