Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat(shared): conversation, message, task, task-message queries

Gener3e32afedf367
diff --git a/src/shared/src/db/queries/conversation.ts b/src/shared/src/db/queries/conversation.ts
new file mode 100644
index 000000000..b2f702b2c
--- /dev/null
+++ b/src/shared/src/db/queries/conversation.ts
@@ -0,0 +1,99 @@
+import { eq, and, desc, count } from "drizzle-orm";
+import { conversation, message } from "../schema";
+import type { Database } from "../index";
+
+export async function createConversation(
+ db: Database,
+ data: {
+ workspaceId: string;
+ agentId: string;
+ userId: string;
+ title: string;
+ }
+) {
+ const rows = await db
+ .insert(conversation)
+ .values({
+ workspaceId: data.workspaceId,
+ agentId: data.agentId,
+ userId: data.userId,
+ title: data.title,
+ })
+ .returning();
+ return rows[0]!;
+}
+
+export async function getConversation(db: Database, id: string) {
+ const rows = await db
+ .select()
+ .from(conversation)
+ .where(eq(conversation.id, id));
+ return rows[0] ?? null;
+}
+
+export async function listConversations(
+ db: Database,
+ workspaceId: string,
+ userId: string
+) {
+ return db
+ .select()
+ .from(conversation)
+ .where(
+ and(
+ eq(conversation.workspaceId, workspaceId),
+ eq(conversation.userId, userId)
+ )
+ )
+ .orderBy(desc(conversation.createdAt));
+}
+
+export async function listConversationsByAgent(
+ db: Database,
+ workspaceId: string,
+ userId: string,
+ agentId: string
+) {
+ return db
+ .select({
+ id: conversation.id,
+ workspaceId: conversation.workspaceId,
+ agentId: conversation.agentId,
+ userId: conversation.userId,
+ title: conversation.title,
+ createdAt: conversation.createdAt,
+ messageCount: count(message.id).mapWith(Number),
+ })
+ .from(conversation)
+ .leftJoin(message, eq(message.conversationId, conversation.id))
+ .where(
+ and(
+ eq(conversation.workspaceId, workspaceId),
+ eq(conversation.userId, userId),
+ eq(conversation.agentId, agentId)
+ )
+ )
+ .groupBy(conversation.id)
+ .orderBy(desc(conversation.createdAt));
+}
+
+export async function updateConversationTitle(
+ db: Database,
+ id: string,
+ title: string
+) {
+ const rows = await db
+ .update(conversation)
+ .set({ title })
+ .where(and(eq(conversation.id, id), eq(conversation.title, "")))
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function deleteConversation(db: Database, id: string) {
+ const rows = await db
+ .delete(conversation)
+ .where(eq(conversation.id, id))
+ .returning();
+ return rows[0] ?? null;
+}
diff --git a/src/shared/src/db/queries/message.ts b/src/shared/src/db/queries/message.ts
new file mode 100644
index 000000000..9fdbc524e
--- /dev/null
+++ b/src/shared/src/db/queries/message.ts
@@ -0,0 +1,37 @@
+import { eq, asc } from "drizzle-orm";
+import { message } from "../schema";
+import type { Database } from "../index";
+
+export async function createMessage(
+ db: Database,
+ data: {
+ conversationId: string;
+ role: string;
+ content: string;
+ taskId?: string | null;
+ }
+) {
+ const rows = await db
+ .insert(message)
+ .values({
+ conversationId: data.conversationId,
+ role: data.role,
+ content: data.content,
+ taskId: data.taskId ?? null,
+ })
+ .returning();
+ return rows[0]!;
+}
+
+export async function listMessages(db: Database, conversationId: string) {
+ return db
+ .select()
+ .from(message)
+ .where(eq(message.conversationId, conversationId))
+ .orderBy(asc(message.createdAt));
+}
+
+export async function getMessage(db: Database, id: string) {
+ const rows = await db.select().from(message).where(eq(message.id, id));
+ return rows[0] ?? null;
+}
diff --git a/src/shared/src/db/queries/task-message.ts b/src/shared/src/db/queries/task-message.ts
new file mode 100644
index 000000000..a32169955
--- /dev/null
+++ b/src/shared/src/db/queries/task-message.ts
@@ -0,0 +1,54 @@
+import { eq, and, gt, asc } from "drizzle-orm";
+import { taskMessage } from "../schema";
+import type { Database } from "../index";
+
+export async function createTaskMessage(
+ db: Database,
+ data: {
+ taskId: string;
+ seq: number;
+ type: string;
+ tool: string;
+ content: string;
+ input?: unknown;
+ output: string;
+ }
+) {
+ const rows = await db
+ .insert(taskMessage)
+ .values({
+ taskId: data.taskId,
+ seq: data.seq,
+ type: data.type,
+ tool: data.tool,
+ content: data.content,
+ input: data.input ?? null,
+ output: data.output,
+ })
+ .returning();
+ return rows[0]!;
+}
+
+export async function listTaskMessages(db: Database, taskId: string) {
+ return db
+ .select()
+ .from(taskMessage)
+ .where(eq(taskMessage.taskId, taskId))
+ .orderBy(asc(taskMessage.seq));
+}
+
+export async function listTaskMessagesSince(
+ db: Database,
+ taskId: string,
+ afterSeq: number
+) {
+ return db
+ .select()
+ .from(taskMessage)
+ .where(and(eq(taskMessage.taskId, taskId), gt(taskMessage.seq, afterSeq)))
+ .orderBy(asc(taskMessage.seq));
+}
+
+export async function deleteTaskMessages(db: Database, taskId: string) {
+ await db.delete(taskMessage).where(eq(taskMessage.taskId, taskId));
+}
diff --git a/src/shared/src/db/queries/task.ts b/src/shared/src/db/queries/task.ts
new file mode 100644
index 000000000..ecfb44892
--- /dev/null
+++ b/src/shared/src/db/queries/task.ts
@@ -0,0 +1,258 @@
+import { eq, and, desc, asc, inArray, notInArray, isNotNull, count, lt } from "drizzle-orm";
+import { agentTaskQueue } from "../schema";
+import type { Database } from "../index";
+import { ClaimedTaskRowSchema } from "../../schemas";
+
+export async function createTask(
+ db: Database,
+ data: {
+ agentId: string;
+ runtimeId: string;
+ workspaceId: string;
+ conversationId: string;
+ prompt: string;
+ priority?: number;
+ }
+) {
+ const rows = await db
+ .insert(agentTaskQueue)
+ .values({
+ agentId: data.agentId,
+ runtimeId: data.runtimeId,
+ workspaceId: data.workspaceId,
+ conversationId: data.conversationId,
+ prompt: data.prompt,
+ priority: data.priority ?? 0,
+ })
+ .returning();
+ return rows[0]!;
+}
+
+export async function getTask(db: Database, id: string) {
+ const rows = await db
+ .select()
+ .from(agentTaskQueue)
+ .where(eq(agentTaskQueue.id, id));
+ return rows[0] ?? null;
+}
+
+export async function getTaskStatus(db: Database, id: string) {
+ const rows = await db
+ .select({ status: agentTaskQueue.status })
+ .from(agentTaskQueue)
+ .where(eq(agentTaskQueue.id, id));
+ return rows[0]?.status ?? null;
+}
+
+export async function claimTask(db: Database, agentId: string) {
+ // Step 1: Get conversations that have active (dispatched/running) tasks
+ const activeConversations = await db
+ .select({ conversationId: agentTaskQueue.conversationId })
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.agentId, agentId),
+ inArray(agentTaskQueue.status, ["dispatched", "running"])
+ )
+ );
+
+ const activeConvIds = activeConversations.map((r) => r.conversationId);
+
+ // Step 2: Find queued tasks not in those conversations
+ const candidateQuery = db
+ .select({ id: agentTaskQueue.id })
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.agentId, agentId),
+ eq(agentTaskQueue.status, "queued"),
+ ...(activeConvIds.length > 0
+ ? [notInArray(agentTaskQueue.conversationId, activeConvIds)]
+ : [])
+ )
+ )
+ .orderBy(desc(agentTaskQueue.priority), asc(agentTaskQueue.createdAt))
+ .limit(1);
+
+ const candidates = await candidateQuery;
+
+ if (candidates.length === 0) return null;
+
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({ status: "dispatched", dispatchedAt: new Date().toISOString() })
+ .where(
+ and(
+ eq(agentTaskQueue.id, candidates[0].id),
+ eq(agentTaskQueue.status, "queued")
+ )
+ )
+ .returning();
+
+ const row = rows[0] ?? null;
+ if (!row) return null;
+ return ClaimedTaskRowSchema.parse(row);
+}
+
+export async function startTask(db: Database, id: string) {
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({ status: "running", startedAt: new Date().toISOString() })
+ .where(
+ and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.status, "dispatched"))
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function completeTask(
+ db: Database,
+ id: string,
+ data: { result: unknown; sessionId: string | null; workDir: string | null }
+) {
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({
+ status: "completed",
+ completedAt: new Date().toISOString(),
+ result: data.result,
+ sessionId: data.sessionId,
+ workDir: data.workDir,
+ })
+ .where(
+ and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.status, "running"))
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function failTask(
+ db: Database,
+ id: string,
+ error: string
+) {
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({ status: "failed", completedAt: new Date().toISOString(), error })
+ .where(
+ and(
+ eq(agentTaskQueue.id, id),
+ inArray(agentTaskQueue.status, ["dispatched", "running"])
+ )
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function getLastTaskSession(
+ db: Database,
+ agentId: string,
+ conversationId: string
+) {
+ const rows = await db
+ .select({
+ sessionId: agentTaskQueue.sessionId,
+ workDir: agentTaskQueue.workDir,
+ })
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.agentId, agentId),
+ eq(agentTaskQueue.conversationId, conversationId),
+ eq(agentTaskQueue.status, "completed"),
+ isNotNull(agentTaskQueue.sessionId)
+ )
+ )
+ .orderBy(desc(agentTaskQueue.completedAt))
+ .limit(1);
+ return rows[0] ?? null;
+}
+
+export async function listPendingTasksByRuntime(
+ db: Database,
+ runtimeId: string
+) {
+ return db
+ .select()
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.runtimeId, runtimeId),
+ inArray(agentTaskQueue.status, ["queued", "dispatched"])
+ )
+ )
+ .orderBy(desc(agentTaskQueue.priority), asc(agentTaskQueue.createdAt));
+}
+
+export async function hasPendingTaskForConversation(
+ db: Database,
+ conversationId: string
+) {
+ const rows = await db
+ .select({ id: agentTaskQueue.id })
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.conversationId, conversationId),
+ inArray(agentTaskQueue.status, ["queued", "dispatched"])
+ )
+ )
+ .limit(1);
+ return rows.length > 0;
+}
+
+export async function cancelTask(db: Database, id: string) {
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({ status: "cancelled", completedAt: new Date().toISOString() })
+ .where(
+ and(
+ eq(agentTaskQueue.id, id),
+ inArray(agentTaskQueue.status, ["queued", "dispatched", "running"])
+ )
+ )
+ .returning();
+ return rows[0] ?? null;
+}
+
+export async function failStaleDispatchedTasks(db: Database, staleSeconds = 20) {
+ const threshold = new Date(Date.now() - staleSeconds * 1000).toISOString();
+ const rows = await db
+ .update(agentTaskQueue)
+ .set({
+ status: "failed",
+ completedAt: new Date().toISOString(),
+ error: "timed out in dispatched state (daemon likely disconnected)",
+ })
+ .where(
+ and(
+ eq(agentTaskQueue.status, "dispatched"),
+ lt(agentTaskQueue.dispatchedAt, threshold)
+ )
+ )
+ .returning({ agentId: agentTaskQueue.agentId });
+ return rows;
+}
+
+export async function deleteTasksByConversation(
+ db: Database,
+ conversationId: string
+) {
+ return db
+ .delete(agentTaskQueue)
+ .where(eq(agentTaskQueue.conversationId, conversationId))
+ .returning({ id: agentTaskQueue.id });
+}
+
+export async function countRunningTasks(db: Database, agentId: string) {
+ const rows = await db
+ .select({ value: count() })
+ .from(agentTaskQueue)
+ .where(
+ and(
+ eq(agentTaskQueue.agentId, agentId),
+ inArray(agentTaskQueue.status, ["dispatched", "running"])
+ )
+ );
+ return Number(rows[0]?.value ?? 0);
+}