@elizaos/ui 2.0.0-alpha.526 → 2.0.0-alpha.528

package/packages/app-core/src/api/client-chat.js

@@ -0,0 +1,582 @@
+/**
+ * Chat domain methods — chat, conversations, knowledge, memory, MCP,
+ * share ingest, workbench, trajectories, database.
+ */
+import { ElizaClient } from "./client-base";
+// ---------------------------------------------------------------------------
+// Prototype augmentation
+// ---------------------------------------------------------------------------
+const LEGACY_CHAT_COMPAT_TITLE = "Quick Chat";
+const LEGACY_CHAT_CONVERSATION_STORAGE_PREFIX = "legacy_chat_conversation";
+function getLegacyChatConversationStorageKey(client) {
+    const base = client.getBaseUrl() ||
+        (typeof window !== "undefined" ? window.location.origin : "same-origin");
+    return `${LEGACY_CHAT_CONVERSATION_STORAGE_PREFIX}:${encodeURIComponent(base)}`;
+}
+function readLegacyChatConversationId(client) {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    const stored = window.sessionStorage.getItem(getLegacyChatConversationStorageKey(client));
+    return stored?.trim() ? stored.trim() : null;
+}
+function writeLegacyChatConversationId(client, conversationId) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    const key = getLegacyChatConversationStorageKey(client);
+    if (conversationId?.trim()) {
+        window.sessionStorage.setItem(key, conversationId.trim());
+        return;
+    }
+    window.sessionStorage.removeItem(key);
+}
+async function ensureLegacyChatConversationId(client) {
+    const cached = readLegacyChatConversationId(client);
+    if (cached) {
+        return cached;
+    }
+    const { conversation } = await client.createConversation(LEGACY_CHAT_COMPAT_TITLE);
+    writeLegacyChatConversationId(client, conversation.id);
+    return conversation.id;
+}
+ElizaClient.prototype.sendChatRest = async function (text, channelType = "DM", conversationMode) {
+    const sendToConversation = async (conversationId) => this.sendConversationMessage(conversationId, text, channelType, undefined, conversationMode);
+    const conversationId = await ensureLegacyChatConversationId(this);
+    try {
+        return await sendToConversation(conversationId);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.name === "ApiError" &&
+            error.status === 404) {
+            writeLegacyChatConversationId(this, null);
+            return sendToConversation(await ensureLegacyChatConversationId(this));
+        }
+        throw error;
+    }
+};
+ElizaClient.prototype.sendChatStream = async function (text, onToken, channelType = "DM", signal, conversationMode) {
+    const streamConversation = async (conversationId) => this.sendConversationMessageStream(conversationId, text, onToken, channelType, signal, undefined, conversationMode);
+    const conversationId = await ensureLegacyChatConversationId(this);
+    try {
+        return await streamConversation(conversationId);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.name === "ApiError" &&
+            error.status === 404) {
+            writeLegacyChatConversationId(this, null);
+            return streamConversation(await ensureLegacyChatConversationId(this));
+        }
+        throw error;
+    }
+};
+ElizaClient.prototype.listConversations = async function () {
+    return this.fetch("/api/conversations");
+};
+ElizaClient.prototype.createConversation = async function (title, options) {
+    const response = await this.fetch("/api/conversations", {
+        method: "POST",
+        body: JSON.stringify({
+            title,
+            ...(options?.includeGreeting === true ||
+                options?.bootstrapGreeting === true
+                ? { includeGreeting: true }
+                : {}),
+            ...(typeof options?.lang === "string" && options.lang.trim()
+                ? { lang: options.lang.trim() }
+                : {}),
+            ...(options?.metadata ? { metadata: options.metadata } : {}),
+        }),
+    });
+    if (!response.greeting) {
+        return response;
+    }
+    return {
+        ...response,
+        greeting: {
+            ...response.greeting,
+            text: this.normalizeGreetingText(response.greeting.text),
+        },
+    };
+};
+ElizaClient.prototype.getConversationMessages = async function (id) {
+    const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages`);
+    return {
+        messages: response.messages.map((message) => {
+            if (message.role !== "assistant")
+                return message;
+            const text = this.normalizeAssistantText(message.text);
+            return text === message.text ? message : { ...message, text };
+        }),
+    };
+};
+ElizaClient.prototype.getInboxMessages = async function (options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number" && options.limit > 0) {
+        params.set("limit", String(options.limit));
+    }
+    if (options?.sources && options.sources.length > 0) {
+        params.set("sources", options.sources.join(","));
+    }
+    if (typeof options?.roomId === "string" && options.roomId.length > 0) {
+        params.set("roomId", options.roomId);
+    }
+    if (typeof options?.roomSource === "string" &&
+        options.roomSource.length > 0) {
+        params.set("roomSource", options.roomSource);
+    }
+    const query = params.toString();
+    const path = query ? `/api/inbox/messages?${query}` : "/api/inbox/messages";
+    return this.fetch(path);
+};
+ElizaClient.prototype.getInboxSources = async function () {
+    return this.fetch("/api/inbox/sources");
+};
+ElizaClient.prototype.getInboxChats = async function (options) {
+    const params = new URLSearchParams();
+    if (options?.sources && options.sources.length > 0) {
+        params.set("sources", options.sources.join(","));
+    }
+    const query = params.toString();
+    const path = query ? `/api/inbox/chats?${query}` : "/api/inbox/chats";
+    return this.fetch(path);
+};
+ElizaClient.prototype.sendInboxMessage = async function (data) {
+    return this.fetch("/api/inbox/messages", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.truncateConversationMessages = async function (id, messageId, options) {
+    return this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages/truncate`, {
+        method: "POST",
+        body: JSON.stringify({
+            messageId,
+            inclusive: options?.inclusive === true,
+        }),
+    });
+};
+ElizaClient.prototype.sendConversationMessage = async function (id, text, channelType = "DM", images, conversationMode, metadata) {
+    const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages`, {
+        method: "POST",
+        body: JSON.stringify({
+            text,
+            channelType,
+            ...(images?.length ? { images } : {}),
+            ...(conversationMode ? { conversationMode } : {}),
+            ...(metadata ? { metadata } : {}),
+        }),
+    });
+    return {
+        ...response,
+        text: response.noResponseReason === "ignored"
+            ? ""
+            : this.normalizeAssistantText(response.text),
+    };
+};
+ElizaClient.prototype.sendConversationMessageStream = async function (id, text, onToken, channelType = "DM", signal, images, conversationMode, metadata) {
+    return this.streamChatEndpoint(`/api/conversations/${encodeURIComponent(id)}/messages/stream`, text, onToken, channelType, signal, images, conversationMode, metadata);
+};
+ElizaClient.prototype.requestGreeting = async function (id, lang) {
+    const qs = lang ? `?lang=${encodeURIComponent(lang)}` : "";
+    const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/greeting${qs}`, {
+        method: "POST",
+    });
+    return {
+        ...response,
+        text: this.normalizeGreetingText(response.text),
+    };
+};
+ElizaClient.prototype.renameConversation = async function (id, title, options) {
+    return this.updateConversation(id, {
+        title,
+        generate: options?.generate,
+    });
+};
+ElizaClient.prototype.updateConversation = async function (id, data) {
+    return this.fetch(`/api/conversations/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+            ...(typeof data?.title === "string" ? { title: data.title } : {}),
+            ...(typeof data?.generate === "boolean"
+                ? { generate: data.generate }
+                : {}),
+            ...(data && "metadata" in data ? { metadata: data.metadata } : {}),
+        }),
+    });
+};
+ElizaClient.prototype.deleteConversation = async function (id) {
+    return this.fetch(`/api/conversations/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.cleanupEmptyConversations = async function (options) {
+    return this.fetch("/api/conversations/cleanup-empty", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            ...(options?.keepId ? { keepId: options.keepId } : {}),
+        }),
+    });
+};
+ElizaClient.prototype.getKnowledgeStats = async function () {
+    return this.fetch("/api/knowledge/stats");
+};
+ElizaClient.prototype.listKnowledgeDocuments = async function (options) {
+    const params = new URLSearchParams();
+    if (options?.limit)
+        params.set("limit", String(options.limit));
+    if (options?.offset)
+        params.set("offset", String(options.offset));
+    const query = params.toString();
+    return this.fetch(`/api/knowledge/documents${query ? `?${query}` : ""}`);
+};
+ElizaClient.prototype.getKnowledgeDocument = async function (documentId) {
+    return this.fetch(`/api/knowledge/documents/${encodeURIComponent(documentId)}`);
+};
+ElizaClient.prototype.updateKnowledgeDocument = async function (documentId, data) {
+    return this.fetch(`/api/knowledge/documents/${encodeURIComponent(documentId)}`, {
+        method: "PATCH",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.deleteKnowledgeDocument = async function (documentId) {
+    return this.fetch(`/api/knowledge/documents/${encodeURIComponent(documentId)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.uploadKnowledgeDocument = async function (data) {
+    return this.fetch("/api/knowledge/documents", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.uploadKnowledgeDocumentsBulk = async function (data) {
+    return this.fetch("/api/knowledge/documents/bulk", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.uploadKnowledgeFromUrl = async function (url, metadata) {
+    return this.fetch("/api/knowledge/documents/url", {
+        method: "POST",
+        body: JSON.stringify({ url, metadata }),
+    });
+};
+ElizaClient.prototype.searchKnowledge = async function (query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.threshold !== undefined)
+        params.set("threshold", String(options.threshold));
+    if (options?.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return this.fetch(`/api/knowledge/search?${params}`);
+};
+ElizaClient.prototype.getKnowledgeFragments = async function (documentId) {
+    return this.fetch(`/api/knowledge/fragments/${encodeURIComponent(documentId)}`);
+};
+ElizaClient.prototype.listScratchpadTopics = async function () {
+    return this.fetch("/api/knowledge/scratchpad/topics");
+};
+ElizaClient.prototype.createScratchpadTopic = async function (data) {
+    return this.fetch("/api/knowledge/scratchpad/topics", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.getScratchpadTopic = async function (topicId) {
+    return this.fetch(`/api/knowledge/scratchpad/topics/${encodeURIComponent(topicId)}`);
+};
+ElizaClient.prototype.replaceScratchpadTopic = async function (topicId, data) {
+    return this.fetch(`/api/knowledge/scratchpad/topics/${encodeURIComponent(topicId)}`, {
+        method: "PUT",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.deleteScratchpadTopic = async function (topicId) {
+    return this.fetch(`/api/knowledge/scratchpad/topics/${encodeURIComponent(topicId)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.searchScratchpadTopics = async function (query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return this.fetch(`/api/knowledge/scratchpad/search?${params}`);
+};
+ElizaClient.prototype.previewScratchpadSummary = async function (data) {
+    return this.fetch("/api/knowledge/scratchpad/summary-preview", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.rememberMemory = async function (text) {
+    return this.fetch("/api/memory/remember", {
+        method: "POST",
+        body: JSON.stringify({ text }),
+    });
+};
+ElizaClient.prototype.searchMemory = async function (query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return this.fetch(`/api/memory/search?${params}`);
+};
+ElizaClient.prototype.quickContext = async function (query, options) {
+    const params = new URLSearchParams({ q: query });
+    if (options?.limit !== undefined)
+        params.set("limit", String(options.limit));
+    return this.fetch(`/api/context/quick?${params}`);
+};
+ElizaClient.prototype.getMemoryFeed = async function (query) {
+    const params = new URLSearchParams();
+    if (query?.type)
+        params.set("type", query.type);
+    if (typeof query?.limit === "number")
+        params.set("limit", String(query.limit));
+    if (typeof query?.before === "number")
+        params.set("before", String(query.before));
+    const qs = params.toString();
+    return this.fetch(`/api/memories/feed${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.browseMemories = async function (query) {
+    const params = new URLSearchParams();
+    if (query?.type)
+        params.set("type", query.type);
+    if (query?.entityId)
+        params.set("entityId", query.entityId);
+    if (query?.roomId)
+        params.set("roomId", query.roomId);
+    if (query?.q)
+        params.set("q", query.q);
+    if (typeof query?.limit === "number")
+        params.set("limit", String(query.limit));
+    if (typeof query?.offset === "number")
+        params.set("offset", String(query.offset));
+    const qs = params.toString();
+    return this.fetch(`/api/memories/browse${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.getMemoriesByEntity = async function (entityId, query) {
+    const params = new URLSearchParams();
+    if (query?.type)
+        params.set("type", query.type);
+    if (typeof query?.limit === "number")
+        params.set("limit", String(query.limit));
+    if (typeof query?.offset === "number")
+        params.set("offset", String(query.offset));
+    if (query?.entityIds && query.entityIds.length > 0)
+        params.set("entityIds", query.entityIds.join(","));
+    const qs = params.toString();
+    return this.fetch(`/api/memories/by-entity/${encodeURIComponent(entityId)}${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.getMemoryStats = async function () {
+    return this.fetch("/api/memories/stats");
+};
+ElizaClient.prototype.getMcpConfig = async function () {
+    return this.fetch("/api/mcp/config");
+};
+ElizaClient.prototype.getMcpStatus = async function () {
+    return this.fetch("/api/mcp/status");
+};
+ElizaClient.prototype.searchMcpMarketplace = async function (query, limit) {
+    const params = new URLSearchParams({ q: query, limit: String(limit) });
+    return this.fetch(`/api/mcp/marketplace/search?${params}`);
+};
+ElizaClient.prototype.getMcpServerDetails = async function (name) {
+    return this.fetch(`/api/mcp/marketplace/${encodeURIComponent(name)}`);
+};
+ElizaClient.prototype.addMcpServer = async function (name, config) {
+    await this.fetch("/api/mcp/servers", {
+        method: "POST",
+        body: JSON.stringify({ name, config }),
+    });
+};
+ElizaClient.prototype.removeMcpServer = async function (name) {
+    await this.fetch(`/api/mcp/servers/${encodeURIComponent(name)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.ingestShare = async function (payload) {
+    return this.fetch("/api/ingest/share", {
+        method: "POST",
+        body: JSON.stringify(payload),
+    });
+};
+ElizaClient.prototype.consumeShareIngest = async function () {
+    return this.fetch("/api/share/consume", { method: "POST" });
+};
+ElizaClient.prototype.getWorkbenchOverview = async function () {
+    return this.fetch("/api/workbench/overview");
+};
+ElizaClient.prototype.listWorkbenchTasks = async function () {
+    return this.fetch("/api/workbench/tasks");
+};
+ElizaClient.prototype.getWorkbenchTask = async function (taskId) {
+    return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`);
+};
+ElizaClient.prototype.createWorkbenchTask = async function (data) {
+    return this.fetch("/api/workbench/tasks", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.updateWorkbenchTask = async function (taskId, data) {
+    return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`, {
+        method: "PUT",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.deleteWorkbenchTask = async function (taskId) {
+    return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.listWorkbenchTodos = async function () {
+    return this.fetch("/api/workbench/todos");
+};
+ElizaClient.prototype.getWorkbenchTodo = async function (todoId) {
+    return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`);
+};
+ElizaClient.prototype.createWorkbenchTodo = async function (data) {
+    return this.fetch("/api/workbench/todos", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.updateWorkbenchTodo = async function (todoId, data) {
+    return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`, {
+        method: "PUT",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.setWorkbenchTodoCompleted = async function (todoId, isCompleted) {
+    await this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}/complete`, {
+        method: "POST",
+        body: JSON.stringify({ isCompleted }),
+    });
+};
+ElizaClient.prototype.deleteWorkbenchTodo = async function (todoId) {
+    return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.refreshRegistry = async function () {
+    await this.fetch("/api/apps/refresh", { method: "POST" });
+};
+ElizaClient.prototype.getTrajectories = async function (options) {
+    const params = new URLSearchParams();
+    if (options?.limit)
+        params.set("limit", String(options.limit));
+    if (options?.offset)
+        params.set("offset", String(options.offset));
+    if (options?.source)
+        params.set("source", options.source);
+    if (options?.scenarioId)
+        params.set("scenarioId", options.scenarioId);
+    if (options?.batchId)
+        params.set("batchId", options.batchId);
+    if (options?.status)
+        params.set("status", options.status);
+    if (options?.startDate)
+        params.set("startDate", options.startDate);
+    if (options?.endDate)
+        params.set("endDate", options.endDate);
+    if (options?.search)
+        params.set("search", options.search);
+    const query = params.toString();
+    return this.fetch(`/api/trajectories${query ? `?${query}` : ""}`);
+};
+ElizaClient.prototype.getTrajectoryDetail = async function (trajectoryId) {
+    return this.fetch(`/api/trajectories/${encodeURIComponent(trajectoryId)}`);
+};
+ElizaClient.prototype.getTrajectoryStats = async function () {
+    return this.fetch("/api/trajectories/stats");
+};
+ElizaClient.prototype.getTrajectoryConfig = async function () {
+    return this.fetch("/api/trajectories/config");
+};
+ElizaClient.prototype.updateTrajectoryConfig = async function (config) {
+    return this.fetch("/api/trajectories/config", {
+        method: "PUT",
+        body: JSON.stringify(config),
+    });
+};
+ElizaClient.prototype.exportTrajectories = async function (options) {
+    const res = await this.rawRequest("/api/trajectories/export", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(options),
+    });
+    return res.blob();
+};
+ElizaClient.prototype.deleteTrajectories = async function (trajectoryIds) {
+    return this.fetch("/api/trajectories", {
+        method: "DELETE",
+        body: JSON.stringify({ trajectoryIds }),
+    });
+};
+ElizaClient.prototype.clearAllTrajectories = async function () {
+    return this.fetch("/api/trajectories", {
+        method: "DELETE",
+        body: JSON.stringify({ clearAll: true }),
+    });
+};
+ElizaClient.prototype.getDatabaseStatus = async function () {
+    return this.fetch("/api/database/status");
+};
+ElizaClient.prototype.getDatabaseConfig = async function () {
+    return this.fetch("/api/database/config");
+};
+ElizaClient.prototype.saveDatabaseConfig = async function (config) {
+    return this.fetch("/api/database/config", {
+        method: "PUT",
+        body: JSON.stringify(config),
+    });
+};
+ElizaClient.prototype.testDatabaseConnection = async function (creds) {
+    return this.fetch("/api/database/test", {
+        method: "POST",
+        body: JSON.stringify(creds),
+    });
+};
+ElizaClient.prototype.getDatabaseTables = async function () {
+    return this.fetch("/api/database/tables");
+};
+ElizaClient.prototype.getDatabaseRows = async function (table, opts) {
+    const params = new URLSearchParams();
+    if (opts?.offset != null)
+        params.set("offset", String(opts.offset));
+    if (opts?.limit != null)
+        params.set("limit", String(opts.limit));
+    if (opts?.sort)
+        params.set("sort", opts.sort);
+    if (opts?.order)
+        params.set("order", opts.order);
+    if (opts?.search)
+        params.set("search", opts.search);
+    const qs = params.toString();
+    return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.insertDatabaseRow = async function (table, data) {
+    return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
+        method: "POST",
+        body: JSON.stringify({ data }),
+    });
+};
+ElizaClient.prototype.updateDatabaseRow = async function (table, where, data) {
+    return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
+        method: "PUT",
+        body: JSON.stringify({ where, data }),
+    });
+};
+ElizaClient.prototype.deleteDatabaseRow = async function (table, where) {
+    return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
+        method: "DELETE",
+        body: JSON.stringify({ where }),
+    });
+};
+ElizaClient.prototype.executeDatabaseQuery = async function (sql, readOnly = true) {
+    return this.fetch("/api/database/query", {
+        method: "POST",
+        body: JSON.stringify({ sql, readOnly }),
+    });
+};