@nowledge/openclaw-nowledge-mem 0.3.0 → 0.6.5

package/src/tools/thread-fetch.js

@@ -0,0 +1,106 @@
+export function createThreadFetchTool(client, logger) {
+	return {
+		name: "nowledge_mem_thread_fetch",
+		description:
+			"Fetch full messages from a conversation thread. Use to read the complete context " +
+			"around a memory — pass the sourceThreadId from memory_search or memory_get results, " +
+			"or a threadId from nowledge_mem_thread_search. " +
+			"Supports pagination for long conversations: set offset to skip earlier messages. " +
+			"Useful for progressive retrieval — fetch the first page, then request more if needed.",
+		parameters: {
+			type: "object",
+			properties: {
+				threadId: {
+					type: "string",
+					description:
+						"Thread ID from nowledge_mem_thread_search, or sourceThreadId from memory_search / memory_get results",
+				},
+				offset: {
+					type: "number",
+					description: "Skip first N messages (for pagination, default 0)",
+				},
+				limit: {
+					type: "number",
+					description: "Max messages to return (1-200, default 50)",
+				},
+			},
+			required: ["threadId"],
+		},
+		async execute(_toolCallId, params) {
+			const safeParams = params && typeof params === "object" ? params : {};
+			const threadId = String(safeParams.threadId ?? "").trim();
+			const offset = Math.max(
+				0,
+				Math.trunc(Number(safeParams.offset ?? 0) || 0),
+			);
+			const limit = Math.min(
+				200,
+				Math.max(1, Math.trunc(Number(safeParams.limit ?? 50) || 50)),
+			);
+
+			if (!threadId) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								threadId: "",
+								error: "threadId is required",
+							}),
+						},
+					],
+				};
+			}
+
+			try {
+				const thread = await client.fetchThread(threadId, {
+					offset,
+					limit,
+				});
+
+				const hasMore =
+					thread.messageCount > 0 &&
+					offset + thread.messages.length < thread.messageCount;
+
+				const result = {
+					threadId: thread.threadId,
+					title: thread.title,
+					source: thread.source,
+					totalMessages: thread.messageCount,
+					offset,
+					limit,
+					returnedMessages: thread.messages.length,
+					hasMore,
+					messages: thread.messages,
+				};
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify(result, null, 2),
+						},
+					],
+					details: {
+						threadId: thread.threadId,
+						messageCount: thread.messages.length,
+					},
+				};
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				logger.error(`nowledge_mem_thread_fetch failed: ${message}`);
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								threadId,
+								error: message,
+							}),
+						},
+					],
+				};
+			}
+		},
+	};
+}

package/src/tools/thread-search.js

@@ -0,0 +1,108 @@
+function truncateSnippet(text, maxChars = 400) {
+	const value = String(text || "").trim();
+	if (!value) return "";
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}…`;
+}
+
+export function createThreadSearchTool(client, logger) {
+	return {
+		name: "nowledge_mem_thread_search",
+		description:
+			"Search past conversations by keyword. Use when the user asks about a past discussion, " +
+			"wants to find a conversation from a specific time, or when you want to explore the full context " +
+			"around a topic beyond what memory_search returned. " +
+			"Returns matched threads with message snippets and relevance scores. " +
+			"To read full messages from a thread, pass its threadId to nowledge_mem_thread_fetch.",
+		parameters: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Search keywords or natural language query",
+				},
+				limit: {
+					type: "number",
+					description: "Max threads to return (1-20, default 5)",
+				},
+				source: {
+					type: "string",
+					description:
+						"Filter by source platform (e.g. 'openclaw', 'claude-code'). Omit to search all sources.",
+				},
+			},
+			required: ["query"],
+		},
+		async execute(_toolCallId, params) {
+			const safeParams = params && typeof params === "object" ? params : {};
+			const query = String(safeParams.query ?? "").trim();
+			const limit = Math.min(
+				20,
+				Math.max(1, Math.trunc(Number(safeParams.limit ?? 5) || 5)),
+			);
+			const rawSource = safeParams.source
+				? String(safeParams.source).trim()
+				: "";
+			const source = rawSource || undefined;
+
+			if (!query) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({ threads: [], totalFound: 0 }),
+						},
+					],
+				};
+			}
+
+			try {
+				const { threads, totalFound } = await client.searchThreadsFull(query, {
+					limit,
+					source,
+				});
+
+				const results = threads.map((t) => {
+					const msgs = (t.matched_messages ?? []).slice(0, 3);
+					return {
+						threadId: t.thread_id ?? t.id,
+						title: t.title || "(untitled thread)",
+						source: t.source ?? "unknown",
+						messageCount: Number(t.message_count ?? 0),
+						lastActivity: t.last_activity ?? null,
+						relevanceScore: Number(t.relevance_score ?? 0),
+						matchedMessages: msgs.map((m) => ({
+							role: m.role,
+							snippet: truncateSnippet(m.snippet),
+						})),
+					};
+				});
+
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({ threads: results, totalFound }, null, 2),
+						},
+					],
+					details: { query, threadCount: results.length },
+				};
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				logger.error(`nowledge_mem_thread_search failed: ${message}`);
+				return {
+					content: [
+						{
+							type: "text",
+							text: JSON.stringify({
+								threads: [],
+								totalFound: 0,
+								error: message,
+							}),
+						},
+					],
+				};
+			}
+		},
+	};
+}