agent-relay-runner 0.127.4 → 0.127.6

package/src/mcp-outbox.ts

@@ -68,8 +68,15 @@ export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Pro
     logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
   } catch (error) {
     if (isHttpStatusError(error, 409)) {
+      const reason = errMessage(error);
       if (record.kind === "session-message-batch") {
-        logger.error("outbox", `relay reported duplicate session batch; acking row seq=${record.seq} batchKey=${record.idempotencyKey} itemKeys=${sessionBatchItemKeys(record).join(",")} error=${errMessage(error)}`);
+        const messages = sessionBatchMessages(record);
+        logger.error("outbox", `relay reported duplicate session batch; acking row seq=${record.seq} batchKey=${record.idempotencyKey} itemKeys=${sessionBatchItemKeys(record).join(",")} error=${reason}`);
+        await emitMirrorDropNotice(input, messages, messages.length, `duplicate idempotency key: ${reason}`, "duplicate-batch");
+      } else if (record.kind === "session-message") {
+        const message = record.payload as SendMessageInput;
+        logger.error("outbox", `relay reported duplicate session message; acking row seq=${record.seq} key=${record.idempotencyKey} error=${reason}`);
+        await emitMirrorDropNotice(input, [message], 1, `duplicate idempotency key: ${reason}`, "duplicate-message");
       }
       return;
     }
@@ -79,14 +86,20 @@ export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Pro
 }
 
 async function deliverSessionBatchItems(input: RunnerOutboxDelivery, messages: SendMessageInput[]): Promise<void> {
+  const dropped: Array<{ message: SendMessageInput; reason: string }> = [];
   for (const message of messages) {
     try {
       await input.http.sendMessage(message);
     } catch (error) {
       if (!isDeterministicValidationError(error)) throw error;
-      logger.warn("outbox", `dropping invalid session batch item: ${errMessage(error)}`);
+      const reason = errMessage(error);
+      logger.error("outbox", `dropping invalid session batch item key=${message.idempotencyKey ?? "(none)"} error=${reason}`);
+      dropped.push({ message, reason });
     }
   }
+  for (const item of dropped) {
+    await emitMirrorDropNotice(input, [item.message], 1, item.reason, "invalid-item");
+  }
 }
 
 function isDeterministicValidationError(error: unknown): boolean {
@@ -95,10 +108,47 @@ function isDeterministicValidationError(error: unknown): boolean {
 }
 
 function sessionBatchItemKeys(record: OutboxRecord): string[] {
-  const messages = Array.isArray((record.payload as { messages?: unknown }).messages)
+  const messages = sessionBatchMessages(record);
+  return messages.map((message, index) => message.idempotencyKey ?? `${record.idempotencyKey}:${index}`);
+}
+
+function sessionBatchMessages(record: OutboxRecord): SendMessageInput[] {
+  return Array.isArray((record.payload as { messages?: unknown }).messages)
     ? (record.payload as { messages: SendMessageInput[] }).messages
     : [];
-  return messages.map((message, index) => message.idempotencyKey ?? `${record.idempotencyKey}:${index}`);
+}
+
+async function emitMirrorDropNotice(input: RunnerOutboxDelivery, messages: SendMessageInput[], count: number, reason: string, suffix: string): Promise<void> {
+  if (count <= 0) return;
+  const anchor = messages[0];
+  const from = typeof anchor?.from === "string" && anchor.from ? anchor.from : "system";
+  const to = typeof anchor?.to === "string" && anchor.to ? anchor.to : "user";
+  const occurredAt = typeof anchor?.occurredAt === "number" ? anchor.occurredAt : input.record.occurredAt;
+  const body = `${count} steps could not be mirrored: ${reason}`;
+  const idempotencyKey = `session-mirror-drop:${input.record.idempotencyKey}:${suffix}:${shortHash(body)}`;
+  logger.error("outbox", `session mirror drop notice seq=${input.record.seq} count=${count} reason=${reason} noticeKey=${idempotencyKey}`);
+  try {
+    await input.http.sendMessage({
+      from,
+      to,
+      kind: "session",
+      body,
+      idempotencyKey,
+      occurredAt,
+      payload: { session: { type: "notice", origin: "provider", label: "mirror-drop", stepId: idempotencyKey } },
+    });
+  } catch (error) {
+    logger.error("outbox", `failed to emit session mirror drop notice seq=${input.record.seq}; acking original row anyway: ${errMessage(error)}`);
+  }
+}
+
+function shortHash(value: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < value.length; i++) {
+    h ^= value.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(36);
 }
 
 export async function deliverBufferedMcpCall(input: {

package/src/pending-permission-store.ts

@@ -0,0 +1,148 @@
+import { Database } from "bun:sqlite";
+import type { InteractivePrompt } from "agent-relay-sdk";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { runnerOutboxDirFromEnv } from "./config";
+import { logger } from "./logger";
+import { errMessage } from "agent-relay-sdk";
+
+export interface PendingPermissionRequestRecord {
+  approvalId: string;
+  view: InteractivePrompt;
+  hookDeadlineAt: number;
+  ownerInstanceId: string;
+  occurredAt: number;
+}
+
+interface PendingPermissionRow {
+  approval_id: string;
+  view: string;
+  hook_deadline_at: number;
+  owner_instance_id: string;
+  occurred_at: number;
+}
+
+export class PendingPermissionStore {
+  private db?: Database;
+  readonly path: string;
+
+  constructor(options: { agentId: string; dir?: string }) {
+    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "agent-relay-outbox");
+    this.path = options.dir === ":memory:" ? ":memory:" : join(dir, `pending-permissions-${safeName(options.agentId)}.sqlite`);
+    try {
+      if (this.path !== ":memory:") mkdirSync(dirname(this.path), { recursive: true });
+      const db = new Database(this.path, { create: true });
+      db.exec("PRAGMA journal_mode = WAL");
+      db.exec("PRAGMA busy_timeout = 2000");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS pending_permission_requests (
+          approval_id TEXT PRIMARY KEY,
+          view TEXT NOT NULL,
+          hook_deadline_at INTEGER NOT NULL,
+          owner_instance_id TEXT NOT NULL,
+          occurred_at INTEGER NOT NULL,
+          created_at INTEGER NOT NULL
+        )
+      `);
+      this.db = db;
+    } catch (error) {
+      logger.error("pending-permission-store", `disabled after open failed path=${this.path}: ${errMessage(error)}`);
+      this.db = undefined;
+    }
+  }
+
+  upsert(record: PendingPermissionRequestRecord): void {
+    if (!this.db) return;
+    try {
+      this.db.query(`
+        INSERT INTO pending_permission_requests (approval_id, view, hook_deadline_at, owner_instance_id, occurred_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(approval_id) DO UPDATE SET
+          view = excluded.view,
+          hook_deadline_at = excluded.hook_deadline_at,
+          owner_instance_id = excluded.owner_instance_id,
+          occurred_at = excluded.occurred_at
+      `).run(record.approvalId, JSON.stringify(record.view), record.hookDeadlineAt, record.ownerInstanceId, record.occurredAt, Date.now());
+    } catch (error) {
+      logger.error("pending-permission-store", `upsert failed approvalId=${record.approvalId}; continuing in-memory only: ${errMessage(error)}`);
+    }
+  }
+
+  delete(approvalId: string): void {
+    if (!this.db) return;
+    try {
+      this.db.query("DELETE FROM pending_permission_requests WHERE approval_id = ?").run(approvalId);
+    } catch (error) {
+      logger.error("pending-permission-store", `delete failed approvalId=${approvalId}; continuing in-memory only: ${errMessage(error)}`);
+    }
+  }
+
+  list(): PendingPermissionRequestRecord[] {
+    if (!this.db) return [];
+    try {
+      const rows = this.db.query("SELECT * FROM pending_permission_requests ORDER BY occurred_at ASC").all() as PendingPermissionRow[];
+      return rows.map((row) => ({
+        approvalId: row.approval_id,
+        view: safeParseView(row.view),
+        hookDeadlineAt: row.hook_deadline_at,
+        ownerInstanceId: row.owner_instance_id,
+        occurredAt: row.occurred_at,
+      }));
+    } catch (error) {
+      logger.error("pending-permission-store", `list failed; continuing without persisted approvals: ${errMessage(error)}`);
+      return [];
+    }
+  }
+
+  close(): void {
+    try { this.db?.close(); } catch { /* already closed */ }
+  }
+}
+
+export function bestEffortListPendingPermissionRequests(store: PendingPermissionStore | undefined): PendingPermissionRequestRecord[] {
+  try {
+    return store?.list() ?? [];
+  } catch (error) {
+    logger.error("pending-permission-store", `list failed; continuing without persisted approvals: ${errMessage(error)}`);
+    return [];
+  }
+}
+
+export function bestEffortUpsertPendingPermissionRequest(store: PendingPermissionStore | undefined, record: PendingPermissionRequestRecord): void {
+  try {
+    store?.upsert(record);
+  } catch (error) {
+    logger.error("pending-permission-store", `upsert failed approvalId=${record.approvalId}; continuing in-memory only: ${errMessage(error)}`);
+  }
+}
+
+export function bestEffortDeletePendingPermissionRequest(store: PendingPermissionStore | undefined, approvalId: string): void {
+  try {
+    store?.delete(approvalId);
+  } catch (error) {
+    logger.error("pending-permission-store", `delete failed approvalId=${approvalId}; continuing in-memory only: ${errMessage(error)}`);
+  }
+}
+
+function safeName(value: string): string {
+  return sanitizeFsName(value, { replacement: "_", maxLen: 180, fallback: "agent" });
+}
+
+function safeParseView(json: string): InteractivePrompt {
+  try {
+    const parsed = JSON.parse(json);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as InteractivePrompt;
+  } catch {
+    // Fall through to a valid placeholder so recovery can still emit a notice and clear the row.
+  }
+  return {
+    id: "unknown",
+    kind: "tool",
+    title: "Recovered permission request",
+    body: "The original permission request could not be decoded.",
+    choices: [],
+    reasoningSettled: false,
+  };
+}

package/src/profile-home.ts

@@ -7,7 +7,7 @@ import { getManifest } from "agent-relay-providers";
 import { profileAllowsRelayFeature, type RunnerSpawnConfig } from "./adapter";
 import { claudeRelayManual } from "./relay-instructions";
 import { providerHomeRootFromEnv } from "./config";
-import { applyClaudeConfigPromptGatePreventions } from "./claude-prompt-gates";
+import { applyClaudeConfigPromptGatePreventions } from "./adapters/claude-prompt-gates";
 
 type ProviderHome = {
   path: string;