@alook/app 0.0.117 → 0.0.119

package/bundled/ws-do/index.js

@@ -16245,6 +16245,10 @@ var CreateAgentLinkRequestSchema = external_exports.object({
 var UpdateAgentLinkRequestSchema = external_exports.object({
   instruction: external_exports.string()
 });
+var UpsertAgentLinkRequestSchema = external_exports.object({
+  target_agent_id: external_exports.string().min(1, "target_agent_id is required"),
+  instruction: external_exports.string()
+});
 var AddWhitelistRequestSchema = external_exports.object({
   email: external_exports.string().email()
 });
@@ -16278,8 +16282,9 @@ var CreateConversationRequestSchema = external_exports.object({
 var CreateMessageRequestSchema = external_exports.object({
   content: external_exports.string().min(1, "content is required")
 });
-var CreateBufferedMessageRequestSchema = external_exports.object({
-  content: external_exports.string().min(1, "content is required")
+var AgentDmRequestSchema = external_exports.object({
+  content: external_exports.string().min(1, "content is required"),
+  task_id: external_exports.string().min(1).optional()
 });
 var EmailAttachmentSchema = external_exports.object({
   key: external_exports.string().min(1),
@@ -22462,6 +22467,7 @@ __export(schema_exports, {
   conversationMap: () => conversationMap,
   conversationReadState: () => conversationReadState,
   emails: () => emails,
+  inboxUnread: () => inboxUnread,
   issue: () => issue2,
   issueComment: () => issueComment,
   machine: () => machine,
@@ -23132,6 +23138,26 @@ var agentSkill = sqliteTable(
     }).onDelete("cascade")
   ]
 );
+var inboxUnread = sqliteTable(
+  "inbox_unread",
+  {
+    id: text("id").primaryKey().$defaultFn(() => nanoid3()),
+    conversationId: text("conversation_id").notNull().references(() => conversation.id, { onDelete: "cascade" }),
+    userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+    workspaceId: text("workspace_id").notNull(),
+    agentId: text("agent_id").notNull(),
+    taskId: text("task_id").notNull(),
+    taskType: text("task_type").notNull(),
+    taskStatus: text("task_status").notNull(),
+    taskPrompt: text("task_prompt"),
+    completedAt: text("completed_at").notNull(),
+    latestMessageId: text("latest_message_id")
+  },
+  (t) => [
+    unique("inbox_unread_conv_user").on(t.conversationId, t.userId),
+    index("idx_inbox_unread_user_ws").on(t.userId, t.workspaceId, t.taskType, t.completedAt)
+  ]
+);
 
 // ../shared/src/db/index.ts
 function createDb(d1) {
@@ -23708,19 +23734,12 @@ __name(hasPreviousConversations, "hasPreviousConversations");
 // ../shared/src/db/queries/message.ts
 var message_exports = {};
 __export(message_exports, {
-  activateNextBufferedMessage: () => activateNextBufferedMessage,
-  countBufferedMessages: () => countBufferedMessages,
-  createBufferedMessage: () => createBufferedMessage,
   createMessage: () => createMessage,
-  deleteAllBufferedMessages: () => deleteAllBufferedMessages,
-  deleteBufferedMessage: () => deleteBufferedMessage,
   getActiveMessageCount: () => getActiveMessageCount,
   getMessage: () => getMessage,
   getNewestMessageId: () => getNewestMessageId,
-  listBufferedMessages: () => listBufferedMessages,
   listMessages: () => listMessages,
   listMessagesAroundTask: () => listMessagesAroundTask,
-  revertToBuffered: () => revertToBuffered,
   updateMessageTaskId: () => updateMessageTaskId
 });
 async function createMessage(db, data) {
@@ -23782,69 +23801,6 @@ async function getMessage(db, id) {
   return rows[0] ?? null;
 }
 __name(getMessage, "getMessage");
-async function createBufferedMessage(db, data) {
-  const rows = await db.insert(message).values({
-    conversationId: data.conversationId,
-    role: "user",
-    content: data.content,
-    status: "buffered",
-    attachmentIds: data.attachmentIds ?? null
-  }).returning();
-  return rows[0];
-}
-__name(createBufferedMessage, "createBufferedMessage");
-async function listBufferedMessages(db, conversationId) {
-  return db.select().from(message).where(
-    and(
-      eq(message.conversationId, conversationId),
-      eq(message.status, "buffered")
-    )
-  ).orderBy(asc(message.createdAt), asc(message.id));
-}
-__name(listBufferedMessages, "listBufferedMessages");
-async function activateNextBufferedMessage(db, conversationId) {
-  const candidates = await db.select().from(message).where(
-    and(
-      eq(message.conversationId, conversationId),
-      eq(message.status, "buffered")
-    )
-  ).orderBy(asc(message.createdAt), asc(message.id)).limit(1);
-  if (candidates.length === 0) return null;
-  const target = candidates[0];
-  const updated = await db.update(message).set({ status: "active", createdAt: new Date(Date.now() + 1e3).toISOString() }).where(and(eq(message.id, target.id), eq(message.status, "buffered"))).returning();
-  return updated[0] ?? null;
-}
-__name(activateNextBufferedMessage, "activateNextBufferedMessage");
-async function revertToBuffered(db, id) {
-  const rows = await db.update(message).set({ status: "buffered" }).where(and(eq(message.id, id), eq(message.status, "active"))).returning();
-  return rows[0] ?? null;
-}
-__name(revertToBuffered, "revertToBuffered");
-async function deleteBufferedMessage(db, id) {
-  const rows = await db.delete(message).where(and(eq(message.id, id), eq(message.status, "buffered"))).returning();
-  return rows[0] ?? null;
-}
-__name(deleteBufferedMessage, "deleteBufferedMessage");
-async function deleteAllBufferedMessages(db, conversationId) {
-  const rows = await db.delete(message).where(
-    and(
-      eq(message.conversationId, conversationId),
-      eq(message.status, "buffered")
-    )
-  ).returning();
-  return rows;
-}
-__name(deleteAllBufferedMessages, "deleteAllBufferedMessages");
-async function countBufferedMessages(db, conversationId) {
-  const rows = await db.select({ count: count3(message.id) }).from(message).where(
-    and(
-      eq(message.conversationId, conversationId),
-      eq(message.status, "buffered")
-    )
-  );
-  return rows[0]?.count ?? 0;
-}
-__name(countBufferedMessages, "countBufferedMessages");
 async function updateMessageTaskId(db, messageId, taskId) {
   await db.update(message).set({ taskId }).where(eq(message.id, messageId));
 }
@@ -24576,9 +24532,9 @@ __name(getTraceTree, "getTraceTree");
 // ../shared/src/db/queries/task-message.ts
 var task_message_exports = {};
 __export(task_message_exports, {
-  countTextMessagesByTaskIds: () => countTextMessagesByTaskIds,
   createTaskMessage: () => createTaskMessage,
   deleteTaskMessages: () => deleteTaskMessages,
+  listTaskErrorMessages: () => listTaskErrorMessages,
   listTaskMessages: () => listTaskMessages,
   listTaskMessagesSince: () => listTaskMessagesSince
 });
@@ -24614,6 +24570,27 @@ async function listTaskMessages(db, taskId, workspaceId) {
   return db.select().from(taskMessage).where(and(eq(taskMessage.taskId, taskId), notInArray(taskMessage.type, ["tool-result", "tool-use", "thinking"]))).orderBy(asc(taskMessage.seq));
 }
 __name(listTaskMessages, "listTaskMessages");
+async function listTaskErrorMessages(db, taskId, workspaceId) {
+  return db.select({
+    id: taskMessage.id,
+    taskId: taskMessage.taskId,
+    seq: taskMessage.seq,
+    type: taskMessage.type,
+    tool: taskMessage.tool,
+    content: taskMessage.content,
+    callId: taskMessage.callId,
+    input: taskMessage.input,
+    output: taskMessage.output,
+    createdAt: taskMessage.createdAt
+  }).from(taskMessage).innerJoin(agentTaskQueue, eq(taskMessage.taskId, agentTaskQueue.id)).where(
+    and(
+      eq(taskMessage.taskId, taskId),
+      eq(agentTaskQueue.workspaceId, workspaceId),
+      eq(taskMessage.type, "error")
+    )
+  ).orderBy(asc(taskMessage.seq));
+}
+__name(listTaskErrorMessages, "listTaskErrorMessages");
 async function listTaskMessagesSince(db, taskId, afterSeq) {
   return db.select().from(taskMessage).where(and(eq(taskMessage.taskId, taskId), gt(taskMessage.seq, afterSeq), notInArray(taskMessage.type, ["tool-result", "tool-use", "thinking"]))).orderBy(asc(taskMessage.seq));
 }
@@ -24622,42 +24599,6 @@ async function deleteTaskMessages(db, taskId) {
   await db.delete(taskMessage).where(eq(taskMessage.taskId, taskId));
 }
 __name(deleteTaskMessages, "deleteTaskMessages");
-var SQLITE_MAX_PARAMS = 999;
-var FIXED_PARAMS = 2;
-async function countTextMessagesByTaskIds(db, taskIds, workspaceId) {
-  if (taskIds.length === 0) return [];
-  const chunkSize = SQLITE_MAX_PARAMS - FIXED_PARAMS;
-  if (taskIds.length <= chunkSize) {
-    const rows = await db.select({
-      taskId: taskMessage.taskId,
-      count: count3(taskMessage.id)
-    }).from(taskMessage).innerJoin(agentTaskQueue, eq(taskMessage.taskId, agentTaskQueue.id)).where(
-      and(
-        inArray(taskMessage.taskId, taskIds),
-        eq(agentTaskQueue.workspaceId, workspaceId),
-        eq(taskMessage.type, "text")
-      )
-    ).groupBy(taskMessage.taskId);
-    return rows.map((r) => ({ taskId: r.taskId, count: r.count }));
-  }
-  const results = [];
-  for (let i = 0; i < taskIds.length; i += chunkSize) {
-    const chunk = taskIds.slice(i, i + chunkSize);
-    const rows = await db.select({
-      taskId: taskMessage.taskId,
-      count: count3(taskMessage.id)
-    }).from(taskMessage).innerJoin(agentTaskQueue, eq(taskMessage.taskId, agentTaskQueue.id)).where(
-      and(
-        inArray(taskMessage.taskId, chunk),
-        eq(agentTaskQueue.workspaceId, workspaceId),
-        eq(taskMessage.type, "text")
-      )
-    ).groupBy(taskMessage.taskId);
-    results.push(...rows.map((r) => ({ taskId: r.taskId, count: r.count })));
-  }
-  return results;
-}
-__name(countTextMessagesByTaskIds, "countTextMessagesByTaskIds");
 
 // ../shared/src/db/queries/machine.ts
 var machine_exports = {};
@@ -25960,12 +25901,14 @@ var agent_link_exports = {};
 __export(agent_link_exports, {
   create: () => create,
   getAllColleaguesForWorkspace: () => getAllColleaguesForWorkspace,
+  getByPair: () => getByPair,
   getColleaguesForAgent: () => getColleaguesForAgent,
   getColleaguesForAgents: () => getColleaguesForAgents,
   listByAgent: () => listByAgent,
   listByWorkspace: () => listByWorkspace,
   remove: () => remove,
-  update: () => update
+  update: () => update,
+  upsertByPair: () => upsertByPair
 });
 async function listByWorkspace(db, workspaceId, opts) {
   let q = db.select().from(agentLink).where(eq(agentLink.workspaceId, workspaceId)).$dynamic();
@@ -26000,6 +25943,36 @@ async function create(db, data) {
   return rows[0];
 }
 __name(create, "create");
+async function getByPair(db, workspaceId, a, b) {
+  const [sourceAgentId, targetAgentId] = a > b ? [b, a] : [a, b];
+  const rows = await db.select().from(agentLink).where(
+    and(
+      eq(agentLink.workspaceId, workspaceId),
+      eq(agentLink.sourceAgentId, sourceAgentId),
+      eq(agentLink.targetAgentId, targetAgentId)
+    )
+  );
+  return rows[0] ?? null;
+}
+__name(getByPair, "getByPair");
+async function upsertByPair(db, data) {
+  const existing = await getByPair(
+    db,
+    data.workspaceId,
+    data.sourceAgentId,
+    data.targetAgentId
+  );
+  if (existing) {
+    const updated = await update(db, existing.id, data.workspaceId, {
+      instruction: data.instruction
+    });
+    if (!updated) return { row: existing, created: false };
+    return { row: updated, created: false };
+  }
+  const created = await create(db, data);
+  return { row: created, created: true };
+}
+__name(upsertByPair, "upsertByPair");
 async function update(db, id, workspaceId, data) {
   const rows = await db.update(agentLink).set({
     instruction: data.instruction,
@@ -26108,68 +26081,103 @@ __name(getAllColleaguesForWorkspace, "getAllColleaguesForWorkspace");
 // ../shared/src/db/queries/inbox.ts
 var inbox_exports = {};
 __export(inbox_exports, {
+  deleteAllUnreadEntries: () => deleteAllUnreadEntries,
+  deleteUnreadEntry: () => deleteUnreadEntry,
+  findLatestAssistantMessageId: () => findLatestAssistantMessageId,
   getUnreadCount: () => getUnreadCount,
+  isUnreadEligible: () => isUnreadEligible,
   listUnreadConversations: () => listUnreadConversations,
   markAllConversationsRead: () => markAllConversationsRead,
-  markConversationRead: () => markConversationRead
-});
+  markConversationRead: () => markConversationRead,
+  updateUnreadLatestMessage: () => updateUnreadLatestMessage,
+  upsertUnreadEntry: () => upsertUnreadEntry
+});
+var UNREAD_ELIGIBLE_TYPES = ["user_dm_message", "email_notification", "calendar_event"];
+function isUnreadEligible(task) {
+  if (task.parentTaskId != null) return false;
+  if (task.traceId == null) return false;
+  if (!UNREAD_ELIGIBLE_TYPES.includes(task.type)) return false;
+  if (task.type === "email_notification" && task.context?.isInternal === true) return false;
+  return true;
+}
+__name(isUnreadEligible, "isUnreadEligible");
+async function upsertUnreadEntry(db, entry) {
+  const id = nanoid3();
+  await db.run(sql`
+    INSERT INTO inbox_unread (id, conversation_id, user_id, workspace_id, agent_id, task_id, task_type, task_status, task_prompt, completed_at, latest_message_id)
+    VALUES (${id}, ${entry.conversationId}, ${entry.userId}, ${entry.workspaceId}, ${entry.agentId}, ${entry.taskId}, ${entry.taskType}, ${entry.taskStatus}, ${entry.taskPrompt}, ${entry.completedAt}, ${entry.latestMessageId})
+    ON CONFLICT (conversation_id, user_id) DO UPDATE SET
+      agent_id = excluded.agent_id,
+      task_id = excluded.task_id,
+      task_type = excluded.task_type,
+      task_status = excluded.task_status,
+      task_prompt = excluded.task_prompt,
+      completed_at = excluded.completed_at,
+      latest_message_id = excluded.latest_message_id
+    WHERE excluded.completed_at >= inbox_unread.completed_at
+  `);
+}
+__name(upsertUnreadEntry, "upsertUnreadEntry");
+async function updateUnreadLatestMessage(db, conversationId, userId, messageId) {
+  await db.run(sql`
+    UPDATE inbox_unread
+    SET latest_message_id = ${messageId}
+    WHERE conversation_id = ${conversationId} AND user_id = ${userId}
+  `);
+}
+__name(updateUnreadLatestMessage, "updateUnreadLatestMessage");
+async function deleteUnreadEntry(db, conversationId, userId) {
+  await db.run(sql`
+    DELETE FROM inbox_unread
+    WHERE conversation_id = ${conversationId} AND user_id = ${userId}
+  `);
+}
+__name(deleteUnreadEntry, "deleteUnreadEntry");
+async function deleteAllUnreadEntries(db, userId, workspaceId) {
+  await db.run(sql`
+    DELETE FROM inbox_unread
+    WHERE user_id = ${userId} AND workspace_id = ${workspaceId}
+  `);
+}
+__name(deleteAllUnreadEntries, "deleteAllUnreadEntries");
+async function findLatestAssistantMessageId(db, conversationId) {
+  const rows = await db.all(sql`
+    SELECT id FROM message
+    WHERE conversation_id = ${conversationId}
+      AND role = 'assistant'
+      AND status = 'active'
+    ORDER BY created_at DESC
+    LIMIT 1
+  `);
+  return rows[0]?.id ?? null;
+}
+__name(findLatestAssistantMessageId, "findLatestAssistantMessageId");
 async function listUnreadConversations(db, userId, workspaceId, opts) {
   const limit = opts?.limit ?? 30;
-  const beforeClause = opts?.before ? sql`AND t.completed_at < ${opts.before}` : sql``;
+  const beforeClause = opts?.before ? sql`AND u.completed_at < ${opts.before}` : sql``;
   const types = opts?.types?.length ? opts.types : ["user_dm_message"];
   const typePlaceholders = sql.join(types.map((t) => sql`${t}`), sql`, `);
   const rows = await db.all(sql`
-    SELECT c.id,
-           c.agent_id,
+    SELECT u.conversation_id AS id,
+           u.agent_id,
            c.title,
            c.channel,
-           m_latest.content AS latest_response,
-           t.completed_at AS latest_response_at,
-           t.prompt AS root_prompt,
+           m.content AS latest_response,
+           u.completed_at AS latest_response_at,
+           u.task_prompt AS root_prompt,
            a.name AS agent_name,
            a.avatar_url AS agent_avatar_url,
-           t.status AS root_task_status,
-           t.type AS root_task_type
-    FROM agent_task_queue t
-    INNER JOIN conversation c
-      ON c.id = t.conversation_id
-      AND c.user_id = ${userId}
-      AND c.workspace_id = ${workspaceId}
-    LEFT JOIN conversation_read_state crs
-      ON crs.conversation_id = c.id AND crs.user_id = ${userId}
-    INNER JOIN message m_latest
-      ON m_latest.conversation_id = c.id
-      AND m_latest.role = 'assistant'
-      AND m_latest.status = 'active'
-      AND m_latest.id = (
-        SELECT id FROM message
-        WHERE conversation_id = c.id
-          AND role = 'assistant'
-          AND status = 'active'
-        ORDER BY created_at DESC LIMIT 1
-      )
-    LEFT JOIN agent a
-      ON a.id = c.agent_id AND a.workspace_id = c.workspace_id
-    WHERE t.workspace_id = ${workspaceId}
-      AND t.parent_task_id IS NULL
-      AND t.trace_id IS NOT NULL
-      AND t.type IN (${typePlaceholders})
-      AND t.status IN ('completed', 'failed')
-      AND t.completed_at > COALESCE(crs.last_read_at, '1970-01-01T00:00:00.000Z')
-      AND NOT (t.type = 'email_notification' AND COALESCE(json_extract(t.context, '$.isInternal'), 0) = 1)
-      AND t.id = (
-        SELECT id FROM agent_task_queue
-        WHERE workspace_id = ${workspaceId}
-          AND conversation_id = c.id
-          AND parent_task_id IS NULL
-          AND trace_id IS NOT NULL
-          AND type IN (${typePlaceholders})
-          AND status IN ('completed', 'failed')
-          AND NOT (type = 'email_notification' AND COALESCE(json_extract(context, '$.isInternal'), 0) = 1)
-        ORDER BY completed_at DESC LIMIT 1
-      )
+           u.task_status AS root_task_status,
+           u.task_type AS root_task_type
+    FROM inbox_unread u
+    INNER JOIN conversation c ON c.id = u.conversation_id
+    LEFT JOIN message m ON m.id = u.latest_message_id
+    LEFT JOIN agent a ON a.id = u.agent_id AND a.workspace_id = u.workspace_id
+    WHERE u.user_id = ${userId}
+      AND u.workspace_id = ${workspaceId}
+      AND u.task_type IN (${typePlaceholders})
       ${beforeClause}
-    ORDER BY t.completed_at DESC
+    ORDER BY u.completed_at DESC
     LIMIT ${limit + 1}
   `);
   const hasMore = rows.length > limit;
@@ -26181,21 +26189,11 @@ async function getUnreadCount(db, userId, workspaceId, types) {
   const validTypes = types?.length ? types : ["user_dm_message"];
   const typePlaceholders = sql.join(validTypes.map((t) => sql`${t}`), sql`, `);
   const rows = await db.all(sql`
-    SELECT COUNT(DISTINCT t.conversation_id) AS count
-    FROM agent_task_queue t
-    INNER JOIN conversation c
-      ON c.id = t.conversation_id
-      AND c.user_id = ${userId}
-      AND c.workspace_id = ${workspaceId}
-    LEFT JOIN conversation_read_state crs
-      ON crs.conversation_id = t.conversation_id AND crs.user_id = ${userId}
-    WHERE t.workspace_id = ${workspaceId}
-      AND t.parent_task_id IS NULL
-      AND t.trace_id IS NOT NULL
-      AND t.type IN (${typePlaceholders})
-      AND t.status IN ('completed', 'failed')
-      AND t.completed_at > COALESCE(crs.last_read_at, '1970-01-01T00:00:00.000Z')
-      AND NOT (t.type = 'email_notification' AND COALESCE(json_extract(t.context, '$.isInternal'), 0) = 1)
+    SELECT COUNT(*) AS count
+    FROM inbox_unread
+    WHERE user_id = ${userId}
+      AND workspace_id = ${workspaceId}
+      AND task_type IN (${typePlaceholders})
   `);
   return rows[0]?.count ?? 0;
 }
@@ -26208,6 +26206,7 @@ async function markConversationRead(db, userId, conversationId) {
     ON CONFLICT (conversation_id, user_id)
     DO UPDATE SET last_read_at = ${now}
   `);
+  await deleteUnreadEntry(db, conversationId, userId);
 }
 __name(markConversationRead, "markConversationRead");
 async function markAllConversationsRead(db, userId, workspaceId) {
@@ -26221,6 +26220,7 @@ async function markAllConversationsRead(db, userId, workspaceId) {
     ON CONFLICT (conversation_id, user_id)
     DO UPDATE SET last_read_at = ${now}
   `);
+  await deleteAllUnreadEntries(db, userId, workspaceId);
 }
 __name(markAllConversationsRead, "markAllConversationsRead");