@creatornader/agent-bridge 0.2.0 → 0.3.0

package/dist/{bridge-service-CfqMcMAn.d.ts → bridge-service-hX1ZQp4W.d.ts}

@@ -1,11 +1,14 @@
-import { c as BridgePrincipal, M as MessageDraft, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
-import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage } from './bridge-store-BuGjxTn4.js';
+import { a as BridgeStore, I as InsertMessageResult, d as MessageQuery, M as MessagePage, c as DeliveryQuery, b as DeliveryPage, D as DeliveryEventPage } from './bridge-store-DPVSCwfs.js';
+import { c as BridgePrincipal, M as MessageDraft, B as BridgeDelivery, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
 
+type PublicMessageQuery = MessageQuery & {
+    unacknowledgedBy?: string;
+};
 declare class BridgeService {
     private readonly store;
     constructor(store: BridgeStore);
     publish(principalInput: BridgePrincipal, draftInput: MessageDraft): Promise<InsertMessageResult>;
-    history(principalInput: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
+    history(principalInput: BridgePrincipal, query?: PublicMessageQuery): Promise<MessagePage>;
     acknowledge(principalInput: BridgePrincipal, messageIds: string[]): Promise<number>;
     claim(principalInput: BridgePrincipal, options?: {
         leaseMs?: number;
@@ -16,7 +19,14 @@ declare class BridgeService {
     } | null>;
     extend(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs?: number): Promise<BridgeDelivery | null>;
     ack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string): Promise<BridgeDelivery | null>;
-    nack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, error: string, dead?: boolean, retryPolicy?: Partial<RetryPolicy>): Promise<BridgeDelivery | null>;
+    nack(principalInput: BridgePrincipal, deliveryId: string, leaseToken: string, error: string, disposition?: "retry" | "dead" | boolean, deprecatedRetryPolicy?: unknown): Promise<BridgeDelivery | null>;
+    deliveries(principalInput: BridgePrincipal, query?: DeliveryQuery): Promise<DeliveryPage>;
+    deliveryEvents(principalInput: BridgePrincipal, deliveryId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<DeliveryEventPage>;
+    cancel(principalInput: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    requeue(principalInput: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
     heartbeat(principalInput: BridgePrincipal, options?: {
         leaseMs?: number;
         runtimeType?: string;
@@ -25,4 +35,4 @@ declare class BridgeService {
     presence(principalInput: BridgePrincipal): Promise<AgentPresence[]>;
 }
 
-export { BridgeService as B };
+export { BridgeService as B, type PublicMessageQuery as P };

package/dist/bridge-store-DPVSCwfs.d.ts

@@ -0,0 +1,102 @@
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, g as DeliveryState, R as RetryPolicy, a as BridgeDeliveryEvent, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
+
+interface InsertMessageResult {
+    message: BridgeMessage;
+    created: boolean;
+}
+interface MessageQuery {
+    mailbox?: "inbox" | "sent" | "all";
+    receiptState?: "any" | "unread" | "read";
+    project?: string;
+    cursor?: string;
+    limit?: number;
+    types?: string[];
+    includeExpired?: boolean;
+    source?: string;
+    since?: string;
+    threadId?: string;
+    latest?: boolean;
+}
+interface MessagePage {
+    messages: BridgeMessage[];
+    cursor?: string;
+}
+interface BridgeDiagnostics {
+    schemaVersion: "local-v2" | "postgres-v2" | "legacy-v1";
+    deliverySupported: boolean;
+    pending: number | null;
+    claimed: number | null;
+    retrying: number | null;
+    dead: number | null;
+    cancelled?: number | null;
+    oldestAvailableAt?: string;
+    due?: number | null;
+    scheduled?: number | null;
+    expiredLeases?: number | null;
+    oldestDueAt?: string;
+    queueLagMs?: number | null;
+    principal?: {
+        workspace: string;
+        agent: string;
+    };
+}
+interface ClaimOptions {
+    leaseMs: number;
+    now?: Date;
+    maxAttempts?: number;
+}
+interface DeliveryQuery {
+    role?: "recipient" | "publisher" | "all";
+    states?: DeliveryState[];
+    messageId?: string;
+    recipient?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface DeliveryPage {
+    deliveries: BridgeDelivery[];
+    cursor?: string;
+}
+interface DeliveryEventPage {
+    events: BridgeDeliveryEvent[];
+    cursor?: string;
+}
+interface BridgeStore {
+    initialize(options?: {
+        signal?: AbortSignal;
+        mode?: "active" | "passive";
+    }): Promise<void>;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">, options?: {
+        signal?: AbortSignal;
+    }): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<MessagePage>;
+    recordReceipt(principal: BridgePrincipal, messageIds: string[], readAt?: Date): Promise<number>;
+    recordLegacyReceipt?(legacyIds: string[], principal: string): Promise<number>;
+    claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    renewDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, leaseMs: number): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, deliveryId: string, leaseToken: string, state: Extract<DeliveryState, "acked" | "retrying" | "dead">, error?: string, retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
+    listDeliveries?(principal: BridgePrincipal, query?: DeliveryQuery): Promise<DeliveryPage>;
+    listDeliveryEvents?(principal: BridgePrincipal, deliveryId: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<DeliveryEventPage>;
+    cancelDelivery?(principal: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    requeueDelivery?(principal: BridgePrincipal, deliveryId: string): Promise<BridgeDelivery | null>;
+    diagnostics?(principal: BridgePrincipal, options?: {
+        mode?: "snapshot" | "probe";
+    }): Promise<BridgeDiagnostics>;
+    heartbeat?(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
+    listPresence?(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    sync?(options?: {
+        maxPush?: number;
+        maxPages?: number;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+    verifyRemote?(): Promise<void>;
+    capabilities?(): Promise<unknown>;
+    close?(): Promise<void>;
+}
+
+export type { BridgeDiagnostics as B, ClaimOptions as C, DeliveryEventPage as D, InsertMessageResult as I, MessagePage as M, BridgeStore as a, DeliveryPage as b, DeliveryQuery as c, MessageQuery as d };

package/dist/bridge.d.ts

@@ -1,9 +1,11 @@
-import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-BcnBeHOn.js';
-export { a as BridgeDeliveryEvent, d as BridgeValidationError, D as DeliveryState, J as JsonValue, M as MessageDraft, e as MessagePriority, f as decodeCursor, g as encodeCursor, u as uuidv7, v as validateMessageDraft, h as validatePrincipal, i as validateRetryPolicy, j as validateUuid } from './bridge-domain-BcnBeHOn.js';
-import { a as BridgeStore, I as InsertMessageResult, b as MessageQuery, M as MessagePage, C as ClaimOptions, B as BridgeDiagnostics } from './bridge-store-BuGjxTn4.js';
-export { B as BridgeService } from './bridge-service-CfqMcMAn.js';
-import { P as PgQueryable } from './gateway-BULozv3K.js';
-export { A as AuthenticatedCredential, C as CredentialResolver, G as GatewayOptions, a as PostgresBridgeStore, b as PostgresCredentialResolver, c as bearerToken, d as createGateway, h as hashCredential, s as safeTokenHashEqual } from './gateway-BULozv3K.js';
+import { b as BridgeMessage, c as BridgePrincipal, B as BridgeDelivery, R as RetryPolicy, A as AgentPresence } from './bridge-domain-CBX3IVqC.js';
+export { a as BridgeDeliveryEvent, d as BridgePrincipalMismatchError, e as BridgeValidationError, D as DeliveryAction, f as DeliveryPolicy, g as DeliveryState, h as DeliveryStateConflictError, J as JsonValue, L as LeasedDeliveryPolicy, M as MessageDraft, i as MessagePriority, j as cursorScope, k as decodeCursor, l as decodeScopedCursor, m as encodeCursor, n as encodeScopedCursor, s as scopedCursorScope, u as uuidv7, v as validateDeliveryCursorPosition, o as validateDeliveryPolicy, p as validateEventCursorPosition, q as validateLeasedDeliveryPolicy, r as validateMessageDraft, t as validatePrincipal, w as validateProject, x as validateUuid } from './bridge-domain-CBX3IVqC.js';
+import { a as BridgeStore, I as InsertMessageResult, d as MessageQuery, M as MessagePage, C as ClaimOptions, B as BridgeDiagnostics, c as DeliveryQuery } from './bridge-store-DPVSCwfs.js';
+export { D as DeliveryEventPage, b as DeliveryPage } from './bridge-store-DPVSCwfs.js';
+export { B as BridgeService, P as PublicMessageQuery } from './bridge-service-hX1ZQp4W.js';
+import { P as PgQueryable } from './postgres-bridge-store-Bfd3hRId.js';
+export { a as PgTransactionClient, b as PostgresBridgeStore } from './postgres-bridge-store-Bfd3hRId.js';
+export { A as AuthenticatedCredential, C as CredentialResolver, G as GatewayOptions, P as PostgresCredentialResolver, b as bearerToken, c as createGateway, h as hashCredential, s as safeTokenHashEqual } from './gateway-CggQ8vTC.js';
 export { CachedMessagePage, EdgeConflictError, EdgeEnqueueResult, EdgeOutboxRecord, EdgeScope, EdgeStats, PendingMessage, SQLiteBridgeStore, SQLiteEdgeStore, SyncDiagnostics, SyncInsertResult, SyncReport, SyncingBridgeStore, SyncingBridgeStoreOptions, edgeMessageFingerprint, edgeScopeKey, isRetryableSyncError, stableIdempotency } from './sqlite.js';
 import 'node:http';
 
@@ -20,15 +22,18 @@ declare class LegacySupabaseRestStore implements BridgeStore {
     private readonly legacyIds;
     private initialized;
     constructor(url: string, key: string, fetchImpl?: typeof fetch, timeoutMs?: number);
-    initialize(): Promise<void>;
+    initialize(options?: {
+        mode?: "active" | "passive";
+    }): Promise<void>;
     private request;
+    private visibleReceiptIds;
     insertMessage(input: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
     listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
-    recordReceipt(_workspace: string, ids: string[], principal: string): Promise<number>;
+    recordReceipt(principal: BridgePrincipal, ids: string[]): Promise<number>;
     recordLegacyReceipt(ids: string[], principal: string): Promise<number>;
     claimDelivery(_principal: BridgePrincipal, _options: ClaimOptions): Promise<BridgeDelivery | null>;
     renewDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _state: "acked" | "retrying" | "dead", _error: string | undefined, _retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    settleDelivery(_principal: BridgePrincipal, _deliveryId: string, _leaseToken: string, _state: "acked" | "retrying" | "dead", _error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
     diagnostics(_principal: BridgePrincipal): Promise<BridgeDiagnostics>;
 }
 
@@ -43,27 +48,51 @@ interface HttpBridgeStoreOptions {
 declare class BridgeHttpError extends Error {
     readonly status: number;
     readonly code: string;
-    constructor(status: number, code: string);
+    readonly requestId?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(status: number, code: string, requestId?: string | undefined, details?: unknown | undefined, message?: string);
 }
 declare class HttpBridgeStore implements BridgeStore {
     private readonly options;
     private readonly fetchImpl;
+    private readonly closeController;
+    private closed;
+    private selectedProtocolVersion?;
+    private protocolProbe?;
     constructor(options: HttpBridgeStoreOptions);
-    initialize(): Promise<void>;
+    initialize(options?: {
+        signal?: AbortSignal;
+        mode?: "active" | "passive";
+    }): Promise<void>;
     private assertBoundPrincipal;
     private request;
+    private ensureProtocol;
+    capabilities(): Promise<unknown>;
     private assertPrincipal;
-    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">): Promise<InsertMessageResult>;
-    listMessages(principal: BridgePrincipal, query?: MessageQuery): Promise<MessagePage>;
-    recordReceipt(workspace: string, ids: string[], principal: string): Promise<number>;
+    insertMessage(message: Omit<BridgeMessage, "sequence" | "createdAt">, options?: {
+        signal?: AbortSignal;
+    }): Promise<InsertMessageResult>;
+    listMessages(principal: BridgePrincipal, query?: MessageQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<MessagePage>;
+    recordReceipt(principal: BridgePrincipal, ids: string[]): Promise<number>;
     diagnostics(principal: BridgePrincipal): Promise<BridgeDiagnostics>;
     claimDelivery(principal: BridgePrincipal, options: ClaimOptions): Promise<BridgeDelivery | null>;
+    listDeliveries(principal: BridgePrincipal, query?: DeliveryQuery): Promise<any>;
+    listDeliveryEvents(principal: BridgePrincipal, id: string, query?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<any>;
+    cancelDelivery(principal: BridgePrincipal, id: string): Promise<any>;
+    requeueDelivery(principal: BridgePrincipal, id: string): Promise<any>;
     renewDelivery(principal: BridgePrincipal, id: string, token: string, leaseMs: number): Promise<BridgeDelivery | null>;
-    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error: string | undefined, retryPolicy: RetryPolicy): Promise<BridgeDelivery | null>;
+    settleDelivery(principal: BridgePrincipal, id: string, token: string, state: "acked" | "retrying" | "dead", error?: string, _retryPolicy?: RetryPolicy): Promise<BridgeDelivery | null>;
     heartbeat(principal: BridgePrincipal, leaseMs: number, runtimeType?: string, capabilities?: string[]): Promise<AgentPresence>;
     listPresence(principal: BridgePrincipal): Promise<AgentPresence[]>;
+    close(): Promise<void>;
 }
 
+declare const NATIVE_DR_ADVISORY_LOCK_KEY = 1646705664;
 interface AppliedMigration {
     version: number;
     name: string;
@@ -93,10 +122,40 @@ declare const REQUIRED_MIGRATIONS: readonly [{
 }, {
     readonly version: 7;
     readonly name: "runtime_role";
+}, {
+    readonly version: 8;
+    readonly name: "message_projects";
+}, {
+    readonly version: 9;
+    readonly name: "mailbox_query_indexes";
+}, {
+    readonly version: 10;
+    readonly name: "publisher_delivery_policy";
+}, {
+    readonly version: 11;
+    readonly name: "credential_security";
+}, {
+    readonly version: 12;
+    readonly name: "request_authority";
+}, {
+    readonly version: 13;
+    readonly name: "row_isolation";
+}, {
+    readonly version: 14;
+    readonly name: "owner_control_plane";
+}, {
+    readonly version: 15;
+    readonly name: "portable_archives";
+}, {
+    readonly version: 16;
+    readonly name: "native_dr_fence";
 }];
 declare function loadMigrationPlan(directory: string): Promise<MigrationPlanEntry[]>;
 declare function migrationsReady(db: PgQueryable, expected: ReadonlyArray<Pick<MigrationPlanEntry, "version" | "name" | "checksum">>): Promise<boolean>;
-declare function runtimeSchemaReady(db: PgQueryable): Promise<boolean>;
+declare function rowIsolationReady(db: PgQueryable, allowPrivilegedCaller: boolean): Promise<boolean>;
+declare function runtimeSchemaReady(db: PgQueryable, options?: {
+    allowPrivilegedCaller?: boolean;
+}): Promise<boolean>;
 declare function runMigrations(db: PgQueryable, directory: string): Promise<AppliedMigration[]>;
 
-export { AgentPresence, type AppliedMigration, BridgeDelivery, BridgeDiagnostics, BridgeHttpError, BridgeMessage, BridgePrincipal, BridgeStore, ClaimOptions, HttpBridgeStore, type HttpBridgeStoreOptions, InsertMessageResult, LegacySupabaseError, LegacySupabaseRestStore, MessagePage, MessageQuery, type MigrationPlanEntry, PgQueryable, REQUIRED_MIGRATIONS, RetryPolicy, loadMigrationPlan, migrationsReady, runMigrations, runtimeSchemaReady };
+export { AgentPresence, type AppliedMigration, BridgeDelivery, BridgeDiagnostics, BridgeHttpError, BridgeMessage, BridgePrincipal, BridgeStore, ClaimOptions, DeliveryQuery, HttpBridgeStore, type HttpBridgeStoreOptions, InsertMessageResult, LegacySupabaseError, LegacySupabaseRestStore, MessagePage, MessageQuery, type MigrationPlanEntry, NATIVE_DR_ADVISORY_LOCK_KEY, PgQueryable, REQUIRED_MIGRATIONS, RetryPolicy, loadMigrationPlan, migrationsReady, rowIsolationReady, runMigrations, runtimeSchemaReady };

package/dist/bridge.js

@@ -1,59 +1,78 @@
 #!/usr/bin/env node
+import {
+  BridgeHttpError,
+  HttpBridgeStore,
+  LegacySupabaseError,
+  LegacySupabaseRestStore
+} from "./chunk-CEXBMOI5.js";
+import {
+  EdgeConflictError,
+  SQLiteEdgeStore,
+  SyncingBridgeStore,
+  edgeMessageFingerprint,
+  edgeScopeKey,
+  isRetryableSyncError,
+  stableIdempotency
+} from "./chunk-Q6PPMXJC.js";
+import {
+  SQLiteBridgeStore
+} from "./chunk-5GMB3A77.js";
+import "./chunk-NCO7RLBM.js";
 import {
   PostgresBridgeStore
-} from "./chunk-O26W5QHS.js";
+} from "./chunk-2DFNOLMO.js";
 import {
+  NATIVE_DR_ADVISORY_LOCK_KEY,
   REQUIRED_MIGRATIONS,
   loadMigrationPlan,
   migrationsReady,
+  rowIsolationReady,
   runMigrations,
   runtimeSchemaReady
-} from "./chunk-6MAZ6YLZ.js";
+} from "./chunk-45BZGB77.js";
+import "./chunk-VOQIDTCJ.js";
 import {
   PostgresCredentialResolver,
   bearerToken,
   createGateway,
   hashCredential,
   safeTokenHashEqual
-} from "./chunk-JOUBDRYX.js";
-import {
-  BridgeHttpError,
-  HttpBridgeStore,
-  LegacySupabaseError,
-  LegacySupabaseRestStore
-} from "./chunk-AXL2I7FH.js";
-import {
-  EdgeConflictError,
-  SQLiteBridgeStore,
-  SQLiteEdgeStore,
-  SyncingBridgeStore,
-  edgeMessageFingerprint,
-  edgeScopeKey,
-  isRetryableSyncError,
-  stableIdempotency
-} from "./chunk-WEULPMUY.js";
-import "./chunk-YD6YJATN.js";
+} from "./chunk-WAI2IYIQ.js";
 import {
   BridgeService
-} from "./chunk-CKSKUBDQ.js";
+} from "./chunk-4VB44KJU.js";
+import "./chunk-GADH244D.js";
 import {
+  BridgePrincipalMismatchError,
   BridgeValidationError,
+  DeliveryStateConflictError,
+  cursorScope,
   decodeCursor,
+  decodeScopedCursor,
   encodeCursor,
+  encodeScopedCursor,
+  scopedCursorScope,
   uuidv7,
+  validateDeliveryCursorPosition,
+  validateDeliveryPolicy,
+  validateEventCursorPosition,
+  validateLeasedDeliveryPolicy,
   validateMessageDraft,
   validatePrincipal,
-  validateRetryPolicy,
+  validateProject,
   validateUuid
-} from "./chunk-BV6W4AJK.js";
+} from "./chunk-BZLMF5O5.js";
 export {
   BridgeHttpError,
+  BridgePrincipalMismatchError,
   BridgeService,
   BridgeValidationError,
+  DeliveryStateConflictError,
   EdgeConflictError,
   HttpBridgeStore,
   LegacySupabaseError,
   LegacySupabaseRestStore,
+  NATIVE_DR_ADVISORY_LOCK_KEY,
   PostgresBridgeStore,
   PostgresCredentialResolver,
   REQUIRED_MIGRATIONS,
@@ -62,22 +81,31 @@ export {
   SyncingBridgeStore,
   bearerToken,
   createGateway,
+  cursorScope,
   decodeCursor,
+  decodeScopedCursor,
   edgeMessageFingerprint,
   edgeScopeKey,
   encodeCursor,
+  encodeScopedCursor,
   hashCredential,
   isRetryableSyncError,
   loadMigrationPlan,
   migrationsReady,
+  rowIsolationReady,
   runMigrations,
   runtimeSchemaReady,
   safeTokenHashEqual,
+  scopedCursorScope,
   stableIdempotency,
   uuidv7,
+  validateDeliveryCursorPosition,
+  validateDeliveryPolicy,
+  validateEventCursorPosition,
+  validateLeasedDeliveryPolicy,
   validateMessageDraft,
   validatePrincipal,
-  validateRetryPolicy,
+  validateProject,
   validateUuid
 };
 //# sourceMappingURL=bridge.js.map