@andocorp/sdk 0.0.1 → 0.2.0

package/dist/client.js

@@ -1,15 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndoClient = void 0;
+exports.ANDO_PUBLIC_API_CLIENT_METHODS = exports.AndoClient = exports.AndoApiError = exports.DEFAULT_ANDO_REALTIME_HOST = exports.DEFAULT_ANDO_PUBLIC_API_BASE_URL = exports.DEFAULT_ANDO_BASE_URL = void 0;
+exports.requestAndoPublicApi = requestAndoPublicApi;
+exports.resolveAndoPublicApiBaseUrl = resolveAndoPublicApiBaseUrl;
+const agent_endpoints_1 = require("./agent-endpoints");
+exports.DEFAULT_ANDO_BASE_URL = "https://api.ando.so";
+exports.DEFAULT_ANDO_PUBLIC_API_BASE_URL = "https://api.ando.so/v1";
+exports.DEFAULT_ANDO_REALTIME_HOST = "realtime.ando.so";
 class AndoApiError extends Error {
-    constructor(message, status) {
-        super(message);
+    constructor(params) {
+        const detail = params.bodyText === "" ? "" : ` ${params.bodyText}`;
+        super(`[ando-sdk] ${params.method} ${params.path} failed: ${params.status}${detail}`);
+        this.body = params.body;
+        this.bodyText = params.bodyText;
+        this.code = params.code;
+        this.method = params.method;
+        this.path = params.path;
+        this.requestId = params.requestId;
         this.name = "AndoApiError";
-        this.status = status;
+        this.status = params.status;
     }
 }
+exports.AndoApiError = AndoApiError;
 const DEFAULT_HISTORY_LIMIT = 8;
 const DEFAULT_THREAD_HISTORY_LIMIT = 12;
+const TRANSIENT_API_RETRY_DELAYS_MS = [100, 250];
 function toIsoString(value) {
     return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
 }
@@ -18,33 +33,271 @@ function isNullConversationMessageError(error) {
         error.message.includes("/conversation-messages/") &&
         error.message.includes("returned null"));
 }
+function isOptionalContextHistoryError(error) {
+    return (error instanceof AndoApiError &&
+        (error.status === 404 ||
+            error.status === 410 ||
+            error.status === 422 ||
+            error.status >= 500));
+}
+function isRequestRetryable(method, headers) {
+    if (method === "GET" || method === "HEAD") {
+        return true;
+    }
+    return headers?.["Idempotency-Key"] != null;
+}
+function isOptimisticConcurrencyFailure(error) {
+    return (error.code === "OptimisticConcurrencyControlFailure" ||
+        error.bodyText.includes("OptimisticConcurrencyControlFailure"));
+}
+function isRetryableApiError(error) {
+    if (!(error instanceof AndoApiError)) {
+        return false;
+    }
+    if (isOptimisticConcurrencyFailure(error)) {
+        return error.status === 409 || error.status >= 500;
+    }
+    return error.status === 429 || error.status >= 500;
+}
+function isRetryableNetworkError(error) {
+    return error instanceof TypeError && error.message === "fetch failed";
+}
+function isRetryableRequestError(error) {
+    return isRetryableApiError(error) || isRetryableNetworkError(error);
+}
+function createAbortError(signal) {
+    if (signal.reason instanceof Error) {
+        return signal.reason;
+    }
+    const error = new Error("[ando-sdk] request aborted");
+    error.name = "AbortError";
+    return error;
+}
+async function waitForRetryDelay(ms, signal) {
+    if (signal?.aborted) {
+        throw createAbortError(signal);
+    }
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const abort = () => {
+            cleanup();
+            reject(createAbortError(signal));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", abort);
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+function createJsonRequestInit(params) {
+    const requestInit = {
+        method: params.method,
+        headers: {
+            Authorization: params.authHeaderValue,
+            "Content-Type": "application/json",
+            ...params.headers,
+        },
+    };
+    if (params.signal != null) {
+        requestInit.signal = params.signal;
+    }
+    if (params.body != null) {
+        requestInit.body = JSON.stringify(params.body);
+    }
+    return requestInit;
+}
+function parseResponseBody(bodyText) {
+    if (bodyText.trim() === "") {
+        return null;
+    }
+    const trimmedBody = bodyText.trim();
+    if (trimmedBody.startsWith("{") || trimmedBody.startsWith("[")) {
+        try {
+            return JSON.parse(bodyText);
+        }
+        catch {
+            return bodyText;
+        }
+    }
+    return bodyText;
+}
+async function requestAndoPublicApi(params) {
+    const fetchImpl = params.fetchImpl ?? fetch;
+    const response = await fetchImpl(params.url, createJsonRequestInit({
+        authHeaderValue: `Bearer ${params.apiKey}`,
+        body: params.body,
+        headers: {
+            Accept: "application/json",
+            ...params.headers,
+        },
+        method: params.method,
+        signal: params.signal,
+    }));
+    const bodyText = await response.text();
+    return {
+        body: parseResponseBody(bodyText),
+        bodyText,
+        empty: bodyText.trim() === "",
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+    };
+}
 function isDefined(value) {
     return value != null;
 }
+function stripTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value[end - 1] === "/") {
+        end -= 1;
+    }
+    return value.slice(0, end);
+}
+function normalizeConfiguredHost(value, fallback) {
+    return value == null || value === ""
+        ? fallback
+        : stripTrailingSlashes(value) || fallback;
+}
+function createIdempotencyKey(operation) {
+    const random = globalThis.crypto.randomUUID();
+    return `ando-sdk-${operation}-${random}`;
+}
+function requireIdempotencyKey(operation, idempotencyKey) {
+    const resolved = idempotencyKey ?? createIdempotencyKey(operation);
+    if (resolved.trim() === "") {
+        throw new Error(`[ando-sdk] ${operation} idempotency key cannot be empty`);
+    }
+    if (resolved.length > 255) {
+        throw new Error(`[ando-sdk] ${operation} idempotency key must be 255 characters or fewer`);
+    }
+    return resolved;
+}
+function parseErrorBody(bodyText) {
+    if (bodyText.trim() === "") {
+        return null;
+    }
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        return bodyText;
+    }
+}
+function getErrorDetails(body) {
+    if (body == null || typeof body !== "object" || !("error" in body)) {
+        return {};
+    }
+    const error = body.error;
+    if (typeof error === "string") {
+        const code = body.error_code;
+        return typeof code === "string" ? { code } : {};
+    }
+    if (error == null || typeof error !== "object") {
+        return {};
+    }
+    const code = error.code;
+    const requestId = error.request_id;
+    return {
+        ...(typeof code === "string" ? { code } : {}),
+        ...(typeof requestId === "string" ? { requestId } : {}),
+    };
+}
+function emitDiagnostic(diagnostics, event) {
+    try {
+        const result = diagnostics?.(event);
+        if (result != null) {
+            result.then(() => undefined, () => undefined);
+        }
+    }
+    catch {
+        // Diagnostics should never affect SDK behavior.
+    }
+}
+function createRequestSignal(params) {
+    if (params.timeoutMs == null || params.timeoutMs <= 0) {
+        return {
+            signal: params.signal,
+            cleanup: () => undefined,
+        };
+    }
+    const controller = new AbortController();
+    let timeout = setTimeout(() => {
+        controller.abort(new Error(params.timeoutMessage));
+    }, params.timeoutMs);
+    const abortFromCaller = () => {
+        controller.abort(params.signal?.reason);
+    };
+    if (params.signal?.aborted) {
+        abortFromCaller();
+    }
+    else {
+        params.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            if (timeout != null) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            params.signal?.removeEventListener("abort", abortFromCaller);
+        },
+    };
+}
 function buildMessageText(message) {
     // Context generation prefers one canonical body plus lightweight
     // placeholders for non-text inputs.
-    const body = message.markdown_content?.trim();
+    const body = (message.markdown_content ?? message.content)?.trim();
     if (body) {
         return body;
     }
     const imageCount = message.image_urls?.length ?? 0;
     if (imageCount > 0) {
-        return imageCount === 1
-            ? "[image attachment]"
-            : `[${imageCount} image attachments]`;
+        return imageCount === 1 ? "[image attachment]" : `[${imageCount} image attachments]`;
     }
     const fileCount = message.files?.length ?? 0;
     if (fileCount > 0) {
-        return fileCount === 1
-            ? "[file attachment]"
-            : `[${fileCount} file attachments]`;
+        return fileCount === 1 ? "[file attachment]" : `[${fileCount} file attachments]`;
     }
     if (message.call_id != null) {
         return "[Jam started]";
     }
     return null;
 }
+function resolveAndoPublicApiBaseUrl(apiHost) {
+    const url = new URL(apiHost);
+    url.search = "";
+    url.hash = "";
+    const trimmedPath = url.pathname.replace(/\/+$/, "");
+    if (trimmedPath.endsWith("/v1") || trimmedPath.endsWith("/api/v1")) {
+        url.pathname = trimmedPath;
+        return url.toString().replace(/\/+$/, "");
+    }
+    if (url.hostname === "api.ando.so") {
+        url.pathname = "/v1";
+        return url.toString().replace(/\/+$/, "");
+    }
+    url.pathname = `${trimmedPath === "" ? "" : trimmedPath}/v1`;
+    return url.toString().replace(/\/+$/, "");
+}
+function publicApiPathForConfiguredBase(baseUrl, publicPath) {
+    const basePath = new URL(baseUrl).pathname.replace(/\/+$/, "");
+    if (publicPath.startsWith("/v1/") &&
+        (basePath.endsWith("/v1") || basePath.endsWith("/api/v1"))) {
+        return publicPath.slice("/v1".length);
+    }
+    return publicPath;
+}
+function messageAuthorId(message) {
+    return message.author?.id ?? message.author_id ?? "unknown";
+}
+function messageAuthorName(message) {
+    return message.author?.display_name ?? message.author_name ?? null;
+}
 function buildHistoryEntry(message) {
     const body = buildMessageText(message);
     if (!body) {
@@ -52,8 +305,8 @@ function buildHistoryEntry(message) {
     }
     return {
         message_id: message.id,
-        author_id: message.author.id,
-        author_name: message.author.display_name,
+        author_id: messageAuthorId(message),
+        author_name: messageAuthorName(message),
         body,
         created_at: toIsoString(message.created_at),
     };
@@ -65,57 +318,127 @@ function joinBodies(messages) {
         if (!body) {
             return null;
         }
-        return `${message.author.display_name ?? message.author.id}: ${body}`;
+        return `${messageAuthorName(message) ?? messageAuthorId(message)}: ${body}`;
     })
         .filter(Boolean);
     return lines.length > 0 ? lines.join("\n\n") : null;
 }
 class AndoClient {
     constructor(options) {
-        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-        this.realtimeHost = options.realtimeHost?.replace(/\/+$/, "") ?? null;
+        this.baseUrl = normalizeConfiguredHost(options.baseUrl, exports.DEFAULT_ANDO_BASE_URL);
+        this.realtimeHost = normalizeConfiguredHost(options.realtimeHost, exports.DEFAULT_ANDO_REALTIME_HOST);
         this.authHeaderValue = `Bearer ${options.auth.apiKey}`;
+        this.diagnostics = options.diagnostics;
         this.fetchImpl = options.fetch ?? fetch;
+        this.requestTimeoutMs = options.requestTimeoutMs;
         this.realtime = {
             subscribeMember: async (realtimeOptions) => {
-                if (!this.realtimeHost) {
-                    throw new Error("[ando-sdk] realtimeHost is required for realtime subscriptions");
-                }
-                const { AndoRealtimeClient } = await import("./realtime.js");
-                const realtimeClient = new AndoRealtimeClient({
-                    realtimeHost: this.realtimeHost,
-                    getMe: (signal) => this.getMe(signal),
-                    getMemberGroupIdByMemberId: (memberId, signal) => this.getMemberGroupIdByMemberId(memberId, signal),
-                    getMyMemberships: (params) => this.getMyMemberships(params),
-                    createWebSocketToken: (room, signal) => this.createWebSocketToken(room, signal),
-                    getMessageContext: (messageId, signal) => this.getMessageContext(messageId, signal),
+                const realtimeClient = await this.createRealtimeClient();
+                return realtimeClient.subscribeMember({
+                    ...realtimeOptions,
+                    diagnostics: realtimeOptions?.diagnostics ?? this.diagnostics,
+                });
+            },
+            on: async (event, realtimeOptions) => {
+                const realtimeClient = await this.createRealtimeClient();
+                return realtimeClient.on(event, {
+                    ...realtimeOptions,
+                    diagnostics: realtimeOptions?.diagnostics ?? this.diagnostics,
                 });
-                return realtimeClient.subscribeMember(realtimeOptions);
             },
         };
     }
+    async createRealtimeClient() {
+        const { AndoRealtimeClient } = await import("./realtime.js");
+        return new AndoRealtimeClient({
+            diagnostics: this.diagnostics,
+            openRealtimeConnection: (request, signal) => this.openRealtimeConnection(request, signal),
+            getMessageContext: (messageId, signal, contextOptions) => this.getMessageContext(messageId, signal, contextOptions),
+            getConversation: (conversationId, signal) => this.getConversation(conversationId, signal),
+        });
+    }
     async fetchJson(path, options = {}) {
         const url = new URL(`${this.baseUrl}${path}`);
+        const method = options.method ?? "GET";
         for (const [key, value] of Object.entries(options.query ?? {})) {
             if (value == null || value === "") {
                 continue;
             }
             url.searchParams.set(key, String(value));
         }
-        const response = await this.fetchImpl(url, {
-            method: options.method ?? "GET",
+        const requestSignal = createRequestSignal({
             signal: options.signal,
-            headers: {
-                Authorization: this.authHeaderValue,
-                "Content-Type": "application/json",
-            },
-            body: options.body ? JSON.stringify(options.body) : undefined,
+            timeoutMs: this.requestTimeoutMs,
+            timeoutMessage: `[ando-sdk] ${method} ${path} timed out after ${this.requestTimeoutMs}ms`,
         });
-        if (!response.ok) {
-            const body = await response.text().catch(() => "");
-            throw new AndoApiError(`[ando-sdk] ${options.method ?? "GET"} ${path} failed: ${response.status} ${body}`, response.status);
+        const canRetry = isRequestRetryable(method, options.headers);
+        const startedAt = Date.now();
+        try {
+            for (let attempt = 0;; attempt += 1) {
+                let status;
+                try {
+                    const requestInit = createJsonRequestInit({
+                        authHeaderValue: this.authHeaderValue,
+                        body: options.body,
+                        headers: options.headers,
+                        method,
+                        signal: requestSignal.signal,
+                    });
+                    const response = await this.fetchImpl(url, requestInit);
+                    status = response.status;
+                    if (!response.ok) {
+                        const bodyText = await response.text().catch(() => "");
+                        const body = parseErrorBody(bodyText);
+                        const details = getErrorDetails(body);
+                        throw new AndoApiError({
+                            body,
+                            bodyText,
+                            code: details.code,
+                            method,
+                            path,
+                            requestId: details.requestId,
+                            status: response.status,
+                        });
+                    }
+                    const data = (await response.json());
+                    emitDiagnostic(this.diagnostics, {
+                        type: "http",
+                        method,
+                        path,
+                        status,
+                        ok: true,
+                        durationMs: Date.now() - startedAt,
+                    });
+                    return data;
+                }
+                catch (error) {
+                    const retryDelay = TRANSIENT_API_RETRY_DELAYS_MS[attempt];
+                    if (canRetry &&
+                        retryDelay != null &&
+                        !requestSignal.signal?.aborted &&
+                        isRetryableRequestError(error)) {
+                        await waitForRetryDelay(retryDelay, requestSignal.signal);
+                        continue;
+                    }
+                    emitDiagnostic(this.diagnostics, {
+                        type: "http",
+                        method,
+                        path,
+                        status,
+                        ok: false,
+                        durationMs: Date.now() - startedAt,
+                        error,
+                    });
+                    throw error;
+                }
+            }
         }
-        return (await response.json());
+        finally {
+            requestSignal.cleanup();
+        }
+    }
+    fetchPublicJson(path, options = {}) {
+        return this.fetchJson(publicApiPathForConfiguredBase(this.baseUrl, path), options);
     }
     encodeMessageCursor(message) {
         const cursor = {
@@ -131,6 +454,73 @@ class AndoClient {
         }
         return data;
     }
+    async searchMessages(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchMessages)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async searchMembers(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchMembers)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async searchConversations(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchConversations)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async searchClipboard(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchClipboard)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async searchClipboards(params, signal) {
+        return this.searchClipboard(params, signal);
+    }
+    async searchCalls(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchCalls)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async searchTasks(params, signal) {
+        return (0, agent_endpoints_1.fetchSearchTasks)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async getConversationMessageResult(messageId, signal) {
+        return (0, agent_endpoints_1.fetchConversationMessageResult)((path, options) => this.fetchPublicJson(path, options), messageId, signal);
+    }
+    async getMember(memberId, signal) {
+        return (0, agent_endpoints_1.fetchMember)((path, options) => this.fetchPublicJson(path, options), memberId, signal);
+    }
+    async getClipboard(clipboardId, signal) {
+        return (0, agent_endpoints_1.fetchClipboard)((path, options) => this.fetchPublicJson(path, options), clipboardId, signal);
+    }
+    async getCall(callId, signal) {
+        return (0, agent_endpoints_1.fetchCall)((path, options) => this.fetchPublicJson(path, options), callId, signal);
+    }
+    async getCallTranscript(params, signal) {
+        return (0, agent_endpoints_1.fetchCallTranscript)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async getConversationMessageResults(params, signal) {
+        return (0, agent_endpoints_1.fetchConversationMessageResults)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async listConversationMessages(params, signal) {
+        return this.getConversationMessageResults(params, signal);
+    }
+    async listThreadReplyResults(params, signal) {
+        return (0, agent_endpoints_1.fetchThreadReplyResults)((path, options) => this.fetchPublicJson(path, options), params, signal);
+    }
+    async listThreadReplies(params, signal) {
+        return this.listThreadReplyResults(params, signal);
+    }
+    async recordTaskUpdate(params, signal) {
+        return (0, agent_endpoints_1.fetchRecordTaskUpdate)((path, options) => this.fetchPublicJson(path, options), {
+            ...params,
+            idempotencyKey: requireIdempotencyKey("recordTaskUpdate", params.idempotencyKey),
+        }, signal);
+    }
+    async getTask(taskId, signal) {
+        return (0, agent_endpoints_1.fetchTask)((path, options) => this.fetchPublicJson(path, options), taskId, signal);
+    }
+    async createConversationMessage(input, signal) {
+        const response = await (0, agent_endpoints_1.fetchCreateConversationMessage)((path, options) => this.fetchPublicJson(path, options), {
+            input,
+            idempotencyKey: requireIdempotencyKey("createConversationMessage", input.idempotencyKey),
+        }, signal);
+        if (!response.success) {
+            throw new Error("[ando-sdk] createConversationMessage returned an empty response");
+        }
+        return response.data;
+    }
     async getOptionalConversationMessage(messageId, signal) {
         try {
             return await this.getConversationMessage(messageId, signal);
@@ -165,6 +555,40 @@ class AndoClient {
             },
         });
     }
+    async getOptionalConversationMessages(conversationId, query, signal) {
+        try {
+            return await this.getConversationMessages(conversationId, query, signal);
+        }
+        catch (error) {
+            if (isOptionalContextHistoryError(error)) {
+                return {
+                    items: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+    async getOptionalThreadReplies(messageId, query, signal) {
+        try {
+            return await this.getThreadReplies(messageId, query, signal);
+        }
+        catch (error) {
+            if (isOptionalContextHistoryError(error)) {
+                return {
+                    items: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
     async getMe(signal) {
         const { data } = await this.fetchJson("/auth/me", {
             signal,
@@ -183,15 +607,31 @@ class AndoClient {
             },
         });
     }
-    async getMessageContext(messageId, signal) {
+    async getConversation(conversationId, signal) {
+        let cursor;
+        do {
+            const response = await this.getMyMemberships({
+                cursor,
+                limit: 200,
+                signal,
+            });
+            const match = response.items.find((membership) => membership.conversation.id === conversationId);
+            if (match) {
+                return match.conversation;
+            }
+            cursor = response.pageInfo.hasNextPage ? response.pageInfo.nextCursor : undefined;
+        } while (cursor);
+        return null;
+    }
+    async getMessageContext(messageId, signal, options = {}) {
         const message = await this.getConversationMessage(messageId, signal);
         const currentText = buildMessageText(message);
-        const isThreadReply = message.thread_root_id != null;
-        const replyThreadRootId = message.thread_root_id ?? message.id;
+        const replyThreadRootId = options.threadRootId ?? message.thread_root_id ?? message.id;
+        const isThreadReply = replyThreadRootId !== message.id;
         if (isThreadReply) {
             const [threadRootMessage, threadReplyHistory] = await Promise.all([
                 this.getOptionalConversationMessage(replyThreadRootId, signal),
-                this.getThreadReplies(replyThreadRootId, {
+                this.getOptionalThreadReplies(replyThreadRootId, {
                     limit: DEFAULT_THREAD_HISTORY_LIMIT,
                     before: this.encodeMessageCursor(message),
                 }, signal),
@@ -213,12 +653,12 @@ class AndoClient {
         const [conversationHistory, threadReplyHistory] = await Promise.all([
             // Conversation pagination is fetched newest-first under the hood and then
             // reversed for display, so `after` pages further back in history here.
-            this.getConversationMessages(message.conversation_id, {
+            this.getOptionalConversationMessages(message.conversation_id, {
                 limit: DEFAULT_HISTORY_LIMIT,
                 after: this.encodeMessageCursor(message),
             }, signal),
             message.replies_count > 0
-                ? this.getThreadReplies(message.id, {
+                ? this.getOptionalThreadReplies(message.id, {
                     limit: DEFAULT_THREAD_HISTORY_LIMIT,
                 }, signal)
                 : Promise.resolve(null),
@@ -237,12 +677,23 @@ class AndoClient {
                 : null,
         };
     }
+    async openRealtimeConnection(request, signal) {
+        return this.fetchJson(publicApiPathForConfiguredBase(this.baseUrl, "/v1/realtime/connections"), {
+            method: "POST",
+            signal,
+            body: request,
+        });
+    }
     async postMessage(input) {
         const response = await this.fetchJson(`/conversations/${input.conversationId}/messages`, {
             method: "POST",
+            headers: {
+                "Idempotency-Key": requireIdempotencyKey("postMessage", input.idempotencyKey),
+            },
             body: {
                 markdown_content: input.markdownContent,
                 thread_root_id: input.threadRootId ?? null,
+                replied_to_message_id: input.repliedToMessageId ?? null,
                 call_root_id: input.callRootId ?? null,
             },
         });
@@ -251,6 +702,15 @@ class AndoClient {
         }
         return response.data;
     }
+    async addReaction(messageId, emojiText, signal) {
+        return this.fetchJson(`/conversation-messages/${encodeURIComponent(messageId)}/reactions`, {
+            method: "POST",
+            signal,
+            body: {
+                emoji_text: emojiText,
+            },
+        });
+    }
     async getMemberGroupIdByMemberId(memberId, signal) {
         let cursor;
         do {
@@ -265,21 +725,29 @@ class AndoClient {
             if (match) {
                 return match.id;
             }
-            cursor = response.pageInfo.hasNextPage
-                ? response.pageInfo.nextCursor
-                : undefined;
+            cursor = response.pageInfo.hasNextPage ? response.pageInfo.nextCursor : undefined;
         } while (cursor);
         return null;
     }
-    async createWebSocketToken(room, signal) {
-        return this.fetchJson("/tokens/ws", {
-            method: "POST",
-            signal,
-            body: {
-                room,
-            },
-        });
-    }
 }
 exports.AndoClient = AndoClient;
+exports.ANDO_PUBLIC_API_CLIENT_METHODS = {
+    createConversationMessage: "createConversationMessage",
+    getCall: "getCall",
+    getCallTranscript: "getCallTranscript",
+    getClipboard: "getClipboard",
+    getConversationMessage: "getConversationMessageResult",
+    getMember: "getMember",
+    getTask: "getTask",
+    listConversationMessages: "listConversationMessages",
+    listThreadReplies: "listThreadReplies",
+    openRealtimeConnection: "openRealtimeConnection",
+    recordTaskUpdate: "recordTaskUpdate",
+    searchCalls: "searchCalls",
+    searchClipboards: "searchClipboards",
+    searchConversations: "searchConversations",
+    searchMembers: "searchMembers",
+    searchMessages: "searchMessages",
+    searchTasks: "searchTasks",
+};
 //# sourceMappingURL=client.js.map