agent-relay-server 0.33.0 → 0.34.0

package/src/db/tasks.ts

@@ -0,0 +1,407 @@
+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, settleSingleTargetOnDemandTasks, validateAgentSession } from "./agents.ts";
+import { ClaimError, getDb } from "./connection.ts";
+import { rowToTask, rowToTaskEvent } from "./mappers.ts";
+import { claimMessageRow } from "./messages.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 const TASK_SELECT = "SELECT * FROM tasks";
+
+export function findOpenTaskByDedupe(source: string, dedupeKey: string): Task | null {
+  const row = getDb()
+    .query(`${TASK_SELECT} WHERE source = ? AND dedupe_key = ? AND status NOT IN ('done', 'failed', 'canceled') ORDER BY id DESC LIMIT 1`)
+    .get(source, dedupeKey) as any;
+  return row ? rowToTask(row) : null;
+}
+
+export function insertTaskEvent(taskId: number, event: Required<Omit<TaskEvent, "id" | "taskId" | "createdAt">>, now: number): TaskEvent {
+  const result = getDb().query(`
+    INSERT INTO task_events (task_id, source, type, severity, title, body, metadata, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(taskId, event.source, event.type, event.severity, event.title, event.body, JSON.stringify(event.metadata), now);
+  return getTaskEvent(Number(result.lastInsertRowid))!;
+}
+
+export function getTaskEvent(id: number): TaskEvent | null {
+  const row = getDb().query("SELECT * FROM task_events WHERE id = ?").get(id) as any;
+  return row ? rowToTaskEvent(row) : null;
+}
+
+export function taskMessageBody(task: Pick<Task, "id" | "source" | "severity" | "body" | "externalUrl" | "dedupeKey">): string {
+  const lines = [
+    `[task:${task.id}] ${task.severity.toUpperCase()} from ${task.source}`,
+    "",
+    task.body,
+  ];
+  if (task.externalUrl) lines.push("", `External: ${task.externalUrl}`);
+  if (task.dedupeKey) lines.push(`Dedupe: ${task.dedupeKey}`);
+  lines.push("", "Claim this task before working it, then update task status when finished.");
+  return lines.join("\n");
+}
+
+
+export function getTask(id: number): Task | null {
+  const row = getDb().query(`${TASK_SELECT} WHERE id = ?`).get(id) as any;
+  return row ? rowToTask(row) : null;
+}
+
+export function listTasks(filter?: { status?: string; source?: string; target?: string; limit?: number }): Task[] {
+  const conditions: string[] = [];
+  const params: any[] = [];
+  if (filter?.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  if (filter?.source) {
+    conditions.push("source = ?");
+    params.push(filter.source);
+  }
+  if (filter?.target) {
+    conditions.push("target = ?");
+    params.push(filter.target);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(filter?.limit ?? 100);
+  return (getDb().query(`${TASK_SELECT} ${where} ORDER BY updated_at DESC LIMIT ?`).all(...params) as any[]).map(rowToTask);
+}
+
+
+export function listTaskEvents(taskId: number): TaskEvent[] {
+  return (getDb().query("SELECT * FROM task_events WHERE task_id = ? ORDER BY id ASC").all(taskId) as any[]).map(rowToTaskEvent);
+}
+
+export function recordTaskEvent(taskId: number, input: {
+  source: string;
+  type: string;
+  severity?: TaskSeverity;
+  title: string;
+  body?: string;
+  metadata?: Record<string, unknown>;
+}, now: number = Date.now()): TaskEvent | null {
+  const task = getTask(taskId);
+  if (!task) return null;
+  return insertTaskEvent(taskId, {
+    source: input.source,
+    type: input.type,
+    severity: input.severity ?? task.severity,
+    title: input.title,
+    body: input.body ?? "",
+    metadata: input.metadata ?? {},
+  }, now);
+}
+
+export function releaseExpiredClaims(now: number = Date.now()): { messageIds: number[]; tasks: Task[] } {
+  return getDb().transaction(() => {
+    settleSingleTargetOnDemandTasks("claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?)", [now], now, "claim-lease-expired");
+    const releasableMessageClaim = "claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?) AND NOT EXISTS (SELECT 1 FROM tasks t WHERE t.message_id = messages.id AND t.status IN ('done', 'failed', 'canceled'))";
+    const messageRows = getDb()
+      .query(`SELECT id FROM messages WHERE ${releasableMessageClaim}`)
+      .all(now) as any[];
+    const taskRows = getDb()
+      .query(`${TASK_SELECT} WHERE claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?) AND status IN ('claimed', 'in_progress', 'blocked')`)
+      .all(now) as any[];
+
+    if (messageRows.length > 0) {
+      getDb()
+        .query(`UPDATE messages SET claimed_by = NULL, claimed_at = NULL, claim_expires_at = NULL WHERE ${releasableMessageClaim}`)
+        .run(now);
+    }
+
+    if (taskRows.length > 0) {
+      getDb()
+        .query("UPDATE tasks SET status = 'open', claimed_by = NULL, claimed_at = NULL, claim_expires_at = NULL, updated_at = ? WHERE claimed_by IS NOT NULL AND (claim_expires_at IS NULL OR claim_expires_at <= ?) AND status IN ('claimed', 'in_progress', 'blocked')")
+        .run(now, now);
+
+      for (const row of taskRows) {
+        insertTaskEvent(row.id, {
+          source: "agent-relay",
+          type: "claim.expired",
+          severity: row.severity,
+          title: "Task claim expired",
+          body: `Claim by ${row.claimed_by} expired and was released`,
+          metadata: { agentId: row.claimed_by },
+        }, now);
+      }
+    }
+
+    return {
+      messageIds: messageRows.map((row: any) => row.id),
+      tasks: taskRows.map((row: any) => getTask(row.id)!),
+    };
+  })();
+}
+
+export function orphanTasksForAgent(agentId: string, now: number = Date.now()): Task[] {
+  return getDb().transaction(() => {
+    const rows = getDb()
+      .query(`${TASK_SELECT} WHERE claimed_by = ? AND status IN ('claimed', 'in_progress')`)
+      .all(agentId) as any[];
+    if (rows.length === 0) return [];
+
+    getDb().query(`
+      UPDATE tasks
+      SET status = 'orphaned', updated_at = ?, last_seen_at = ?
+      WHERE claimed_by = ? AND status IN ('claimed', 'in_progress')
+    `).run(now, now, agentId);
+
+    for (const row of rows) {
+      insertTaskEvent(row.id, {
+        source: "agent-relay",
+        type: "task.orphaned",
+        severity: row.severity,
+        title: "Task orphaned",
+        body: `Claimed agent ${agentId} went offline`,
+        metadata: { agentId },
+      }, now);
+    }
+
+    return rows.map((row: any) => getTask(row.id)!);
+  })();
+}
+
+export function releaseOrphanedTasks(graceMs = 120_000, now: number = Date.now()): Task[] {
+  return getDb().transaction(() => {
+    const cutoff = now - graceMs;
+    settleSingleTargetOnDemandTasks("status = 'orphaned' AND claimed_by IS NOT NULL AND updated_at <= ?", [cutoff], now, "orphan-grace-elapsed");
+    const rows = getDb()
+      .query(`${TASK_SELECT} WHERE status = 'orphaned' AND claimed_by IS NOT NULL AND updated_at <= ?`)
+      .all(cutoff) as any[];
+    if (rows.length === 0) return [];
+
+    getDb().query(`
+      UPDATE tasks
+      SET status = 'open', claimed_by = NULL, claimed_at = NULL, claim_expires_at = NULL, updated_at = ?
+      WHERE status = 'orphaned' AND claimed_by IS NOT NULL AND updated_at <= ?
+    `).run(now, cutoff);
+
+    for (const row of rows) {
+      insertTaskEvent(row.id, {
+        source: "agent-relay",
+        type: "orphan.released",
+        severity: row.severity,
+        title: "Orphaned task released",
+        body: "Task is available for claim again",
+        metadata: { previousAgentId: row.claimed_by },
+      }, now);
+    }
+
+    return rows.map((row: any) => getTask(row.id)!);
+  })();
+}
+
+export function claimTask(taskId: number, agentId: string, guard?: AgentSessionGuard): { ok: boolean; error?: string; task?: Task } {
+  releaseExpiredClaims();
+  const session = validateAgentSession(agentId, guard);
+  if (!session.ok) return { ok: false, error: session.error };
+  const agent = getAgent(agentId);
+  if (!agent) return { ok: false, error: "claiming agent not found" };
+  if (agent.status === "offline") return { ok: false, error: "claiming agent is offline" };
+  const task = getTask(taskId);
+  if (!task) return { ok: false, error: "task not found" };
+  if (!["open", "blocked"].includes(task.status)) return { ok: false, error: `task is ${task.status}` };
+
+  try {
+    return getDb().transaction(() => {
+      const now = Date.now();
+      const expiresAt = now + CLAIM_LEASE_MS;
+      const result = getDb().query(`
+        UPDATE tasks SET status = 'claimed', claimed_by = ?, claimed_at = ?, claim_expires_at = ?, updated_at = ?
+        WHERE id = ? AND status IN ('open', 'blocked')
+      `).run(agentId, now, expiresAt, now, taskId);
+      if (result.changes === 0) return { ok: false, error: "claim race — already claimed" };
+      if (task.messageId) {
+        const messageClaim = claimMessageRow(task.messageId, agentId, now);
+        if (!messageClaim.ok) throw new ClaimError(messageClaim.error);
+      }
+      insertTaskEvent(taskId, {
+        source: "agent-relay",
+        type: "claimed",
+        severity: task.severity,
+        title: `Task claimed by ${agentId}`,
+        body: `Task claimed by ${agentId}`,
+        metadata: { agentId },
+      }, now);
+      return { ok: true, task: getTask(taskId)! };
+    })();
+  } catch (e) {
+    if (e instanceof ClaimError) return { ok: false, error: e.message };
+    throw e;
+  }
+}
+
+export function renewTaskClaim(taskId: number, agentId: string, guard?: AgentSessionGuard): { ok: boolean; error?: string; task?: Task } {
+  releaseExpiredClaims();
+  const session = validateAgentSession(agentId, guard);
+  if (!session.ok) return { ok: false, error: session.error };
+  const agent = getAgent(agentId);
+  if (!agent) return { ok: false, error: "claiming agent not found" };
+  if (agent.status === "offline") return { ok: false, error: "claiming agent is offline" };
+  const task = getTask(taskId);
+  if (!task) return { ok: false, error: "task not found" };
+  if (task.claimedBy !== agentId) return { ok: false, error: task.claimedBy ? `claimed by ${task.claimedBy}` : "task is not claimed" };
+  if (!["claimed", "in_progress", "blocked"].includes(task.status)) return { ok: false, error: `task is ${task.status}` };
+
+  const now = Date.now();
+  const expiresAt = now + CLAIM_LEASE_MS;
+  getDb().query("UPDATE tasks SET claim_expires_at = ?, updated_at = ? WHERE id = ? AND claimed_by = ?").run(expiresAt, now, taskId, agentId);
+  if (task.messageId) {
+    getDb().query("UPDATE messages SET claim_expires_at = ? WHERE id = ? AND claimed_by = ?").run(expiresAt, task.messageId, agentId);
+  }
+  return { ok: true, task: getTask(taskId)! };
+}
+
+export function updateTaskStatus(taskId: number, input: TaskStatusInput): { ok: boolean; error?: string; task?: Task; event?: TaskEvent } {
+  const task = getTask(taskId);
+  if (!task) return { ok: false, error: "task not found" };
+  const now = Date.now();
+  const agentId = input.agentId ?? task.claimedBy ?? null;
+  if (agentId) {
+    const session = validateAgentSession(agentId, input);
+    if (!session.ok) return { ok: false, error: session.error };
+  }
+  const result = getDb().query(`
+    UPDATE tasks
+    SET status = ?, result = COALESCE(?, result), claimed_by = COALESCE(?, claimed_by),
+        claimed_at = CASE WHEN claimed_by IS NULL AND ? IS NOT NULL THEN ? ELSE claimed_at END,
+        claim_expires_at = CASE WHEN ? IN ('done', 'failed', 'canceled') THEN NULL ELSE claim_expires_at END,
+        updated_at = ?, last_seen_at = ?
+    WHERE id = ?
+  `).run(input.status, input.result ?? null, agentId, agentId, now, input.status, now, now, taskId);
+  if (result.changes === 0) return { ok: false, error: "task not found" };
+  if (["done", "failed", "canceled"].includes(input.status) && task.messageId) {
+    getDb().query("UPDATE messages SET claim_expires_at = NULL WHERE id = ?").run(task.messageId);
+  }
+  if (agentId && ["claimed", "in_progress", "blocked"].includes(input.status)) {
+    const expiresAt = now + CLAIM_LEASE_MS;
+    getDb().query("UPDATE tasks SET claim_expires_at = ? WHERE id = ? AND claimed_by = ?").run(expiresAt, taskId, agentId);
+    if (task.messageId) {
+      getDb().query("UPDATE messages SET claim_expires_at = ? WHERE id = ? AND claimed_by = ?").run(expiresAt, task.messageId, agentId);
+    }
+  }
+  const event = insertTaskEvent(taskId, {
+    source: input.agentId ?? "agent-relay",
+    type: `status:${input.status}`,
+    severity: task.severity,
+    title: `Task ${input.status}`,
+    body: input.body ?? input.result ?? `Task marked ${input.status}`,
+    metadata: input.metadata ?? {},
+  }, now);
+  return { ok: true, task: getTask(taskId)!, event };
+}
+
+export function createCallbackDelivery(taskId: number, url: string, eventType: string, payload: unknown): number {
+  const now = Date.now();
+  const result = getDb().query(`
+    INSERT INTO task_callback_deliveries (task_id, url, event_type, payload, status, attempts, created_at, updated_at)
+    VALUES (?, ?, ?, ?, 'pending', 0, ?, ?)
+  `).run(taskId, url, eventType, JSON.stringify(payload), now, now);
+  return Number(result.lastInsertRowid);
+}
+
+export function finishCallbackDelivery(id: number, ok: boolean, error?: string): void {
+  getDb().query(`
+    UPDATE task_callback_deliveries
+    SET status = ?, attempts = attempts + 1, last_error = ?, updated_at = ?
+    WHERE id = ?
+  `).run(ok ? "delivered" : "failed", error ?? null, Date.now(), id);
+}
+
+export function listCallbackDeliveries(taskId: number): Array<{
+  id: number;
+  taskId: number;
+  url: string;
+  eventType: string;
+  status: string;
+  attempts: number;
+  lastError?: string;
+}> {
+  return (getDb().query("SELECT * FROM task_callback_deliveries WHERE task_id = ? ORDER BY id ASC").all(taskId) as any[])
+    .map((row) => ({
+      id: row.id,
+      taskId: row.task_id,
+      url: row.url,
+      eventType: row.event_type,
+      status: row.status,
+      attempts: row.attempts,
+      lastError: row.last_error ?? undefined,
+    }));
+}
+
+// --- Pair sessions ---
+