@absolutejs/agent-inbox 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AbsoluteJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @absolutejs/agent-inbox
+
+Durable inbound work for agents. Verified webhooks and event subscriptions are
+deduplicated by source event, encrypted through an injected codec, leased to one
+worker, retried with backoff, and dead-lettered after a bounded attempt count.
+Interval schedules materialize deterministic occurrences without Redis.
+Occurrences are inserted before a compare-and-swap advances the schedule, so a
+crash cannot lose a tick and retries collapse on the deterministic source ID.
+
+Every message pins the target agent's signed discovery identity and preserves
+verification provenance. The runtime adapter starts a durable
+`@absolutejs/agent-runtime` run with the inbox message ID as its idempotency key.
+Webhook bodies are byte-limited and are rejected unless a source-specific
+signature/claim verifier succeeds. The Postgres store uses `SKIP LOCKED`; the
+memory store is intended for tests.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./memory";
+export * from "./postgres";
+export * from "./service";
+export * from "./webhook";

package/dist/index.js

@@ -0,0 +1,367 @@
+// @bun
+// src/memory.ts
+var createMemoryAgentInboxStore = () => {
+  const subscriptions = new Map;
+  const messages = new Map;
+  const unique = new Map;
+  const schedules = new Map;
+  return {
+    saveSubscription: async (value) => {
+      subscriptions.set(value.id, structuredClone(value));
+    },
+    listSubscriptions: async ({ tenantId, source, kind }) => [...subscriptions.values()].filter((item) => item.enabled && item.target.tenantId === tenantId && item.source === source && item.kinds.includes(kind)).map((item) => structuredClone(item)),
+    enqueue: async (value) => {
+      const key = `${value.subscriptionId}:${value.source}:${value.sourceEventId}`;
+      const previous = unique.get(key);
+      if (previous)
+        return structuredClone(messages.get(previous));
+      unique.set(key, value.id);
+      messages.set(value.id, structuredClone(value));
+      return structuredClone(value);
+    },
+    claim: async ({ workerId, now, leaseExpiresAt }) => {
+      const row = [...messages.values()].filter((item) => (item.status === "pending" && Date.parse(item.notBefore) <= Date.parse(now) || item.status === "leased" && Date.parse(item.leaseExpiresAt ?? "") <= Date.parse(now)) && (!item.expiresAt || Date.parse(item.expiresAt) > Date.parse(now))).sort((a, b) => a.notBefore.localeCompare(b.notBefore))[0];
+      if (!row)
+        return;
+      const next = {
+        ...row,
+        status: "leased",
+        leaseOwner: workerId,
+        leaseExpiresAt,
+        attempts: row.attempts + 1,
+        updatedAt: now
+      };
+      messages.set(row.id, next);
+      return structuredClone(next);
+    },
+    complete: async ({ id, workerId, now }) => {
+      const row = messages.get(id);
+      if (!row || row.status !== "leased" || row.leaseOwner !== workerId)
+        return false;
+      messages.set(id, {
+        ...row,
+        status: "completed",
+        leaseOwner: undefined,
+        leaseExpiresAt: undefined,
+        updatedAt: now
+      });
+      return true;
+    },
+    retry: async ({ id, workerId, now, notBefore, error, deadLetter }) => {
+      const row = messages.get(id);
+      if (!row || row.status !== "leased" || row.leaseOwner !== workerId)
+        return false;
+      messages.set(id, {
+        ...row,
+        status: deadLetter ? "dead_letter" : "pending",
+        leaseOwner: undefined,
+        leaseExpiresAt: undefined,
+        notBefore,
+        lastError: error,
+        updatedAt: now
+      });
+      return true;
+    },
+    saveSchedule: async (value) => {
+      schedules.set(value.id, structuredClone(value));
+    },
+    claimDueSchedule: async ({ now }) => structuredClone([...schedules.values()].filter((item) => item.enabled && Date.parse(item.nextAt) <= Date.parse(now)).sort((a, b) => a.nextAt.localeCompare(b.nextAt))[0]),
+    advanceSchedule: async ({ id, expectedNextAt, nextAt }) => {
+      const row = schedules.get(id);
+      if (!row || row.nextAt !== expectedNextAt)
+        return false;
+      schedules.set(id, { ...row, nextAt });
+      return true;
+    }
+  };
+};
+// src/postgres.ts
+var safe = (value) => {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(value))
+    throw new Error("Invalid SQL namespace");
+  return value;
+};
+var agentInboxPostgresSchemaSql = (schema = "agent_inbox") => {
+  const ns = safe(schema);
+  return `CREATE SCHEMA IF NOT EXISTS ${ns}; CREATE TABLE IF NOT EXISTS ${ns}.subscriptions (id text PRIMARY KEY, tenant_id text NOT NULL, source text NOT NULL, kinds text[] NOT NULL, enabled boolean NOT NULL, document jsonb NOT NULL); CREATE INDEX IF NOT EXISTS agent_inbox_subscription_idx ON ${ns}.subscriptions (tenant_id,source) WHERE enabled; CREATE TABLE IF NOT EXISTS ${ns}.messages (id text PRIMARY KEY, subscription_id text NOT NULL, source text NOT NULL, source_event_id text NOT NULL, status text NOT NULL, not_before timestamptz NOT NULL, expires_at timestamptz, lease_owner text, lease_expires_at timestamptz, document jsonb NOT NULL, UNIQUE(subscription_id,source,source_event_id)); CREATE INDEX IF NOT EXISTS agent_inbox_due_idx ON ${ns}.messages (status,not_before,lease_expires_at); CREATE TABLE IF NOT EXISTS ${ns}.schedules (id text PRIMARY KEY, enabled boolean NOT NULL, next_at timestamptz NOT NULL, document jsonb NOT NULL); CREATE INDEX IF NOT EXISTS agent_inbox_schedules_due_idx ON ${ns}.schedules (next_at) WHERE enabled;`;
+};
+var row = (value) => value ? typeof value.document === "string" ? JSON.parse(value.document) : value.document : undefined;
+var createPostgresAgentInboxStore = ({
+  client,
+  schema = "agent_inbox"
+}) => {
+  const ns = safe(schema);
+  return {
+    saveSubscription: async (v) => {
+      await client.query(`INSERT INTO ${ns}.subscriptions (id,tenant_id,source,kinds,enabled,document) VALUES ($1,$2,$3,$4,$5,$6::jsonb) ON CONFLICT (id) DO UPDATE SET tenant_id=$2,source=$3,kinds=$4,enabled=$5,document=$6::jsonb`, [
+        v.id,
+        v.target.tenantId,
+        v.source,
+        v.kinds,
+        v.enabled,
+        JSON.stringify(v)
+      ]);
+    },
+    listSubscriptions: async (v) => (await client.query(`SELECT document FROM ${ns}.subscriptions WHERE tenant_id=$1 AND source=$2 AND enabled AND $3=ANY(kinds)`, [v.tenantId, v.source, v.kind])).rows.map((v2) => row(v2)),
+    enqueue: async (v) => {
+      const result = await client.query(`INSERT INTO ${ns}.messages (id,subscription_id,source,source_event_id,status,not_before,expires_at,document) VALUES ($1,$2,$3,$4,$5,$6::timestamptz,$7::timestamptz,$8::jsonb) ON CONFLICT (subscription_id,source,source_event_id) DO UPDATE SET source_event_id=EXCLUDED.source_event_id RETURNING document`, [
+        v.id,
+        v.subscriptionId,
+        v.source,
+        v.sourceEventId,
+        v.status,
+        v.notBefore,
+        v.expiresAt ?? null,
+        JSON.stringify(v)
+      ]);
+      return row(result.rows[0]);
+    },
+    claim: (v) => client.transaction(async (tx) => {
+      const found = row((await tx.query(`SELECT document FROM ${ns}.messages WHERE ((status='pending' AND not_before <= $1::timestamptz) OR (status='leased' AND lease_expires_at <= $1::timestamptz)) AND (expires_at IS NULL OR expires_at > $1::timestamptz) ORDER BY not_before FOR UPDATE SKIP LOCKED LIMIT 1`, [v.now])).rows[0]);
+      if (!found)
+        return;
+      const next = {
+        ...found,
+        status: "leased",
+        leaseOwner: v.workerId,
+        leaseExpiresAt: v.leaseExpiresAt,
+        attempts: found.attempts + 1,
+        updatedAt: v.now
+      };
+      return row((await tx.query(`UPDATE ${ns}.messages SET status='leased',lease_owner=$2,lease_expires_at=$3::timestamptz,document=$4::jsonb WHERE id=$1 RETURNING document`, [found.id, v.workerId, v.leaseExpiresAt, JSON.stringify(next)])).rows[0]);
+    }),
+    complete: async (v) => (await client.query(`UPDATE ${ns}.messages SET status='completed',lease_owner=NULL,lease_expires_at=NULL,document=jsonb_set(jsonb_set(document,'{status}','"completed"'),'{updatedAt}',to_jsonb($3::text)) WHERE id=$1 AND lease_owner=$2 AND status='leased' RETURNING id`, [v.id, v.workerId, v.now])).rows.length === 1,
+    retry: async (v) => {
+      const status = v.deadLetter ? "dead_letter" : "pending";
+      return (await client.query(`UPDATE ${ns}.messages SET status=$3,not_before=$4::timestamptz,lease_owner=NULL,lease_expires_at=NULL,document=document || $5::jsonb WHERE id=$1 AND lease_owner=$2 AND status='leased' RETURNING id`, [
+        v.id,
+        v.workerId,
+        status,
+        v.notBefore,
+        JSON.stringify({
+          status,
+          notBefore: v.notBefore,
+          lastError: v.error,
+          updatedAt: v.now
+        })
+      ])).rows.length === 1;
+    },
+    saveSchedule: async (v) => {
+      await client.query(`INSERT INTO ${ns}.schedules (id,enabled,next_at,document) VALUES ($1,$2,$3::timestamptz,$4::jsonb) ON CONFLICT(id) DO UPDATE SET enabled=$2,next_at=$3::timestamptz,document=$4::jsonb`, [v.id, v.enabled, v.nextAt, JSON.stringify(v)]);
+    },
+    claimDueSchedule: async (v) => row((await client.query(`SELECT document FROM ${ns}.schedules WHERE enabled AND next_at <= $1::timestamptz ORDER BY next_at LIMIT 1`, [v.now])).rows[0]),
+    advanceSchedule: async (v) => (await client.query(`UPDATE ${ns}.schedules SET next_at=$3::timestamptz,document=jsonb_set(document,'{nextAt}',to_jsonb($3::text)) WHERE id=$1 AND next_at=$2::timestamptz RETURNING id`, [v.id, v.expectedNextAt, v.nextAt])).rows.length === 1
+  };
+};
+// src/service.ts
+var identity = {
+  encode: async (value) => structuredClone(value),
+  decode: async (value) => structuredClone(value)
+};
+
+class AgentInboxVerificationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentInboxVerificationError";
+  }
+}
+var createAgentInbox = ({
+  store,
+  verifiers,
+  codec = identity,
+  now = Date.now,
+  id = () => crypto.randomUUID(),
+  maxBodyBytes = 1048576
+}) => ({
+  subscribe: (value) => store.saveSubscription(value),
+  schedule: (value) => {
+    if (!Number.isSafeInteger(value.intervalMs) || value.intervalMs < 1000)
+      throw new Error("Schedule interval must be at least one second");
+    return store.saveSchedule(value);
+  },
+  ingest: async ({
+    source,
+    eventId,
+    kind,
+    body,
+    headers
+  }) => {
+    if (body.byteLength > maxBodyBytes)
+      throw new Error("Agent inbox event body is too large");
+    const verifier = verifiers[source];
+    if (!verifier)
+      throw new Error("No verifier for agent inbox source");
+    const checked = await verifier.verify({
+      source,
+      eventId,
+      kind,
+      body,
+      headers
+    });
+    if (!checked.valid || !checked.tenantId)
+      throw new AgentInboxVerificationError("Agent inbox event verification failed");
+    const subscriptions = await store.listSubscriptions({
+      tenantId: checked.tenantId,
+      source,
+      kind
+    });
+    const timestamp = new Date(now()).toISOString();
+    const output = [];
+    for (const subscription of subscriptions) {
+      const messageId = id();
+      const message = {
+        id: messageId,
+        subscriptionId: subscription.id,
+        target: subscription.target,
+        source,
+        sourceEventId: eventId,
+        kind,
+        encodedPayload: await codec.encode(checked.payload, {
+          tenantId: checked.tenantId,
+          messageId
+        }),
+        provenance: {
+          verifiedBy: verifier.id,
+          verifiedAt: timestamp,
+          ...checked.proof !== undefined ? { proof: checked.proof } : {}
+        },
+        status: "pending",
+        attempts: 0,
+        maxAttempts: 5,
+        notBefore: timestamp,
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+      output.push(await store.enqueue(message));
+    }
+    return output;
+  },
+  tickSchedule: async () => {
+    const timestamp = new Date(now()).toISOString();
+    const schedule = await store.claimDueSchedule({ now: timestamp });
+    if (!schedule)
+      return;
+    const occurrence = schedule.nextAt;
+    const nextAt = new Date(Date.parse(occurrence) + schedule.intervalMs).toISOString();
+    const messageId = id();
+    const message = await store.enqueue({
+      id: messageId,
+      subscriptionId: `schedule:${schedule.id}`,
+      target: schedule.target,
+      source: schedule.source,
+      sourceEventId: `${schedule.id}:${occurrence}`,
+      kind: schedule.kind,
+      encodedPayload: await codec.encode(schedule.payload, {
+        tenantId: schedule.target.tenantId,
+        messageId
+      }),
+      provenance: { verifiedBy: "agent-inbox:schedule", verifiedAt: timestamp },
+      status: "pending",
+      attempts: 0,
+      maxAttempts: schedule.maxAttempts,
+      notBefore: occurrence,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    });
+    if (!await store.advanceSchedule({
+      id: schedule.id,
+      expectedNextAt: occurrence,
+      nextAt
+    }))
+      return;
+    return message;
+  },
+  workOne: async (workerId, handler, options = {}) => {
+    const claimedAt = now();
+    const message = await store.claim({
+      workerId,
+      now: new Date(claimedAt).toISOString(),
+      leaseExpiresAt: new Date(claimedAt + (options.leaseMs ?? 30000)).toISOString()
+    });
+    if (!message)
+      return;
+    try {
+      const payload = await codec.decode(message.encodedPayload, {
+        tenantId: message.target.tenantId,
+        messageId: message.id
+      });
+      await handler({ message, payload });
+      if (!await store.complete({
+        id: message.id,
+        workerId,
+        now: new Date(now()).toISOString()
+      }))
+        throw new Error("Agent inbox lease was lost");
+      return { ...message, status: "completed" };
+    } catch (error) {
+      const deadLetter = message.attempts >= message.maxAttempts;
+      const current = now();
+      await store.retry({
+        id: message.id,
+        workerId,
+        now: new Date(current).toISOString(),
+        notBefore: new Date(current + (options.retryDelayMs?.(message.attempts) ?? Math.min(300000, 1000 * 2 ** message.attempts))).toISOString(),
+        error: error instanceof Error ? error.message : "Agent inbox handler failed",
+        deadLetter
+      });
+      throw error;
+    }
+  }
+});
+var createAgentRuntimeInboxHandler = (runtime) => async ({
+  message,
+  payload
+}) => runtime.start({
+  actor: {
+    tenantId: message.target.tenantId,
+    userId: message.target.userId,
+    agentId: message.target.agentId
+  },
+  agent: message.target.agent,
+  goal: message.target.goal,
+  input: {
+    event: {
+      source: message.source,
+      kind: message.kind,
+      provenance: message.provenance
+    },
+    payload
+  },
+  idempotencyKey: `inbox:${message.id}`
+});
+// src/webhook.ts
+var createAgentInboxWebhookHandler = (ingest, options) => async (request) => {
+  if (request.method !== "POST")
+    return new Response("method not allowed", { status: 405 });
+  const length = Number(request.headers.get("content-length") ?? 0);
+  if (length > (options.maxBodyBytes ?? 1048576))
+    return new Response("payload too large", { status: 413 });
+  const eventId = request.headers.get(options.eventIdHeader ?? "x-event-id");
+  const kind = request.headers.get(options.kindHeader ?? "x-event-type");
+  if (!eventId || !kind)
+    return new Response("missing event identity", { status: 400 });
+  try {
+    const body = new Uint8Array(await request.arrayBuffer());
+    if (body.byteLength > (options.maxBodyBytes ?? 1048576))
+      return new Response("payload too large", { status: 413 });
+    await ingest({
+      source: options.source,
+      eventId,
+      kind,
+      body,
+      headers: request.headers
+    });
+    return new Response(null, { status: 202 });
+  } catch (error) {
+    return error instanceof AgentInboxVerificationError ? new Response("verification failed", { status: 401 }) : new Response("inbox unavailable", { status: 503 });
+  }
+};
+export {
+  createPostgresAgentInboxStore,
+  createMemoryAgentInboxStore,
+  createAgentRuntimeInboxHandler,
+  createAgentInboxWebhookHandler,
+  createAgentInbox,
+  agentInboxPostgresSchemaSql,
+  AgentInboxVerificationError
+};

package/dist/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifest: import("@absolutejs/manifest").PackageManifest<unknown, never>;

package/dist/manifest.js

@@ -0,0 +1,23 @@
+// @bun
+// src/manifest.ts
+import { defineManifest } from "@absolutejs/manifest";
+import { Type } from "@sinclair/typebox";
+var manifest = defineManifest()({
+  contract: 2,
+  identity: {
+    name: "@absolutejs/agent-inbox",
+    category: "automation",
+    tagline: "Wake agents from verified events, not ambient polling.",
+    description: "Durable verified webhooks, event subscriptions, interval schedules, encrypted payloads, leases, retries, dead letters, and agent-runtime handoff.",
+    docsUrl: "https://github.com/absolutejs/agent-inbox",
+    accent: "#06b6d4"
+  },
+  settings: Type.Object({}),
+  slots: {},
+  implements: [],
+  tools: {},
+  wiring: []
+});
+export {
+  manifest
+};

package/dist/manifest.json

@@ -0,0 +1,19 @@
+{
+	"contract": 2,
+	"identity": {
+		"name": "@absolutejs/agent-inbox",
+		"category": "automation",
+		"tagline": "Wake agents from verified events, not ambient polling.",
+		"description": "Durable verified webhooks, event subscriptions, interval schedules, encrypted payloads, leases, retries, dead letters, and agent-runtime handoff.",
+		"docsUrl": "https://github.com/absolutejs/agent-inbox",
+		"accent": "#06b6d4"
+	},
+	"settings": {
+		"type": "object",
+		"properties": {}
+	},
+	"slots": {},
+	"implements": [],
+	"wiring": [],
+	"tools": {}
+}

package/dist/memory.d.ts

@@ -0,0 +1,2 @@
+import type { AgentInboxStore } from "./types";
+export declare const createMemoryAgentInboxStore: () => AgentInboxStore;

package/dist/postgres.d.ts

@@ -0,0 +1,15 @@
+import type { AgentInboxStore } from "./types";
+export type AgentInboxSqlResult<Row> = {
+    rows: Row[];
+};
+export type AgentInboxSqlTransaction = {
+    query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<AgentInboxSqlResult<Row>>;
+};
+export type AgentInboxSqlClient = AgentInboxSqlTransaction & {
+    transaction<Value>(work: (tx: AgentInboxSqlTransaction) => Promise<Value>): Promise<Value>;
+};
+export declare const agentInboxPostgresSchemaSql: (schema?: string) => string;
+export declare const createPostgresAgentInboxStore: ({ client, schema, }: {
+    client: AgentInboxSqlClient;
+    schema?: string;
+}) => AgentInboxStore;

package/dist/service.d.ts

@@ -0,0 +1,69 @@
+import type { AgentInboxCodec, AgentInboxMessage, AgentInboxStore, AgentInboxSubscription, AgentInboxVerifier, AgentSchedule } from "./types";
+export declare class AgentInboxVerificationError extends Error {
+    constructor(message: string);
+}
+export declare const createAgentInbox: ({ store, verifiers, codec, now, id, maxBodyBytes, }: {
+    store: AgentInboxStore;
+    verifiers: Record<string, AgentInboxVerifier>;
+    codec?: AgentInboxCodec;
+    now?: () => number;
+    id?: () => string;
+    maxBodyBytes?: number;
+}) => {
+    subscribe: (value: AgentInboxSubscription) => Promise<void>;
+    schedule: (value: AgentSchedule) => Promise<void>;
+    ingest: ({ source, eventId, kind, body, headers, }: {
+        source: string;
+        eventId: string;
+        kind: string;
+        body: Uint8Array;
+        headers: Headers;
+    }) => Promise<AgentInboxMessage[]>;
+    tickSchedule: () => Promise<AgentInboxMessage | undefined>;
+    workOne: (workerId: string, handler: (input: {
+        message: AgentInboxMessage;
+        payload: unknown;
+    }) => Promise<void>, options?: {
+        leaseMs?: number;
+        retryDelayMs?: (attempt: number) => number;
+    }) => Promise<{
+        status: "completed";
+        id: string;
+        subscriptionId: string;
+        target: import("./types").AgentInboxTarget;
+        source: string;
+        sourceEventId: string;
+        kind: string;
+        encodedPayload: unknown;
+        provenance: {
+            verifiedBy: string;
+            verifiedAt: string;
+            proof?: unknown;
+        };
+        attempts: number;
+        maxAttempts: number;
+        notBefore: string;
+        expiresAt?: string;
+        leaseOwner?: string;
+        leaseExpiresAt?: string;
+        lastError?: string;
+        createdAt: string;
+        updatedAt: string;
+    } | undefined>;
+};
+export declare const createAgentRuntimeInboxHandler: (runtime: {
+    start(input: {
+        actor: {
+            tenantId: string;
+            userId: string;
+            agentId: string;
+        };
+        agent: AgentInboxMessage["target"]["agent"];
+        goal: string;
+        input: unknown;
+        idempotencyKey: string;
+    }): Promise<unknown>;
+}) => ({ message, payload, }: {
+    message: AgentInboxMessage;
+    payload: unknown;
+}) => Promise<unknown>;

package/dist/types.d.ts

@@ -0,0 +1,117 @@
+export type AgentIdentityPin = {
+    descriptorId: string;
+    descriptorVersion: string;
+    descriptorDigest: string;
+};
+export type AgentInboxTarget = {
+    tenantId: string;
+    userId: string;
+    agentId: string;
+    agent: AgentIdentityPin;
+    goal: string;
+};
+export type AgentInboxSubscription = {
+    id: string;
+    target: AgentInboxTarget;
+    source: string;
+    kinds: string[];
+    enabled: boolean;
+    createdAt: string;
+};
+export type AgentInboxMessage = {
+    id: string;
+    subscriptionId: string;
+    target: AgentInboxTarget;
+    source: string;
+    sourceEventId: string;
+    kind: string;
+    encodedPayload: unknown;
+    provenance: {
+        verifiedBy: string;
+        verifiedAt: string;
+        proof?: unknown;
+    };
+    status: "pending" | "leased" | "completed" | "dead_letter";
+    attempts: number;
+    maxAttempts: number;
+    notBefore: string;
+    expiresAt?: string;
+    leaseOwner?: string;
+    leaseExpiresAt?: string;
+    lastError?: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type AgentSchedule = {
+    id: string;
+    target: AgentInboxTarget;
+    source: string;
+    kind: string;
+    payload: unknown;
+    intervalMs: number;
+    nextAt: string;
+    enabled: boolean;
+    maxAttempts: number;
+    createdAt: string;
+};
+export type AgentInboxStore = {
+    saveSubscription(value: AgentInboxSubscription): Promise<void>;
+    listSubscriptions(input: {
+        tenantId: string;
+        source: string;
+        kind: string;
+    }): Promise<AgentInboxSubscription[]>;
+    enqueue(value: AgentInboxMessage): Promise<AgentInboxMessage>;
+    claim(input: {
+        workerId: string;
+        now: string;
+        leaseExpiresAt: string;
+    }): Promise<AgentInboxMessage | undefined>;
+    complete(input: {
+        id: string;
+        workerId: string;
+        now: string;
+    }): Promise<boolean>;
+    retry(input: {
+        id: string;
+        workerId: string;
+        now: string;
+        notBefore: string;
+        error: string;
+        deadLetter: boolean;
+    }): Promise<boolean>;
+    saveSchedule(value: AgentSchedule): Promise<void>;
+    claimDueSchedule(input: {
+        now: string;
+    }): Promise<AgentSchedule | undefined>;
+    advanceSchedule(input: {
+        id: string;
+        expectedNextAt: string;
+        nextAt: string;
+    }): Promise<boolean>;
+};
+export type AgentInboxVerifier = {
+    id: string;
+    verify(input: {
+        source: string;
+        eventId: string;
+        kind: string;
+        body: Uint8Array;
+        headers: Headers;
+    }): Promise<{
+        valid: boolean;
+        tenantId?: string;
+        payload?: unknown;
+        proof?: unknown;
+    }>;
+};
+export type AgentInboxCodec = {
+    encode(value: unknown, context: {
+        tenantId: string;
+        messageId: string;
+    }): Promise<unknown>;
+    decode(value: unknown, context: {
+        tenantId: string;
+        messageId: string;
+    }): Promise<unknown>;
+};

package/dist/webhook.d.ts

@@ -0,0 +1,12 @@
+export declare const createAgentInboxWebhookHandler: (ingest: (input: {
+    source: string;
+    eventId: string;
+    kind: string;
+    body: Uint8Array;
+    headers: Headers;
+}) => Promise<unknown>, options: {
+    source: string;
+    eventIdHeader?: string;
+    kindHeader?: string;
+    maxBodyBytes?: number;
+}) => (request: Request) => Promise<Response>;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@absolutejs/agent-inbox",
+  "version": "0.1.0",
+  "description": "Durable verified webhooks, event subscriptions, schedules, leases, retries, and dead letters for AI agent triggers.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/absolutejs/agent-inbox.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "absolutejs": {
+    "manifestContract": 2
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./manifest.json": "./dist/manifest.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "format": "prettier --write \"./**/*.{ts,json,md,yml}\"",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "build": "rm -rf dist && bun build src/index.ts src/manifest.ts --outdir dist --target=bun --external @absolutejs/manifest --external @sinclair/typebox && tsc -p tsconfig.build.json && absolute-manifest emit",
+    "check:package": "bun run typecheck && bun run test && bun run build"
+  },
+  "dependencies": {
+    "@absolutejs/manifest": "^0.2.0",
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "prettier": "3.5.3",
+    "typescript": "5.8.3"
+  }
+}