agent-relay-server 0.10.7 → 0.10.8

package/src/db.ts

@@ -83,6 +83,11 @@ export function initDb(path: string = "agent-relay.db"): Database {
       claimed_at INTEGER,
       claim_expires_at INTEGER,
       idempotency_key TEXT,
+      delivery_status TEXT NOT NULL DEFAULT 'pending',
+      delivery_attempts INTEGER NOT NULL DEFAULT 0,
+      queued_at INTEGER,
+      max_age_seconds INTEGER,
+      resolved_to_agent TEXT,
       payload TEXT NOT NULL DEFAULT '{}',
       meta TEXT NOT NULL DEFAULT '{}',
       read_by TEXT NOT NULL DEFAULT '[]',
@@ -93,6 +98,48 @@ export function initDb(path: string = "agent-relay.db"): Database {
     CREATE INDEX IF NOT EXISTS idx_msg_created ON messages(created_at);
     CREATE INDEX IF NOT EXISTS idx_msg_channel ON messages(channel);
 
+    CREATE TABLE IF NOT EXISTS config (
+      namespace TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      version INTEGER NOT NULL DEFAULT 1,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_by TEXT,
+      PRIMARY KEY (namespace, key)
+    );
+
+    CREATE TABLE IF NOT EXISTS config_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      namespace TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      changed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      changed_by TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_config_history_key ON config_history(namespace, key, version);
+
+    CREATE TABLE IF NOT EXISTS managed_agent_state (
+      policy_name TEXT PRIMARY KEY,
+      status TEXT NOT NULL,
+      agent_id TEXT,
+      orchestrator_id TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      tmux_session TEXT,
+      spawn_request_id TEXT,
+      last_spawn_at INTEGER,
+      last_stop_at INTEGER,
+      healthy_since INTEGER,
+      restart_count INTEGER NOT NULL DEFAULT 0,
+      consecutive_failures INTEGER NOT NULL DEFAULT 0,
+      backoff_until INTEGER,
+      last_error TEXT,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_managed_agent_state_status ON managed_agent_state(status);
+    CREATE INDEX IF NOT EXISTS idx_managed_agent_state_agent ON managed_agent_state(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_managed_agent_state_spawn_request ON managed_agent_state(policy_name, spawn_request_id);
+
     CREATE TABLE IF NOT EXISTS tasks (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       source TEXT NOT NULL,
@@ -380,11 +427,28 @@ export function initDb(path: string = "agent-relay.db"): Database {
   if (!colNames.includes("idempotency_key")) {
     db.run("ALTER TABLE messages ADD COLUMN idempotency_key TEXT");
   }
+  if (!colNames.includes("delivery_status")) {
+    db.run("ALTER TABLE messages ADD COLUMN delivery_status TEXT NOT NULL DEFAULT 'pending'");
+  }
+  if (!colNames.includes("delivery_attempts")) {
+    db.run("ALTER TABLE messages ADD COLUMN delivery_attempts INTEGER NOT NULL DEFAULT 0");
+  }
+  if (!colNames.includes("queued_at")) {
+    db.run("ALTER TABLE messages ADD COLUMN queued_at INTEGER");
+  }
+  if (!colNames.includes("max_age_seconds")) {
+    db.run("ALTER TABLE messages ADD COLUMN max_age_seconds INTEGER");
+  }
+  if (!colNames.includes("resolved_to_agent")) {
+    db.run("ALTER TABLE messages ADD COLUMN resolved_to_agent TEXT");
+  }
   db.prepare(
     "UPDATE messages SET claim_expires_at = coalesce(claimed_at, ?) + ? WHERE claimed_by IS NOT NULL AND claim_expires_at IS NULL",
   ).run(Date.now(), CLAIM_LEASE_MS);
   db.run("CREATE INDEX IF NOT EXISTS idx_msg_thread ON messages(thread_id)");
   db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_msg_idempotency ON messages(from_agent, idempotency_key) WHERE idempotency_key IS NOT NULL");
+  db.run("CREATE INDEX IF NOT EXISTS idx_msg_delivery_status ON messages(delivery_status)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_msg_resolved_to_agent ON messages(resolved_to_agent)");
 
   const channelBindingsSql = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'channel_bindings'").get() as { sql?: string } | undefined;
   if (channelBindingsSql?.sql?.includes("UNIQUE(channel_id, conversation_key)")) {
@@ -626,6 +690,11 @@ function rowToMessage(row: any): Message {
     claimedAt: row.claimed_at ?? undefined,
     claimExpiresAt: row.claim_expires_at ?? undefined,
     idempotencyKey: row.idempotency_key ?? undefined,
+    deliveryStatus: row.delivery_status ?? "pending",
+    deliveryAttempts: row.delivery_attempts ?? 0,
+    queuedAt: row.queued_at ?? undefined,
+    maxAgeSeconds: row.max_age_seconds ?? undefined,
+    resolvedToAgent: row.resolved_to_agent ?? undefined,
     payload: parseJson(row.payload ?? "{}", {}),
     meta: parseJson(row.meta, {}),
     readBy: parseJson(row.read_by_agents ?? "[]", []),
@@ -763,6 +832,7 @@ function bindingTargetToLegacyTarget(target: ChannelRouteTarget): string {
   if (target.type === "broadcast") return "broadcast";
   if (target.type === "orchestrator") return `orchestrator:${target.id}`;
   if (target.type === "pool") return `pool:${target.id}`;
+  if (target.type === "policy") return `policy:${target.id}`;
   return "";
 }
 
@@ -801,6 +871,11 @@ function channelTargetMatches(target: ChannelRouteTarget, channelId?: string): A
     const agent = getAgent(target.id);
     return agent ? [agent] : [];
   }
+  if (target.type === "policy") {
+    const agentId = runningAgentForPolicy(target.id);
+    const agent = agentId ? getAgent(agentId) : null;
+    return agent ? [agent] : [];
+  }
   const channelCandidates = candidates.filter((agent) => agentCanServeChannel(agent, channelId));
   if (target.type === "pool") return poolSelectorMatches(target.id, channelCandidates);
   if (target.type === "label") return channelCandidates.filter((agent) => agent.label === target.id);
@@ -867,7 +942,7 @@ function channelTargetHealth(binding: ChannelBinding, now: number = Date.now()):
     return { status: "ok", detail: `Pool ${targetLabel}: claimed by ${binding.poolAgentId}`, target, matches: snapshots };
   }
 
-  if (target.type === "agent" || target.type === "orchestrator") {
+  if (target.type === "agent" || target.type === "orchestrator" || target.type === "policy") {
     const agent = matches[0];
     if (!agent) {
       return { status: "error", detail: `Target ${targetLabel} is not registered`, target, matches: [] };
@@ -2137,6 +2212,56 @@ function findMessageByIdempotencyKey(from: string, key: string): Message | null
   return row ? rowToMessage(row) : null;
 }
 
+function policyNameFromTarget(target: string): string | null {
+  if (!target.startsWith("policy:")) return null;
+  const name = target.slice("policy:".length).trim();
+  return name || null;
+}
+
+function spawnPolicyExists(policyName: string): boolean {
+  const row = db.prepare("SELECT 1 FROM config WHERE namespace = 'spawn-policy' AND key = ?").get(policyName);
+  return Boolean(row);
+}
+
+function runningAgentForPolicy(policyName: string): string | null {
+  const row = db.prepare(`
+    SELECT agent_id
+    FROM managed_agent_state
+    WHERE policy_name = ? AND status = 'running' AND agent_id IS NOT NULL
+  `).get(policyName) as { agent_id?: string } | undefined;
+  if (!row?.agent_id) return null;
+  const agent = getAgent(row.agent_id);
+  if (!agent || agent.status === "offline") return null;
+  return row.agent_id;
+}
+
+function queueDepthLimit(target: string): number {
+  const row = db.prepare("SELECT value FROM config WHERE namespace = 'system' AND key = 'message-queue'").get() as { value?: string } | undefined;
+  const parsed = row?.value ? parseJson<Record<string, unknown>>(row.value, {}) : {};
+  const perTarget = parsed?.maxDepthPerTarget;
+  if (typeof perTarget === "number" && Number.isSafeInteger(perTarget) && perTarget > 0) return perTarget;
+  const targetLimits = parsed?.targetLimits;
+  if (targetLimits && typeof targetLimits === "object" && !Array.isArray(targetLimits)) {
+    const value = (targetLimits as Record<string, unknown>)[target];
+    if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return value;
+  }
+  return 100;
+}
+
+function enforceQueueLimit(target: string): void {
+  const limit = queueDepthLimit(target);
+  db.prepare(`
+    UPDATE messages
+    SET delivery_status = 'failed'
+    WHERE id IN (
+      SELECT id FROM messages
+      WHERE to_target = ? AND delivery_status = 'queued'
+      ORDER BY queued_at DESC, id DESC
+      LIMIT -1 OFFSET ?
+    )
+  `).run(target, limit);
+}
+
 function isDeliveryAgent(agent: AgentCard): boolean {
   return agent.status !== "offline" &&
     agent.id !== "user" &&
@@ -2231,12 +2356,35 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
   }
 
   const insert = db.prepare(`
-    INSERT INTO messages (from_agent, to_target, kind, channel, subject, body, thread_id, reply_to, claimable, idempotency_key, payload, meta, created_at)
-    VALUES ($from, $to, $kind, $channel, $subject, $body, $threadId, $replyTo, $claimable, $idempotencyKey, $payload, $meta, $now)
+    INSERT INTO messages (
+      from_agent, to_target, kind, channel, subject, body, thread_id, reply_to, claimable,
+      idempotency_key, delivery_status, queued_at, max_age_seconds, resolved_to_agent,
+      payload, meta, created_at
+    )
+    VALUES (
+      $from, $to, $kind, $channel, $subject, $body, $threadId, $replyTo, $claimable,
+      $idempotencyKey, $deliveryStatus, $queuedAt, $maxAgeSeconds, $resolvedToAgent,
+      $payload, $meta, $now
+    )
   `);
   const setSelfThread = db.prepare("UPDATE messages SET thread_id = ? WHERE id = ?");
   const claimable = shouldStoreClaimable(input);
   const kind = inferMessageKind(input);
+  const policyName = policyNameFromTarget(input.to);
+  let deliveryStatus: Message["deliveryStatus"] = "pending";
+  let queuedAt: number | null = null;
+  let maxAgeSeconds = input.maxAgeSeconds ?? null;
+  let resolvedToAgent: string | null = null;
+
+  if (policyName) {
+    if (!spawnPolicyExists(policyName)) throw new ValidationError(`spawn policy ${policyName} not found`);
+    resolvedToAgent = runningAgentForPolicy(policyName);
+    if (!resolvedToAgent) {
+      deliveryStatus = "queued";
+      queuedAt = now;
+      maxAgeSeconds = maxAgeSeconds ?? 86_400;
+    }
+  }
 
   const id = db.transaction(() => {
     const result = insert.run({
@@ -2250,12 +2398,17 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
       $replyTo: input.replyTo ?? null,
       $claimable: claimable ? 1 : 0,
       $idempotencyKey: input.idempotencyKey ?? null,
+      $deliveryStatus: deliveryStatus,
+      $queuedAt: queuedAt,
+      $maxAgeSeconds: maxAgeSeconds,
+      $resolvedToAgent: resolvedToAgent,
       $payload: JSON.stringify(input.payload ?? {}),
       $meta: JSON.stringify(input.meta ?? {}),
       $now: now,
     });
     const newId = Number(result.lastInsertRowid);
     if (threadId === null) setSelfThread.run(newId, newId);
+    if (policyName && deliveryStatus === "queued") enforceQueueLimit(`policy:${policyName}`);
     return newId;
   })();
 
@@ -2375,6 +2528,65 @@ export function getMessage(id: number): Message | null {
   return row ? rowToMessage(row) : null;
 }
 
+export function getMessageDeliveryStatus(id: number): Pick<Message, "id" | "to" | "deliveryStatus" | "deliveryAttempts" | "queuedAt" | "maxAgeSeconds" | "resolvedToAgent"> | null {
+  const message = getMessage(id);
+  if (!message) return null;
+  return {
+    id: message.id,
+    to: message.to,
+    deliveryStatus: message.deliveryStatus,
+    deliveryAttempts: message.deliveryAttempts,
+    queuedAt: message.queuedAt,
+    maxAgeSeconds: message.maxAgeSeconds,
+    resolvedToAgent: message.resolvedToAgent,
+  };
+}
+
+export function listQueuedMessages(target: string, limit = 100): Message[] {
+  const safeLimit = Math.min(Math.max(limit, 1), 500);
+  return (db.prepare(`
+    ${MSG_SELECT}
+    WHERE m.to_target = ? AND m.delivery_status = 'queued'
+    ORDER BY m.queued_at ASC, m.id ASC
+    LIMIT ?
+  `).all(target, safeLimit) as any[]).map(rowToMessage);
+}
+
+export function resolveQueuedPolicyMessages(policyName: string, agentId: string): Message[] {
+  const target = `policy:${policyName}`;
+  const rows = db.prepare(`
+    SELECT id FROM messages
+    WHERE to_target = ? AND delivery_status = 'queued'
+    ORDER BY queued_at ASC, id ASC
+  `).all(target) as Array<{ id: number }>;
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.id);
+  const placeholders = ids.map(() => "?").join(",");
+  db.prepare(`
+    UPDATE messages
+    SET delivery_status = 'pending',
+        resolved_to_agent = ?,
+        delivery_attempts = delivery_attempts + 1
+    WHERE id IN (${placeholders})
+  `).run(agentId, ...ids);
+  return ids.map((id) => getMessage(id)).filter((message): message is Message => Boolean(message));
+}
+
+export function expireQueuedMessages(now: number = Date.now()): Message[] {
+  const rows = db.prepare(`
+    SELECT id FROM messages
+    WHERE delivery_status = 'queued'
+      AND queued_at IS NOT NULL
+      AND coalesce(max_age_seconds, 86400) >= 0
+      AND queued_at + (coalesce(max_age_seconds, 86400) * 1000) <= ?
+  `).all(now) as Array<{ id: number }>;
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.id);
+  const placeholders = ids.map(() => "?").join(",");
+  db.prepare(`UPDATE messages SET delivery_status = 'failed' WHERE id IN (${placeholders})`).run(...ids);
+  return ids.map((id) => getMessage(id)).filter((message): message is Message => Boolean(message));
+}
+
 export function listRecentMessages(limit: number = 100, since?: number, channel?: string): Message[] {
   const conditions: string[] = [];
   const params: any[] = [];
@@ -2409,8 +2621,8 @@ export function pollMessages(query: PollQuery): Message[] {
   // 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 = ?", "to_target = 'broadcast'"];
-  params.push(query.for);
+  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 = ?");
@@ -2429,6 +2641,7 @@ export function pollMessages(query: PollQuery): Message[] {
     params.push(target);
   }
   conditions.push(`(${targetClauses.join(" OR ")})`);
+  conditions.push("delivery_status != 'queued' AND delivery_status != 'failed'");
 
   // Hide active claims held by someone else, but let expired claims surface so
   // another matching agent can recover stuck work.
@@ -2468,6 +2681,11 @@ export function markRead(messageId: number, agentId: string): boolean {
   db.prepare(
     "INSERT OR IGNORE INTO message_reads (message_id, agent_id, read_at) VALUES (?, ?, ?)"
   ).run(messageId, agentId, Date.now());
+  db.prepare(`
+    UPDATE messages
+    SET delivery_status = 'delivered'
+    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(messageId, agentId, agentId);
   return true;
 }
 

package/src/index.ts

@@ -8,6 +8,7 @@ import { expireCommands } from "./commands-db";
 import { applyCommandToRecipe } from "./recipe-runner";
 import { emitRelayEvent } from "./events";
 import { reconcileAutomationRuns, runDueAutomations, type AutomationDispatchResult, type AutomationReconcileResult } from "./automations";
+import { getLifecycleManager } from "./lifecycle-manager";
 import { resolve, sep } from "path";
 import {
   REAP_INTERVAL_MS,
@@ -48,6 +49,7 @@ function startServer(): void {
 
   assertSafeNetworkConfig(HOST);
   initDb(DB_PATH);
+  getLifecycleManager().start();
 
   setInterval(() => {
     const released = releaseExpiredClaims();