agent-relay-server 0.32.4 → 0.33.1

package/src/db/message-reads.ts

@@ -0,0 +1,304 @@
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import { isRecord, stringValue, isMechanicalMessageKind } from "agent-relay-sdk";
+import { ORCHESTRATOR_PROTOCOL_VERSION, VERSION } from "../config.ts";
+import { parseJson } from "../utils";
+import { isLiveIsolatedWorkspace } from "../workspace-phase";
+import {
+  CONTRACT_REQUIREMENTS,
+  contractCompatibility,
+  parseRuntimeCapabilities,
+  parseRuntimeContracts,
+  parseRuntimePackage,
+  type RuntimeContracts,
+} from "../contracts";
+import { STALE_TTL_MS, DAY_MS, CLAIM_LEASE_MS, POOL_CLAIM_LEASE_MS, WORKSPACE_MERGE_LEASE_MS } from "../config";
+import { matchAgents } from "../agent-ref";
+import { getAgent } from "./agents.ts";
+import { deleteArtifactLinksForEntity } from "./artifacts.ts";
+import { getDb, timedQuery } from "./connection.ts";
+import { legacyChannelTargets } from "./delivery.ts";
+import { MSG_SELECT, rowToMessage } from "./mappers.ts";
+import type {
+  AgentCard,
+  ActivityEvent,
+  ActivityEventInput,
+  AgentKind,
+  AgentSessionGuard,
+  Artifact,
+  ArtifactBlob,
+  ArtifactKind,
+  ArtifactLink,
+  ArtifactSensitivity,
+  ArtifactVisibility,
+  AttachmentRef,
+  ChannelBinding,
+  ChannelBindingMode,
+  ChannelRouteTarget,
+  ChatHistoryImport,
+  ChatHistoryImportEntry,
+  ChannelSummary,
+  ChannelTargetHealth,
+  CreatePairInput,
+  HealthCheck,
+  HealthReport,
+  ManagedAgent,
+  ManagedSessionExitDiagnostics,
+  Message,
+  MessageDeliveryAttempt,
+  MessageDeliveryStatus,
+  Orchestrator,
+  OrchestratorHealth,
+  OrchestratorRuntimeInput,
+  OrchestratorStatus,
+  OrchestratorUpgradeState,
+  PairActionInput,
+  PairMessageInput,
+  PairSession,
+  PairStatus,
+  RegisterAgentInput,
+  ReplyObligation,
+  RegisterOrchestratorInput,
+  SendMessageInput,
+  PollQuery,
+  SpawnApprovalMode,
+  SpawnProvider,
+  Task,
+  TaskEvent,
+  TaskSeverity,
+  TaskStatus,
+  IntegrationEventInput,
+  IntegrationSummary,
+  IntegrationTaskStats,
+  InboxDraft,
+  InboxState,
+  InboxThreadState,
+  ContextSnapshot,
+  ContextState,
+  ProviderCapabilities,
+  TaskStatusInput,
+  WorkspaceMetadata,
+  WorkspaceRecord,
+  WorkspaceStatus,
+} from "../types";
+
+export function listRecentMessages(limit: number = 100, since?: number, channel?: string): Message[] {
+  const conditions: string[] = [];
+  const params: any[] = [];
+
+  if (since !== undefined) {
+    conditions.push("created_at > ?");
+    params.push(since);
+  }
+  if (channel) {
+    conditions.push("channel = ?");
+    params.push(channel);
+  }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const sql = `${MSG_SELECT} ${where} ORDER BY m.created_at DESC LIMIT ?`;
+  params.push(limit);
+
+  const rows = timedQuery("listMessages", () => getDb().query(sql).all(...params) as any[]);
+  return rows.map(rowToMessage).reverse();
+}
+
+export function pollMessages(query: PollQuery): Message[] {
+  const agent = getAgent(query.for);
+  const agentTags = agent?.tags ?? [];
+  const agentCaps = agent?.capabilities ?? [];
+  const agentLabel = agent?.label;
+  const agentLegacyChannelTargets = legacyChannelTargets(agent);
+
+  const conditions: string[] = [];
+  const params: any[] = [];
+
+  // Build target matching: direct + broadcast + tag + capability + label.
+  // Channel agents also accept legacy bare provider targets (for example
+  // "telegram") so older clients keep working after canonical IDs became
+  // provider:account ("telegram:default").
+  const targetClauses = ["to_target = ?", "resolved_to_agent = ?", "to_target = 'broadcast'"];
+  params.push(query.for, query.for);
+
+  for (const tag of agentTags) {
+    targetClauses.push("to_target = ?");
+    params.push(`tag:${tag}`);
+  }
+  for (const cap of agentCaps) {
+    targetClauses.push("to_target = ?");
+    params.push(`cap:${cap}`);
+  }
+  if (agentLabel) {
+    targetClauses.push("to_target = ?");
+    params.push(`label:${agentLabel}`);
+  }
+  for (const target of agentLegacyChannelTargets) {
+    targetClauses.push("to_target = ?");
+    params.push(target);
+  }
+  conditions.push(`(${targetClauses.join(" OR ")})`);
+  conditions.push("delivery_status != 'queued' AND delivery_status NOT IN ('failed', 'dead')");
+
+  // Hide active claims held by someone else, but let expired claims surface so
+  // another matching agent can recover stuck work.
+  conditions.push(`(claimable = 0 OR claimed_by IS NULL OR claimed_by = ? OR ((claim_expires_at IS NULL OR claim_expires_at <= ?) AND NOT EXISTS (SELECT 1 FROM tasks t WHERE t.message_id = m.id AND t.status IN ('done', 'failed', 'canceled'))))`);
+  params.push(query.for, Date.now());
+
+  if (query.sinceId !== undefined) {
+    conditions.push("id > ?");
+    params.push(query.sinceId);
+  } else if (query.since !== undefined) {
+    conditions.push("created_at > ?");
+    params.push(query.since);
+  }
+
+  if (query.unread) {
+    conditions.push(
+      "NOT EXISTS (SELECT 1 FROM message_reads WHERE message_id = m.id AND agent_id = ?)"
+    );
+    params.push(query.for);
+  }
+
+  if (query.channel) {
+    conditions.push("channel = ?");
+    params.push(query.channel);
+  }
+
+  const limit = query.limit ?? 50;
+  const sql = `${MSG_SELECT} WHERE ${conditions.join(" AND ")} ORDER BY m.created_at ASC LIMIT ?`;
+  params.push(limit);
+
+  const rows = timedQuery("pollMessages", () => getDb().query(sql).all(...params) as any[]);
+  return rows.map(rowToMessage);
+}
+
+export function messageRequiresReply(message: Message): boolean {
+  // Server-owned notification flag (#283) wins over every kind/sender heuristic below: an
+  // explicit replyExpected:false is a fire-and-forget message that must never become an obligation.
+  if (message.replyExpected === false) return false;
+  if (isMechanicalMessageKind(message.kind)) return false;
+  if (message.from === "user") return true;
+  if (message.kind === "task" || message.kind === "channel.event") return true;
+  return Boolean(message.payload?.source);
+}
+
+export function stringField(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+export function recordField(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+export function relayConversationId(message: Message): string | undefined {
+  const conversation = recordField(message.payload?.conversation);
+  const replyContext = recordField(message.payload?.replyContext);
+  return stringField(replyContext?.conversationId) ?? stringField(conversation?.id);
+}
+
+export function isCoveredByLaterAgentResponse(message: Message, agentId: string): boolean {
+  // Order by id, not created_at: ids are monotonic insertion order, so this is
+  // robust when a reply lands in the same millisecond as the message it covers
+  // (created_at > … strictly would miss it, leaving the message wrongly pending).
+  const replies = (getDb().query(`
+    ${MSG_SELECT}
+    WHERE m.from_agent = ?
+      AND m.id > ?
+    ORDER BY m.id ASC
+    LIMIT 200
+  `).all(agentId, message.id) as any[]).map(rowToMessage);
+
+  const conversationId = relayConversationId(message);
+  return replies.some((reply) => {
+    if (reply.replyTo === message.id) return true;
+    if (message.threadId !== undefined && reply.threadId === message.threadId) return true;
+    if (!message.channel || reply.channel !== message.channel || !conversationId) return false;
+    return relayConversationId(reply) === conversationId;
+  });
+}
+
+export function replyObligationFromMessage(message: Message, agentId: string): ReplyObligation {
+  return {
+    messageId: message.id,
+    agentId,
+    from: message.from,
+    kind: message.kind,
+    ...(message.subject ? { subject: message.subject } : {}),
+    ...(message.channel ? { channel: message.channel } : {}),
+    bodyPreview: message.body.length > 240 ? `${message.body.slice(0, 240)}\n[truncated]` : message.body,
+    createdAt: message.createdAt,
+    replyCommand: `agent-relay /reply ${message.id} --stdin < .agent-relay/sessions/${agentId}/tmp/reply.md`,
+  };
+}
+
+export function listPendingReplyObligations(agentId: string, limit = 20): ReplyObligation[] {
+  const scanLimit = Math.max(limit * 5, 50);
+  const rows = timedQuery("listPendingReplyObligations", () => getDb().query(`
+    ${MSG_SELECT}
+    WHERE EXISTS (
+      SELECT 1 FROM message_reads mr
+      WHERE mr.message_id = m.id AND mr.agent_id = ?
+    )
+      AND m.from_agent != ?
+      AND NOT EXISTS (
+        SELECT 1 FROM messages reply
+        WHERE reply.reply_to = m.id
+          AND reply.from_agent = ?
+      )
+    ORDER BY m.created_at ASC
+    LIMIT ?
+  `).all(agentId, agentId, agentId, scanLimit) as any[]);
+  return rows
+    .map(rowToMessage)
+    .filter(messageRequiresReply)
+    .filter((message) => !isCoveredByLaterAgentResponse(message, agentId))
+    .slice(0, limit)
+    .map((message) => replyObligationFromMessage(message, agentId));
+}
+
+export function markRead(messageId: number, agentId: string): boolean {
+  const exists = getDb().query("SELECT 1 FROM messages WHERE id = ?").get(messageId);
+  if (!exists) return false;
+  getDb().query(
+    "INSERT OR IGNORE INTO message_reads (message_id, agent_id, read_at) VALUES (?, ?, ?)"
+  ).run(messageId, agentId, Date.now());
+  getDb().query(`
+    UPDATE messages
+    SET delivery_status = 'delivered',
+        delivery_last_error = NULL,
+        delivery_next_retry_at = NULL,
+        delivery_poison_reason = NULL,
+        delivery_updated_at = ?
+    WHERE id = ? AND (to_target = ? OR resolved_to_agent = ? OR to_target = 'broadcast' OR to_target LIKE 'tag:%' OR to_target LIKE 'cap:%' OR to_target LIKE 'label:%')
+  `).run(Date.now(), messageId, agentId, agentId);
+  return true;
+}
+
+
+export function deleteMessage(id: number): boolean {
+  return getDb().transaction(() => {
+    // Break reply_to references from children so the FK doesn't block delete.
+    // Children keep their thread_id — the thread shows up minus this message.
+    getDb().query("UPDATE messages SET reply_to = NULL WHERE reply_to = ?").run(id);
+    deleteArtifactLinksForEntity("message", id);
+    return getDb().query("DELETE FROM messages WHERE id = ?").run(id).changes > 0;
+  })();
+}
+
+export function getLatestMessageId(): number {
+  const row = getDb().query("SELECT MAX(id) as id FROM messages").get() as any;
+  return row?.id ?? 0;
+}
+
+export function pruneOldMessages(maxAgeMs: number): number {
+  const cutoff = Date.now() - maxAgeMs;
+  return getDb().transaction(() => {
+    getDb()
+      .query("UPDATE messages SET reply_to = NULL WHERE reply_to IN (SELECT id FROM messages WHERE created_at < ?)")
+      .run(cutoff);
+    return getDb()
+      .query("DELETE FROM messages WHERE created_at < ?")
+      .run(cutoff).changes;
+  })();
+}
+