agent-relay-server 0.33.0 → 0.34.0

package/src/db/artifacts.ts

@@ -0,0 +1,342 @@
+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 { ValidationError, getDb } from "./connection.ts";
+import { rowToArtifact, rowToArtifactBlob, rowToArtifactLink } 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";
+
+// --- Artifacts ---
+
+export const VALID_ARTIFACT_KINDS = new Set<ArtifactKind>(["image", "audio", "video", "document", "archive", "other"]);
+export const VALID_ARTIFACT_VISIBILITIES = new Set<ArtifactVisibility>(["private", "project", "org"]);
+export const VALID_ARTIFACT_SENSITIVITIES = new Set<ArtifactSensitivity>(["public", "normal", "sensitive", "secret"]);
+export const VALID_ARTIFACT_LINK_ENTITY_TYPES = new Set<ArtifactLink["entityType"]>(["message", "task", "recipeRun", "recipeStep", "channelEvent"]);
+export const VALID_ARTIFACT_ROLES = new Set<NonNullable<ArtifactLink["role"]>>(["media", "patch", "report", "log", "output", "input"]);
+
+export function artifactId(): string {
+  return `art_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+
+export function artifactLinkId(): string {
+  return `alink_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+
+export function normalizeArtifactKind(kind: unknown): ArtifactKind {
+  return typeof kind === "string" && VALID_ARTIFACT_KINDS.has(kind as ArtifactKind) ? kind as ArtifactKind : "other";
+}
+
+export function normalizeArtifactVisibility(visibility: unknown): ArtifactVisibility {
+  return typeof visibility === "string" && VALID_ARTIFACT_VISIBILITIES.has(visibility as ArtifactVisibility) ? visibility as ArtifactVisibility : "project";
+}
+
+export function normalizeArtifactSensitivity(sensitivity: unknown): ArtifactSensitivity {
+  return typeof sensitivity === "string" && VALID_ARTIFACT_SENSITIVITIES.has(sensitivity as ArtifactSensitivity) ? sensitivity as ArtifactSensitivity : "normal";
+}
+
+export function upsertArtifactBlob(input: {
+  digest: string;
+  storageUri: string;
+  mediaType: string;
+  size: number;
+  createdAt?: number;
+}): ArtifactBlob {
+  const now = input.createdAt ?? Date.now();
+  getDb().query(`
+    INSERT INTO artifact_blobs (digest, storage_uri, media_type, size, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(digest) DO UPDATE SET
+      storage_uri = excluded.storage_uri,
+      media_type = excluded.media_type,
+      size = excluded.size
+  `).run(input.digest, input.storageUri, input.mediaType, input.size, now);
+  return getArtifactBlob(input.digest)!;
+}
+
+export function getArtifactBlob(digest: string): ArtifactBlob | null {
+  const row = getDb().query("SELECT * FROM artifact_blobs WHERE digest = ?").get(digest) as any;
+  return row ? rowToArtifactBlob(row) : null;
+}
+
+export function deleteArtifactBlob(digest: string): boolean {
+  return getDb().query("DELETE FROM artifact_blobs WHERE digest = ?").run(digest).changes > 0;
+}
+
+export function createArtifact(input: {
+  blobDigest: string;
+  mediaType: string;
+  kind?: ArtifactKind;
+  filename?: string;
+  size: number;
+  visibility?: ArtifactVisibility;
+  sensitivity?: ArtifactSensitivity;
+  createdBy: string;
+  expiresAt?: number;
+  metadata?: Record<string, unknown>;
+  id?: string;
+}): Artifact {
+  if (!getArtifactBlob(input.blobDigest)) throw new ValidationError("artifact blob not found");
+  const id = input.id ?? artifactId();
+  const now = Date.now();
+  getDb().query(`
+    INSERT INTO artifacts (
+      id, blob_digest, media_type, kind, filename, size, visibility, sensitivity,
+      created_by, created_at, expires_at, metadata
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    input.blobDigest,
+    input.mediaType,
+    normalizeArtifactKind(input.kind),
+    input.filename ?? null,
+    input.size,
+    normalizeArtifactVisibility(input.visibility),
+    normalizeArtifactSensitivity(input.sensitivity),
+    input.createdBy,
+    now,
+    input.expiresAt ?? null,
+    JSON.stringify(input.metadata ?? {}),
+  );
+  return getArtifact(id)!;
+}
+
+export function getArtifact(id: string): Artifact | null {
+  const row = getDb().query("SELECT * FROM artifacts WHERE id = ?").get(id) as any;
+  if (!row) return null;
+  return rowToArtifact(row, listArtifactLinks(id));
+}
+
+export function listArtifacts(query: {
+  messageId?: number;
+  taskId?: number;
+  createdBy?: string;
+  limit?: number;
+} = {}): Artifact[] {
+  const conditions: string[] = [];
+  const params: any[] = [];
+  if (query.createdBy) {
+    conditions.push("a.created_by = ?");
+    params.push(query.createdBy);
+  }
+  if (query.messageId !== undefined) {
+    conditions.push("EXISTS (SELECT 1 FROM artifact_links l WHERE l.artifact_id = a.id AND l.entity_type = 'message' AND l.entity_id = ?)");
+    params.push(String(query.messageId));
+  }
+  if (query.taskId !== undefined) {
+    conditions.push("EXISTS (SELECT 1 FROM artifact_links l WHERE l.artifact_id = a.id AND l.entity_type = 'task' AND l.entity_id = ?)");
+    params.push(String(query.taskId));
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = Math.min(Math.max(query.limit ?? 100, 1), 500);
+  const rows = getDb().query(`SELECT a.* FROM artifacts a ${where} ORDER BY a.created_at DESC LIMIT ?`).all(...params, limit) as any[];
+  return rows.map((row) => rowToArtifact(row, listArtifactLinks(row.id)));
+}
+
+export function deleteArtifact(id: string): boolean {
+  return getDb().transaction(() => {
+    return getDb().query("DELETE FROM artifacts WHERE id = ?").run(id).changes > 0;
+  })();
+}
+
+export function listArtifactLinks(artifactId: string): ArtifactLink[] {
+  return (getDb().query("SELECT * FROM artifact_links WHERE artifact_id = ? ORDER BY created_at ASC").all(artifactId) as any[]).map(rowToArtifactLink);
+}
+
+export function listArtifactsForEntity(entityType: ArtifactLink["entityType"], entityId: string | number): Artifact[] {
+  const rows = getDb().query(`
+    SELECT a.*
+    FROM artifacts a
+    JOIN artifact_links l ON l.artifact_id = a.id
+    WHERE l.entity_type = ? AND l.entity_id = ?
+    ORDER BY l.created_at ASC
+  `).all(entityType, String(entityId)) as any[];
+  return rows.map((row) => rowToArtifact(row, listArtifactLinks(row.id)));
+}
+
+export function linkArtifact(input: {
+  artifactId: string;
+  entityType: ArtifactLink["entityType"];
+  entityId: string | number;
+  role?: ArtifactLink["role"];
+  title?: string;
+  createdBy: string;
+}): ArtifactLink {
+  if (!VALID_ARTIFACT_LINK_ENTITY_TYPES.has(input.entityType)) throw new ValidationError("invalid artifact link entity type");
+  if (input.role && !VALID_ARTIFACT_ROLES.has(input.role)) throw new ValidationError("invalid artifact role");
+  if (!getArtifact(input.artifactId)) throw new ValidationError(`artifact ${input.artifactId} not found`);
+  const now = Date.now();
+  const id = artifactLinkId();
+  getDb().query(`
+    INSERT OR IGNORE INTO artifact_links (id, artifact_id, entity_type, entity_id, role, title, created_by, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    input.artifactId,
+    input.entityType,
+    String(input.entityId),
+    input.role ?? null,
+    input.title ?? null,
+    input.createdBy,
+    now,
+  );
+  const row = getDb().query(`
+    SELECT * FROM artifact_links
+    WHERE artifact_id = ? AND entity_type = ? AND entity_id = ? AND ((role IS NULL AND ? IS NULL) OR role = ?)
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(input.artifactId, input.entityType, String(input.entityId), input.role ?? null, input.role ?? null) as any;
+  return rowToArtifactLink(row);
+}
+
+export function deleteArtifactLinksForEntity(entityType: ArtifactLink["entityType"], entityId: string | number): number {
+  return getDb().query("DELETE FROM artifact_links WHERE entity_type = ? AND entity_id = ?").run(entityType, String(entityId)).changes;
+}
+
+export function artifactBlobReferenceCount(digest: string): number {
+  const row = getDb().query("SELECT COUNT(*) AS count FROM artifacts WHERE blob_digest = ?").get(digest) as { count?: number };
+  return row.count ?? 0;
+}
+
+export function unreferencedArtifactBlobs(): ArtifactBlob[] {
+  return (getDb().query(`
+    SELECT b.*
+    FROM artifact_blobs b
+    WHERE NOT EXISTS (SELECT 1 FROM artifacts a WHERE a.blob_digest = b.digest)
+  `).all() as any[]).map(rowToArtifactBlob);
+}
+
+export function sweepArtifacts(input: { now?: number; unlinkedGraceMs?: number } = {}): { artifactIds: string[]; blobs: ArtifactBlob[] } {
+  const now = input.now ?? Date.now();
+  const unlinkedCutoff = now - (input.unlinkedGraceMs ?? 60 * 60 * 1000);
+  return getDb().transaction(() => {
+    const rows = getDb().query(`
+      SELECT id FROM artifacts a
+      WHERE (expires_at IS NOT NULL AND expires_at <= ?)
+         OR (created_at <= ? AND NOT EXISTS (SELECT 1 FROM artifact_links l WHERE l.artifact_id = a.id))
+    `).all(now, unlinkedCutoff) as Array<{ id: string }>;
+    for (const row of rows) getDb().query("DELETE FROM artifacts WHERE id = ?").run(row.id);
+    const blobs = unreferencedArtifactBlobs();
+    for (const blob of blobs) deleteArtifactBlob(blob.digest);
+    return { artifactIds: rows.map((row) => row.id), blobs };
+  })();
+}
+
+export function cleanAttachmentRefs(payload: Record<string, unknown> | undefined): AttachmentRef[] {
+  const raw = payload?.attachments;
+  if (!Array.isArray(raw)) return [];
+  const refs: AttachmentRef[] = [];
+  for (const [index, item] of raw.entries()) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new ValidationError(`payload.attachments[${index}] must be an object`);
+    }
+    const record = item as Record<string, unknown>;
+    const artifactId = typeof record.artifactId === "string" ? record.artifactId.trim() : "";
+    if (!artifactId) continue;
+    const role = typeof record.role === "string" && VALID_ARTIFACT_ROLES.has(record.role as NonNullable<ArtifactLink["role"]>)
+      ? record.role as NonNullable<ArtifactLink["role"]>
+      : undefined;
+    refs.push({
+      artifactId,
+      kind: normalizeArtifactKind(record.kind),
+      role,
+      title: typeof record.title === "string" ? record.title.slice(0, 240) : undefined,
+    });
+  }
+  return refs;
+}
+
+export function validateAttachmentRefs(refs: AttachmentRef[]): void {
+  for (const ref of refs) {
+    if (!getArtifact(ref.artifactId)) throw new ValidationError(`artifact ${ref.artifactId} not found`);
+  }
+}
+
+export function linkAttachmentRefs(entityType: ArtifactLink["entityType"], entityId: string | number, refs: AttachmentRef[], createdBy: string): void {
+  for (const ref of refs) {
+    linkArtifact({
+      artifactId: ref.artifactId,
+      entityType,
+      entityId,
+      role: ref.role,
+      title: ref.title,
+      createdBy,
+    });
+  }
+}
+
+// --- Messages ---
+