@agi-cli/server 0.1.124 → 0.1.126

package/src/tools/database/get-parent-session.ts

@@ -0,0 +1,178 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getDb } from '@agi-cli/database';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { eq, asc, count } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	includeMessages: z
+		.boolean()
+		.default(true)
+		.describe('Include message content from the parent session'),
+	messageLimit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(50)
+		.describe('Max messages to include'),
+});
+
+export function buildGetParentSessionTool(
+	projectRoot: string,
+	parentSessionId: string | null,
+) {
+	return {
+		name: 'get_parent_session',
+		tool: tool({
+			description:
+				'Get the context of the parent session that this research session is attached to. Use this to understand what the user was working on and what they might be asking about. This is the FIRST tool you should call when the user asks about "this session" or "current work".',
+			inputSchema,
+			async execute(input) {
+				if (!parentSessionId) {
+					return {
+						ok: false,
+						error:
+							'No parent session - this research session is not attached to a main session',
+					};
+				}
+
+				const db = await getDb(projectRoot);
+
+				const sessionRows = await db
+					.select()
+					.from(sessions)
+					.where(eq(sessions.id, parentSessionId))
+					.limit(1);
+
+				if (sessionRows.length === 0) {
+					return {
+						ok: false,
+						error: 'Parent session not found',
+					};
+				}
+
+				const session = sessionRows[0];
+
+				const msgCountResult = await db
+					.select({ count: count() })
+					.from(messages)
+					.where(eq(messages.sessionId, parentSessionId));
+
+				const toolCallsResult = await db
+					.select({
+						toolName: messageParts.toolName,
+						count: count(),
+					})
+					.from(messageParts)
+					.innerJoin(messages, eq(messageParts.messageId, messages.id))
+					.where(eq(messages.sessionId, parentSessionId))
+					.groupBy(messageParts.toolName);
+
+				const uniqueTools: string[] = [];
+				let totalToolCalls = 0;
+				for (const row of toolCallsResult) {
+					if (row.toolName) {
+						uniqueTools.push(row.toolName);
+						totalToolCalls += Number(row.count);
+					}
+				}
+
+				const totalTokens =
+					(session.totalInputTokens ?? 0) + (session.totalOutputTokens ?? 0);
+
+				const stats = {
+					totalMessages: msgCountResult[0]?.count ?? 0,
+					totalToolCalls,
+					uniqueTools,
+					totalTokens,
+					totalInputTokens: session.totalInputTokens ?? 0,
+					totalOutputTokens: session.totalOutputTokens ?? 0,
+				};
+
+				let messagesData:
+					| Array<{
+							id: string;
+							role: string;
+							content: string;
+							toolCalls?: Array<{ name: string; args?: string }>;
+							createdAt: number;
+					  }>
+					| undefined;
+
+				if (input.includeMessages) {
+					const msgRows = await db
+						.select({
+							id: messages.id,
+							role: messages.role,
+							createdAt: messages.createdAt,
+						})
+						.from(messages)
+						.where(eq(messages.sessionId, parentSessionId))
+						.orderBy(asc(messages.createdAt))
+						.limit(input.messageLimit);
+
+					messagesData = await Promise.all(
+						msgRows.map(async (msg) => {
+							const parts = await db
+								.select({
+									type: messageParts.type,
+									content: messageParts.content,
+									toolName: messageParts.toolName,
+								})
+								.from(messageParts)
+								.where(eq(messageParts.messageId, msg.id))
+								.orderBy(asc(messageParts.index));
+
+							let textContent = '';
+							const toolCalls: Array<{ name: string; args?: string }> = [];
+
+							for (const part of parts) {
+								if (part.type === 'text' && part.content) {
+									try {
+										const parsed = JSON.parse(part.content);
+										if (parsed?.text) {
+											textContent += parsed.text + '\n';
+										} else {
+											textContent += part.content + '\n';
+										}
+									} catch {
+										textContent += part.content + '\n';
+									}
+								}
+								if (part.type === 'tool_call' && part.toolName) {
+									toolCalls.push({
+										name: part.toolName,
+										args: part.content?.slice(0, 200),
+									});
+								}
+							}
+
+							return {
+								id: msg.id,
+								role: msg.role,
+								content: textContent.trim().slice(0, 2000),
+								...(toolCalls.length > 0 ? { toolCalls } : {}),
+								createdAt: msg.createdAt,
+							};
+						}),
+					);
+				}
+
+				return {
+					ok: true,
+					parentSession: {
+						id: session.id,
+						title: session.title,
+						agent: session.agent,
+						provider: session.provider,
+						model: session.model,
+						createdAt: session.createdAt,
+						lastActiveAt: session.lastActiveAt,
+					},
+					stats,
+					...(messagesData ? { messages: messagesData } : {}),
+				};
+			},
+		}),
+	};
+}

package/src/tools/database/get-session-context.ts

@@ -0,0 +1,156 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getDb } from '@agi-cli/database';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { eq, asc, count } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	sessionId: z.string().describe('The session ID to get context for'),
+	includeMessages: z
+		.boolean()
+		.default(false)
+		.describe('Include full message content'),
+	messageLimit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(50)
+		.describe('Max messages to include if includeMessages is true'),
+});
+
+export function buildGetSessionContextTool(projectRoot: string) {
+	return {
+		name: 'get_session_context',
+		tool: tool({
+			description:
+				'Get detailed context for a specific session including summary, stats, and optionally full messages. Use to understand what happened in a past conversation.',
+			inputSchema,
+			async execute(input) {
+				const db = await getDb(projectRoot);
+
+				const sessionRows = await db
+					.select()
+					.from(sessions)
+					.where(eq(sessions.id, input.sessionId))
+					.limit(1);
+
+				if (sessionRows.length === 0) {
+					return {
+						ok: false,
+						error: 'Session not found',
+					};
+				}
+
+				const session = sessionRows[0];
+
+				if (session.projectPath !== projectRoot) {
+					return {
+						ok: false,
+						error: 'Session belongs to a different project',
+					};
+				}
+
+				const msgCountResult = await db
+					.select({ count: count() })
+					.from(messages)
+					.where(eq(messages.sessionId, input.sessionId));
+
+				const toolCallsResult = await db
+					.select({
+						toolName: messageParts.toolName,
+						count: count(),
+					})
+					.from(messageParts)
+					.innerJoin(messages, eq(messageParts.messageId, messages.id))
+					.where(eq(messages.sessionId, input.sessionId))
+					.groupBy(messageParts.toolName);
+
+				const uniqueTools: string[] = [];
+				let totalToolCalls = 0;
+				for (const row of toolCallsResult) {
+					if (row.toolName) {
+						uniqueTools.push(row.toolName);
+						totalToolCalls += Number(row.count);
+					}
+				}
+
+				const totalTokens =
+					(session.totalInputTokens ?? 0) + (session.totalOutputTokens ?? 0);
+
+				const stats = {
+					totalMessages: msgCountResult[0]?.count ?? 0,
+					totalToolCalls,
+					uniqueTools,
+					totalTokens,
+					totalInputTokens: session.totalInputTokens ?? 0,
+					totalOutputTokens: session.totalOutputTokens ?? 0,
+				};
+
+				let messagesData:
+					| Array<{
+							id: string;
+							role: string;
+							content: string;
+							createdAt: number;
+					  }>
+					| undefined;
+
+				if (input.includeMessages) {
+					const msgRows = await db
+						.select({
+							id: messages.id,
+							role: messages.role,
+							createdAt: messages.createdAt,
+						})
+						.from(messages)
+						.where(eq(messages.sessionId, input.sessionId))
+						.orderBy(asc(messages.createdAt))
+						.limit(input.messageLimit);
+
+					messagesData = await Promise.all(
+						msgRows.map(async (msg) => {
+							const parts = await db
+								.select({
+									type: messageParts.type,
+									content: messageParts.content,
+								})
+								.from(messageParts)
+								.where(eq(messageParts.messageId, msg.id))
+								.orderBy(asc(messageParts.index));
+
+							const content = parts
+								.filter((p) => p.type === 'text' && p.content)
+								.map((p) => p.content)
+								.join('\n');
+
+							return {
+								id: msg.id,
+								role: msg.role,
+								content: content.slice(0, 2000),
+								createdAt: msg.createdAt,
+							};
+						}),
+					);
+				}
+
+				return {
+					ok: true,
+					session: {
+						id: session.id,
+						title: session.title,
+						agent: session.agent,
+						provider: session.provider,
+						model: session.model,
+						createdAt: session.createdAt,
+						lastActiveAt: session.lastActiveAt,
+						sessionType: session.sessionType,
+						parentSessionId: session.parentSessionId,
+					},
+					contextSummary: session.contextSummary ?? null,
+					stats,
+					...(messagesData ? { messages: messagesData } : {}),
+				};
+			},
+		}),
+	};
+}

package/src/tools/database/index.ts

@@ -0,0 +1,42 @@
+import { buildQuerySessionsTool } from './query-sessions.ts';
+import { buildQueryMessagesTool } from './query-messages.ts';
+import { buildGetSessionContextTool } from './get-session-context.ts';
+import { buildSearchHistoryTool } from './search-history.ts';
+import { buildGetParentSessionTool } from './get-parent-session.ts';
+import { buildPresentActionTool } from './present-session-links.ts';
+
+export type DatabaseTool =
+	| ReturnType<typeof buildQuerySessionsTool>
+	| ReturnType<typeof buildQueryMessagesTool>
+	| ReturnType<typeof buildGetSessionContextTool>
+	| ReturnType<typeof buildSearchHistoryTool>
+	| ReturnType<typeof buildPresentActionTool>
+	| ReturnType<typeof buildGetParentSessionTool>;
+
+export function buildDatabaseTools(
+	projectRoot: string,
+	parentSessionId?: string | null,
+): DatabaseTool[] {
+	const tools: DatabaseTool[] = [
+		buildQuerySessionsTool(projectRoot),
+		buildQueryMessagesTool(projectRoot),
+		buildGetSessionContextTool(projectRoot),
+		buildSearchHistoryTool(projectRoot),
+		buildPresentActionTool(),
+	];
+
+	if (parentSessionId) {
+		tools.push(buildGetParentSessionTool(projectRoot, parentSessionId));
+	}
+
+	return tools;
+}
+
+export {
+	buildQuerySessionsTool,
+	buildQueryMessagesTool,
+	buildGetSessionContextTool,
+	buildSearchHistoryTool,
+	buildGetParentSessionTool,
+	buildPresentActionTool,
+};

package/src/tools/database/present-session-links.ts

@@ -0,0 +1,47 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const sessionLinkSchema = z.object({
+	sessionId: z.string().describe('The session ID to link to'),
+	title: z.string().describe('Display title for the link'),
+	description: z
+		.string()
+		.optional()
+		.describe('Brief description of what this session contains'),
+});
+
+const inputSchema = z.object({
+	type: z
+		.enum(['session_links', 'info', 'warning'])
+		.default('session_links')
+		.describe('Type of action to present'),
+	title: z.string().optional().describe('Optional title for the action block'),
+	summary: z.string().optional().describe('Summary text to display'),
+	links: z
+		.array(sessionLinkSchema)
+		.max(10)
+		.optional()
+		.describe('Session links to present (for session_links type)'),
+});
+
+export function buildPresentActionTool() {
+	return {
+		name: 'present_action',
+		tool: tool({
+			description:
+				'Present an action block to the user with session links or information. Use at the end of your research to let users navigate directly to relevant sessions. The links will be rendered as clickable buttons.',
+			inputSchema,
+			async execute(input) {
+				return {
+					ok: true,
+					type: input.type,
+					title: input.title,
+					summary: input.summary,
+					links: input.links || [],
+				};
+			},
+		}),
+	};
+}
+
+export { buildPresentActionTool as buildPresentSessionLinksTool };

package/src/tools/database/query-messages.ts

@@ -0,0 +1,160 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getDb } from '@agi-cli/database';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { eq, desc, asc, gte, lte, and, like, count, sql } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	sessionId: z.string().optional().describe('Filter by specific session ID'),
+	role: z
+		.enum(['user', 'assistant', 'system', 'tool'])
+		.optional()
+		.describe('Filter by message role'),
+	search: z.string().optional().describe('Full-text search in message content'),
+	toolName: z
+		.string()
+		.optional()
+		.describe('Filter by tool calls with this name'),
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(50)
+		.describe('Max messages to return'),
+	offset: z.number().min(0).default(0).describe('Offset for pagination'),
+	startDate: z
+		.string()
+		.optional()
+		.describe('Filter messages created after this ISO date'),
+	endDate: z
+		.string()
+		.optional()
+		.describe('Filter messages created before this ISO date'),
+});
+
+export function buildQueryMessagesTool(projectRoot: string) {
+	return {
+		name: 'query_messages',
+		tool: tool({
+			description:
+				'Search messages across sessions. Find specific conversations, tool calls, or content patterns in session history.',
+			inputSchema,
+			async execute(input) {
+				const db = await getDb(projectRoot);
+
+				const conditions = [];
+
+				if (input.sessionId) {
+					conditions.push(eq(messages.sessionId, input.sessionId));
+				} else {
+					const projectSessions = db
+						.select({ id: sessions.id })
+						.from(sessions)
+						.where(eq(sessions.projectPath, projectRoot));
+					conditions.push(
+						sql`${messages.sessionId} IN (SELECT id FROM sessions WHERE project_path = ${projectRoot})`,
+					);
+				}
+
+				if (input.role) {
+					conditions.push(eq(messages.role, input.role));
+				}
+
+				if (input.startDate) {
+					const startTs = new Date(input.startDate).getTime();
+					conditions.push(gte(messages.createdAt, startTs));
+				}
+
+				if (input.endDate) {
+					const endTs = new Date(input.endDate).getTime();
+					conditions.push(lte(messages.createdAt, endTs));
+				}
+
+				const rows = await db
+					.select({
+						id: messages.id,
+						sessionId: messages.sessionId,
+						role: messages.role,
+						agent: messages.agent,
+						model: messages.model,
+						createdAt: messages.createdAt,
+						totalTokens: messages.totalTokens,
+						status: messages.status,
+					})
+					.from(messages)
+					.where(conditions.length > 0 ? and(...conditions) : undefined)
+					.orderBy(desc(messages.createdAt))
+					.limit(input.limit * 2)
+					.offset(input.offset);
+
+				const messagesWithContent = await Promise.all(
+					rows.map(async (msg) => {
+						const parts = await db
+							.select({
+								type: messageParts.type,
+								content: messageParts.content,
+								toolName: messageParts.toolName,
+							})
+							.from(messageParts)
+							.where(eq(messageParts.messageId, msg.id))
+							.orderBy(asc(messageParts.index))
+							.limit(10);
+
+						let contentPreview = '';
+						let hasMatchingTool = false;
+
+						for (const part of parts) {
+							if (part.type === 'text' && part.content) {
+								contentPreview = part.content.slice(0, 300);
+							}
+							if (input.toolName && part.toolName === input.toolName) {
+								hasMatchingTool = true;
+							}
+						}
+
+						if (input.toolName && !hasMatchingTool) {
+							return null;
+						}
+
+						if (
+							input.search &&
+							!contentPreview.toLowerCase().includes(input.search.toLowerCase())
+						) {
+							return null;
+						}
+
+						const session = await db
+							.select({ title: sessions.title })
+							.from(sessions)
+							.where(eq(sessions.id, msg.sessionId))
+							.limit(1);
+
+						return {
+							...msg,
+							sessionTitle: session[0]?.title ?? null,
+							contentPreview: contentPreview.slice(0, 200),
+						};
+					}),
+				);
+
+				const filtered = messagesWithContent.filter(
+					(m): m is NonNullable<typeof m> => m !== null,
+				);
+				const limited = filtered.slice(0, input.limit);
+
+				const countResult = await db
+					.select({ total: count() })
+					.from(messages)
+					.where(conditions.length > 0 ? and(...conditions) : undefined);
+
+				return {
+					ok: true,
+					messages: limited,
+					total: countResult[0]?.total ?? 0,
+					limit: input.limit,
+					offset: input.offset,
+				};
+			},
+		}),
+	};
+}

package/src/tools/database/query-sessions.ts

@@ -0,0 +1,124 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getDb } from '@agi-cli/database';
+import { sessions, messages } from '@agi-cli/database/schema';
+import { eq, desc, asc, gte, lte, and, sql, count } from 'drizzle-orm';
+
+const inputSchema = z.object({
+	limit: z
+		.number()
+		.min(1)
+		.max(100)
+		.default(20)
+		.describe('Max sessions to return'),
+	offset: z.number().min(0).default(0).describe('Offset for pagination'),
+	agent: z.string().optional().describe('Filter by agent type'),
+	startDate: z
+		.string()
+		.optional()
+		.describe('Filter sessions created after this ISO date'),
+	endDate: z
+		.string()
+		.optional()
+		.describe('Filter sessions created before this ISO date'),
+	orderBy: z
+		.enum(['created_at', 'last_active_at', 'total_tokens'])
+		.default('last_active_at')
+		.describe('Sort field'),
+	orderDir: z.enum(['asc', 'desc']).default('desc').describe('Sort direction'),
+	sessionType: z
+		.enum(['main', 'research', 'all'])
+		.default('main')
+		.describe('Filter by session type'),
+});
+
+export function buildQuerySessionsTool(projectRoot: string) {
+	return {
+		name: 'query_sessions',
+		tool: tool({
+			description:
+				'Search and list sessions from the local database. Use to find past conversations, check what work was done, or locate specific sessions.',
+			inputSchema,
+			async execute(input) {
+				const db = await getDb(projectRoot);
+
+				const conditions = [eq(sessions.projectPath, projectRoot)];
+
+				if (input.sessionType !== 'all') {
+					conditions.push(eq(sessions.sessionType, input.sessionType));
+				}
+
+				if (input.agent) {
+					conditions.push(eq(sessions.agent, input.agent));
+				}
+
+				if (input.startDate) {
+					const startTs = new Date(input.startDate).getTime();
+					conditions.push(gte(sessions.createdAt, startTs));
+				}
+
+				if (input.endDate) {
+					const endTs = new Date(input.endDate).getTime();
+					conditions.push(lte(sessions.createdAt, endTs));
+				}
+
+				const orderField =
+					input.orderBy === 'created_at'
+						? sessions.createdAt
+						: input.orderBy === 'total_tokens'
+							? sessions.totalInputTokens
+							: sessions.lastActiveAt;
+
+				const orderFn = input.orderDir === 'asc' ? asc : desc;
+
+				const rows = await db
+					.select({
+						id: sessions.id,
+						title: sessions.title,
+						agent: sessions.agent,
+						provider: sessions.provider,
+						model: sessions.model,
+						createdAt: sessions.createdAt,
+						lastActiveAt: sessions.lastActiveAt,
+						totalInputTokens: sessions.totalInputTokens,
+						totalOutputTokens: sessions.totalOutputTokens,
+						sessionType: sessions.sessionType,
+						parentSessionId: sessions.parentSessionId,
+					})
+					.from(sessions)
+					.where(and(...conditions))
+					.orderBy(orderFn(orderField), desc(sessions.createdAt))
+					.limit(input.limit)
+					.offset(input.offset);
+
+				const countResult = await db
+					.select({ total: count() })
+					.from(sessions)
+					.where(and(...conditions));
+
+				const total = countResult[0]?.total ?? 0;
+
+				const sessionsWithCounts = await Promise.all(
+					rows.map(async (row) => {
+						const msgCount = await db
+							.select({ count: count() })
+							.from(messages)
+							.where(eq(messages.sessionId, row.id));
+						return {
+							...row,
+							messageCount: msgCount[0]?.count ?? 0,
+						};
+					}),
+				);
+
+				return {
+					ok: true,
+					sessions: sessionsWithCounts,
+					total,
+					limit: input.limit,
+					offset: input.offset,
+				};
+			},
+		}),
+	};
+}