@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/chunk-GADH244D.js

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+
+// src/contracts/registry.ts
+import Type from "@sinclair/typebox";
+import { Check, Errors } from "@sinclair/typebox/value";
+var PROTOCOL_VERSION = "2.1";
+var LEGACY_PROTOCOL_VERSION = "2.0";
+var SUPPORTED_PROTOCOL_VERSIONS = [LEGACY_PROTOCOL_VERSION, PROTOCOL_VERSION];
+var SUPPORTED_PROTOCOL_RANGE = SUPPORTED_PROTOCOL_VERSIONS.join(",");
+var PROTOCOL_HEADER = "x-agent-bridge-protocol-version";
+var SUPPORTED_PROTOCOL_HEADER = "x-agent-bridge-supported-protocol-versions";
+var SCOPE_ENFORCEMENT = true;
+var StringArray = Type.Array(Type.String());
+var Empty = Type.Object({}, { additionalProperties: false });
+var OptionalString = () => Type.Optional(Type.String());
+var OptionalNumber = (options = {}) => Type.Optional(Type.Number(options));
+var OptionalBoolean = () => Type.Optional(Type.Boolean());
+var NullableString = () => Type.Union([Type.String(), Type.Null()]);
+var NullableNumber = () => Type.Union([Type.Number(), Type.Null()]);
+var UUID_V7_PATTERN = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-7[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";
+var ErrorIssueSchema = Type.Object({
+  path: Type.String(),
+  message: Type.String()
+}, { additionalProperties: true });
+var ErrorEnvelopeSchema = Type.Object({
+  error: Type.Object({
+    code: Type.String(),
+    requestId: Type.String(),
+    message: OptionalString(),
+    operation: OptionalString(),
+    issues: Type.Optional(Type.Array(ErrorIssueSchema)),
+    details: Type.Optional(Type.Any()),
+    supportedProtocolVersions: Type.Optional(StringArray)
+  }, { additionalProperties: true })
+}, { additionalProperties: true });
+var DeliveryPolicySchema = Type.Union([
+  Type.Object({ mode: Type.Literal("mailbox") }, { additionalProperties: false }),
+  Type.Object({
+    mode: Type.Literal("leased"),
+    maxAttempts: Type.Number(),
+    retryBaseDelayMs: Type.Number(),
+    retryMaxDelayMs: Type.Number(),
+    retryJitterRatio: Type.Number(),
+    notBefore: OptionalString()
+  }, { additionalProperties: false })
+]);
+var DeliveryPolicyInputSchema = Type.Object({
+  mode: Type.Optional(Type.Enum(["mailbox", "leased"])),
+  maxAttempts: OptionalNumber(),
+  retryBaseDelayMs: OptionalNumber(),
+  retryMaxDelayMs: OptionalNumber(),
+  retryJitterRatio: OptionalNumber(),
+  notBefore: OptionalString()
+}, { additionalProperties: false });
+var MessageDraftSchema = Type.Object({
+  id: Type.Optional(Type.String({ pattern: UUID_V7_PATTERN })),
+  source: OptionalString(),
+  project: OptionalString(),
+  type: Type.String(),
+  content: Type.String(),
+  contentType: OptionalString(),
+  data: Type.Optional(Type.Any()),
+  targets: Type.Optional(StringArray),
+  threadId: OptionalString(),
+  replyToId: OptionalString(),
+  correlationId: OptionalString(),
+  causationId: OptionalString(),
+  priority: Type.Optional(Type.Enum(["info", "high", "urgent"])),
+  expiresAt: OptionalString(),
+  idempotencyKey: OptionalString(),
+  atribReceiptId: OptionalString(),
+  informedBy: Type.Optional(StringArray),
+  metadata: Type.Optional(Type.Any()),
+  deliveryPolicy: Type.Optional(DeliveryPolicyInputSchema)
+}, { additionalProperties: false });
+var LegacyMessageDraftSchema = Type.Object({
+  id: OptionalString(),
+  source: OptionalString(),
+  type: Type.String(),
+  content: Type.String(),
+  contentType: OptionalString(),
+  data: Type.Optional(Type.Any()),
+  targets: Type.Optional(StringArray),
+  threadId: OptionalString(),
+  replyToId: OptionalString(),
+  correlationId: OptionalString(),
+  causationId: OptionalString(),
+  priority: Type.Optional(Type.Enum(["info", "high", "urgent"])),
+  expiresAt: OptionalString(),
+  idempotencyKey: OptionalString(),
+  atribReceiptId: OptionalString(),
+  informedBy: Type.Optional(StringArray),
+  metadata: Type.Optional(Type.Any())
+}, { additionalProperties: false });
+var MessageSchema = Type.Object({
+  id: Type.String(),
+  workspace: Type.String(),
+  project: OptionalString(),
+  source: Type.String(),
+  type: Type.String(),
+  content: Type.String(),
+  contentType: Type.String(),
+  sequence: Type.String(),
+  createdAt: Type.String(),
+  data: Type.Optional(Type.Any()),
+  targets: StringArray,
+  threadId: OptionalString(),
+  replyToId: OptionalString(),
+  correlationId: OptionalString(),
+  causationId: OptionalString(),
+  priority: Type.Enum(["info", "high", "urgent"]),
+  expiresAt: OptionalString(),
+  idempotencyKey: OptionalString(),
+  atribReceiptId: OptionalString(),
+  informedBy: Type.Optional(StringArray),
+  metadata: Type.Optional(Type.Any()),
+  deliveryPolicy: DeliveryPolicySchema
+}, { additionalProperties: true });
+var LegacyMessageSchema = Type.Object({
+  id: Type.String(),
+  workspace: Type.String(),
+  source: Type.String(),
+  type: Type.String(),
+  content: Type.String(),
+  contentType: Type.String(),
+  sequence: Type.String(),
+  createdAt: Type.String(),
+  data: Type.Optional(Type.Any()),
+  targets: StringArray,
+  threadId: OptionalString(),
+  replyToId: OptionalString(),
+  correlationId: OptionalString(),
+  causationId: OptionalString(),
+  priority: Type.Enum(["info", "high", "urgent"]),
+  expiresAt: OptionalString(),
+  idempotencyKey: OptionalString(),
+  atribReceiptId: OptionalString(),
+  informedBy: Type.Optional(StringArray),
+  metadata: Type.Optional(Type.Any())
+}, { additionalProperties: true });
+var DeliveryStateSchema = Type.Enum(["pending", "claimed", "acked", "retrying", "dead", "cancelled"]);
+var DeliveryActionSchema = Type.Enum(["created", "claim", "ack", "nack_retry", "nack_dead", "lease_expired", "attempts_exhausted", "message_expired", "cancel", "requeue"]);
+var DeliverySchema = Type.Object({
+  id: Type.String(),
+  messageId: Type.String(),
+  workspace: Type.String(),
+  recipient: Type.String(),
+  state: DeliveryStateSchema,
+  attempt: Type.Number(),
+  cycleAttempt: Type.Number(),
+  requeueCount: Type.Number(),
+  createdAt: Type.String(),
+  priorityRank: Type.Number(),
+  availableAt: Type.String(),
+  leaseToken: OptionalString(),
+  leaseOwner: OptionalString(),
+  leaseExpiresAt: OptionalString(),
+  lastError: OptionalString(),
+  lastActor: OptionalString(),
+  lastAction: DeliveryActionSchema
+}, { additionalProperties: true });
+var LegacyDeliverySchema = Type.Object({
+  id: Type.String(),
+  messageId: Type.String(),
+  workspace: Type.String(),
+  recipient: Type.String(),
+  state: Type.Enum(["pending", "claimed", "acked", "retrying", "dead"]),
+  attempt: Type.Number(),
+  availableAt: Type.String(),
+  leaseToken: OptionalString(),
+  leaseOwner: OptionalString(),
+  leaseExpiresAt: OptionalString(),
+  lastError: OptionalString()
+}, { additionalProperties: true });
+var DeliveryEventSchema = Type.Object({
+  sequence: Type.String(),
+  deliveryId: Type.String(),
+  messageId: Type.String(),
+  workspace: Type.String(),
+  recipient: Type.String(),
+  fromState: Type.Optional(DeliveryStateSchema),
+  toState: DeliveryStateSchema,
+  attempt: Type.Number(),
+  cycleAttempt: Type.Number(),
+  requeueCount: Type.Number(),
+  leaseOwner: OptionalString(),
+  error: OptionalString(),
+  actor: Type.String(),
+  action: DeliveryActionSchema,
+  createdAt: Type.String()
+}, { additionalProperties: true });
+var PresenceSchema = Type.Object({
+  workspace: Type.String(),
+  agent: Type.String(),
+  instance: Type.String(),
+  runtimeType: OptionalString(),
+  capabilities: StringArray,
+  leaseExpiresAt: Type.String(),
+  lastSeenAt: Type.String()
+}, { additionalProperties: true });
+var DeliveryDiagnosticsProperties = {
+  schemaVersion: Type.Enum(["local-v2", "postgres-v2", "legacy-v1"]),
+  deliverySupported: Type.Boolean(),
+  pending: NullableNumber(),
+  claimed: NullableNumber(),
+  retrying: NullableNumber(),
+  dead: NullableNumber(),
+  cancelled: Type.Optional(NullableNumber()),
+  oldestAvailableAt: OptionalString(),
+  due: Type.Optional(NullableNumber()),
+  scheduled: Type.Optional(NullableNumber()),
+  expiredLeases: Type.Optional(NullableNumber()),
+  oldestDueAt: OptionalString(),
+  queueLagMs: Type.Optional(NullableNumber()),
+  principal: Type.Optional(Type.Object({ workspace: Type.String(), agent: Type.String() }, { additionalProperties: true }))
+};
+var DiagnosticsSchema = Type.Object(DeliveryDiagnosticsProperties, { additionalProperties: true });
+var ClientDiagnosticsSchema = Type.Object({
+  ...DeliveryDiagnosticsProperties,
+  remoteReachable: Type.Optional(Type.Union([Type.Boolean(), Type.Null()])),
+  outboxPending: OptionalNumber(),
+  outboxBlocked: OptionalNumber(),
+  cachedMessages: OptionalNumber(),
+  lastSyncAt: OptionalString(),
+  lastSyncError: OptionalString(),
+  outboxDue: OptionalNumber(),
+  outboxScheduled: OptionalNumber(),
+  outboxLeased: OptionalNumber(),
+  outboxOldestDueAt: OptionalString(),
+  outboxQueueLagMs: OptionalNumber(),
+  outboxOldestBlockedAt: OptionalString(),
+  outboxBlockedAgeMs: Type.Optional(NullableNumber()),
+  outboxBlockedMaxAttempts: OptionalNumber(),
+  outboxBlockedLastError: OptionalString(),
+  outboxNextRetryAt: OptionalString(),
+  lastOutboundSyncAt: OptionalString(),
+  lastInboundSyncAt: OptionalString(),
+  lastSyncAttemptAt: OptionalString(),
+  syncLoopState: Type.Optional(Type.Enum(["disabled", "idle", "running", "backoff", "stopped", "failed"])),
+  syncLoopError: OptionalString(),
+  remoteError: OptionalString()
+}, { additionalProperties: true });
+var ClientStatusSchema = Type.Object({
+  status: Type.Enum(["ok", "unknown", "degraded", "failed"]),
+  localHealthy: Type.Boolean(),
+  connected: Type.Boolean(),
+  remoteReachable: Type.Union([Type.Boolean(), Type.Null()]),
+  provider: Type.Enum(["local", "gateway", "legacy-supabase"]),
+  workspace: Type.String(),
+  agent: Type.String(),
+  instance: Type.Union([Type.String(), Type.Null()]),
+  schemaVersion: Type.Enum(["local-v2", "postgres-v2", "legacy-v1"]),
+  endpoint: Type.Union([Type.String(), Type.Null()]),
+  database: Type.Union([Type.String(), Type.Null()]),
+  cursorPath: Type.String(),
+  lastCursor: Type.Union([Type.String(), Type.Null()]),
+  queue: ClientDiagnosticsSchema,
+  checks: Type.Array(Type.Object({
+    name: Type.String(),
+    status: Type.Enum(["ok", "unknown", "degraded", "failed"]),
+    message: Type.String()
+  }, { additionalProperties: false }))
+}, { additionalProperties: true });
+var HistoryRequestSchema = Type.Object({
+  cursor: OptionalString(),
+  limit: OptionalNumber({ minimum: 1, maximum: 200 }),
+  types: Type.Optional(StringArray),
+  mailbox: Type.Optional(Type.Enum(["inbox", "sent", "all"])),
+  receiptState: Type.Optional(Type.Enum(["any", "unread", "read"])),
+  includeExpired: OptionalBoolean(),
+  source: OptionalString(),
+  project: OptionalString(),
+  since: OptionalString(),
+  unacknowledgedBy: OptionalString(),
+  threadId: OptionalString(),
+  latest: OptionalBoolean()
+}, { additionalProperties: false });
+var MessagePageSchema = Type.Object({
+  messages: Type.Array(MessageSchema),
+  cursor: OptionalString(),
+  source: Type.Optional(Type.Enum(["remote", "cache"])),
+  stale: OptionalBoolean(),
+  degraded: OptionalBoolean(),
+  acknowledgements: Type.Optional(Type.Enum(["authoritative", "unknown"])),
+  lastSyncedAt: OptionalString()
+}, { additionalProperties: true });
+var DeliveryPageSchema = Type.Object({ deliveries: Type.Array(DeliverySchema), cursor: OptionalString() }, { additionalProperties: true });
+var DeliveryEventPageSchema = Type.Object({ events: Type.Array(DeliveryEventSchema), cursor: OptionalString() }, { additionalProperties: true });
+var DeliveryIdSchema = Type.Object({ deliveryId: Type.String() }, { additionalProperties: false });
+var LeaseSchema = Type.Object({ deliveryId: Type.String(), leaseToken: Type.String() }, { additionalProperties: false });
+var RetryPolicySchema = Type.Object({
+  maxAttempts: OptionalNumber(),
+  baseDelayMs: OptionalNumber(),
+  maxDelayMs: OptionalNumber(),
+  jitterRatio: OptionalNumber()
+}, { additionalProperties: false });
+var NegativeAcknowledgeRequestSchema = Type.Object({
+  deliveryId: Type.String(),
+  leaseToken: Type.String(),
+  error: Type.String(),
+  disposition: Type.Optional(Type.Enum(["retry", "dead"])),
+  dead: OptionalBoolean(),
+  retryPolicy: Type.Optional(RetryPolicySchema)
+}, { additionalProperties: false });
+var LegacyNegativeAcknowledgeRequestSchema = Type.Object({
+  deliveryId: Type.String(),
+  leaseToken: Type.String(),
+  error: OptionalString(),
+  disposition: Type.Optional(Type.Enum(["retry", "dead"])),
+  dead: OptionalBoolean(),
+  retryPolicy: Type.Optional(RetryPolicySchema)
+}, { additionalProperties: false });
+var SyncResponseSchema = Type.Object({
+  online: Type.Boolean(),
+  pushed: Type.Number(),
+  deduplicated: Type.Number(),
+  pulled: Type.Number(),
+  pending: Type.Number(),
+  blocked: Type.Number(),
+  cached: Type.Number(),
+  cursor: Type.Optional(NullableString()),
+  lastSyncedAt: Type.Optional(NullableString()),
+  lastError: Type.Optional(NullableString()),
+  failureRetryable: OptionalBoolean()
+}, { additionalProperties: true });
+var ClaimResponseSchema = Type.Object({
+  delivery: Type.Union([DeliverySchema, Type.Null()]),
+  leaseToken: OptionalString()
+}, {
+  additionalProperties: true,
+  oneOf: [
+    { properties: { delivery: { type: "null" }, leaseToken: false }, required: ["delivery"] },
+    { properties: { delivery: DeliverySchema, leaseToken: { type: "string" } }, required: ["delivery", "leaseToken"] }
+  ]
+});
+var ALL_PROVIDERS = ["local", "gateway", "legacy-supabase"];
+var DELIVERY_PROVIDERS = ["local", "gateway"];
+var GATEWAY_PROVIDER = ["gateway"];
+var operation = (entry) => entry;
+var HistoryCliOptions = ["cursor", "limit", "type", "category", "mailbox", "receipt-state", "source", "project", "since", "unacked-by", "thread-id", "latest"];
+var LegacyGetRowSchema = Type.Object({
+  id: Type.Union([Type.String(), Type.Number()]),
+  source: Type.String(),
+  category: Type.String(),
+  content: Type.String(),
+  priority: Type.Enum(["info", "high", "urgent"]),
+  project: NullableString(),
+  metadata: Type.Any(),
+  created_at: Type.String()
+}, { additionalProperties: false });
+var ReceiptCliResponseSchema = Type.Object({
+  acknowledged: Type.Number(),
+  agent: Type.String()
+}, { additionalProperties: true });
+var operations = [
+  operation({ id: "capabilities", summary: "Discover operations available on the current surface.", request: Empty, response: Type.Object({ protocolVersion: Type.String(), currentProtocolVersion: Type.String(), selectedProtocolVersion: Type.String(), supportedProtocolVersions: StringArray, scopeEnforcement: Type.Boolean(), requestAuthority: Type.Boolean(), rowIsolation: Type.Boolean(), authorizationModel: Type.Enum(["scoped-credential", "credential-wide", "process-identity", "legacy-key"]), surface: Type.Enum(["mcp", "http", "cli"]), provider: Type.Enum(["local", "gateway", "legacy-supabase"]), operations: Type.Array(Type.Object({ id: Type.String(), summary: Type.String(), requiredScopes: StringArray, mcp: Type.Optional(Type.Any()), http: Type.Optional(Type.Any()), cli: Type.Optional(Type.Any()) }, { additionalProperties: true })) }, { additionalProperties: true }), scopes: [], providers: ALL_PROVIDERS, mcp: { name: "capabilities" }, http: { method: "GET", path: "/v2/capabilities" }, cli: { command: "capabilities", options: [] } }),
+  operation({ id: "status", summary: "Read gateway delivery diagnostics.", request: Empty, response: DiagnosticsSchema, scopes: ["status:read"], providers: ALL_PROVIDERS, http: { method: "GET", path: "/v2/status" } }),
+  operation({ id: "client_status", summary: "Read client connectivity and provider diagnostics.", request: Empty, response: ClientStatusSchema, scopes: ["status:read"], providers: ALL_PROVIDERS, cli: { command: "status", aliases: ["doctor"], options: [] } }),
+  operation({ id: "gateway_metrics", summary: "Read Prometheus gateway counters.", request: Empty, response: Type.String(), scopes: ["gateway:metrics"], providers: GATEWAY_PROVIDER, http: { method: "GET", path: "/metrics", responseContentType: "text/plain" } }),
+  operation({ id: "publish_message", summary: "Create an immutable Agent Bridge v2 message.", request: MessageDraftSchema, response: Type.Object({ created: Type.Boolean(), message: MessageSchema, disposition: Type.Optional(Type.Enum(["committed", "queued"])), authoritative: OptionalBoolean() }, { additionalProperties: true }), scopes: ["messages:write"], providers: ALL_PROVIDERS, mcp: { name: "send" }, http: { method: "POST", path: "/v2/messages", successStatus: 201 }, cli: { command: "send", aliases: ["post"], options: ["source", "project", "type", "kind", "category", "content", "content-type", "data", "payload", "payload-mime", "payload-ref", "payload-ciphertext", "target", "target-agent", "target-agents", "thread-id", "reply-to-id", "correlation-id", "causation-id", "priority", "expires-at", "idempotency-key", "atrib-receipt-id", "informed-by", "metadata", "delivery-mode", "delivery-policy", "delivery-max-attempts", "retry-base-ms", "retry-max-ms", "retry-jitter", "not-before", "message-id"] } }),
+  operation({ id: "history", summary: "Read visible messages after an opaque cursor.", request: HistoryRequestSchema, response: MessagePageSchema, scopes: ["messages:read"], providers: ALL_PROVIDERS, mcp: { name: "history" }, http: { method: "GET", path: "/v2/history", queryAliases: { unacknowledgedBy: ["unacked_by"] } }, cli: { command: "history", aliases: ["inbox", "sent"], options: HistoryCliOptions, variants: [{ command: "get", condition: { kind: "always" }, routesTo: "history", options: HistoryCliOptions, response: Type.Array(LegacyGetRowSchema) }] } }),
+  operation({ id: "record_receipt", summary: "Record caller-bound inbox read receipts.", request: Type.Object({ messageIds: Type.Array(Type.String(), { minItems: 1, maxItems: 200 }) }, { additionalProperties: false }), response: Type.Object({ recorded: Type.Number() }, { additionalProperties: true }), scopes: ["receipts:write"], providers: ALL_PROVIDERS, http: { method: "POST", path: "/v2/receipts" }, cli: { command: "acknowledge", aliases: ["receipt"], options: ["ids"], response: ReceiptCliResponseSchema, variants: [{ command: "ack", condition: { kind: "option-present", option: "ids" }, routesTo: "record_receipt", options: ["ids"], response: ReceiptCliResponseSchema }] } }),
+  operation({ id: "claim_delivery", summary: "Atomically claim the next targeted delivery.", request: Type.Object({ leaseMs: OptionalNumber(), maxAttempts: OptionalNumber() }, { additionalProperties: false }), response: ClaimResponseSchema, scopes: ["deliveries:claim"], providers: DELIVERY_PROVIDERS, mcp: { name: "claim" }, http: { method: "POST", path: "/v2/deliveries/claim" }, cli: { command: "claim", options: ["lease-ms", "max-attempts"], response: Type.Union([Type.Object({ delivery: DeliverySchema, leaseToken: Type.String() }, { additionalProperties: true }), Type.Null()]) } }),
+  operation({ id: "list_deliveries", summary: "List caller-visible deliveries.", request: Type.Object({ cursor: OptionalString(), limit: OptionalNumber(), role: Type.Optional(Type.Enum(["recipient", "publisher", "all"])), messageId: OptionalString(), recipient: OptionalString(), states: Type.Optional(Type.Array(DeliveryStateSchema)) }, { additionalProperties: false }), response: DeliveryPageSchema, scopes: ["deliveries:read"], providers: DELIVERY_PROVIDERS, mcp: { name: "list_deliveries" }, http: { method: "GET", path: "/v2/deliveries" }, cli: { command: "deliveries", aliases: ["dead-letters"], options: ["cursor", "limit", "role", "message-id", "recipient", "state"] } }),
+  operation({ id: "list_delivery_events", summary: "List the append-only event history for a delivery.", request: Type.Object({ deliveryId: Type.String(), cursor: OptionalString(), limit: OptionalNumber() }, { additionalProperties: false }), response: DeliveryEventPageSchema, scopes: ["deliveries:read"], providers: DELIVERY_PROVIDERS, mcp: { name: "list_delivery_events" }, http: { method: "GET", path: "/v2/deliveries/{deliveryId}/events" }, cli: { command: "delivery-events", options: ["delivery-id", "cursor", "limit"] } }),
+  operation({ id: "cancel_delivery", summary: "Cancel a delivery as its publisher.", request: DeliveryIdSchema, response: Type.Object({ delivery: Type.Union([DeliverySchema, Type.Null()]) }, { additionalProperties: true }), scopes: ["deliveries:manage"], providers: DELIVERY_PROVIDERS, mcp: { name: "cancel_delivery" }, http: { method: "POST", path: "/v2/deliveries/{deliveryId}/cancel" }, cli: { command: "cancel", options: ["delivery-id"], response: Type.Union([DeliverySchema, Type.Null()]) } }),
+  operation({ id: "requeue_delivery", summary: "Requeue a delivery as its publisher.", request: DeliveryIdSchema, response: Type.Object({ delivery: Type.Union([DeliverySchema, Type.Null()]) }, { additionalProperties: true }), scopes: ["deliveries:manage"], providers: DELIVERY_PROVIDERS, mcp: { name: "requeue_delivery" }, http: { method: "POST", path: "/v2/deliveries/{deliveryId}/requeue" }, cli: { command: "requeue", options: ["delivery-id"], response: Type.Union([DeliverySchema, Type.Null()]) } }),
+  operation({ id: "extend_delivery", summary: "Extend a claimed delivery lease.", request: Type.Object({ deliveryId: Type.String(), leaseToken: Type.String(), leaseMs: Type.Number() }, { additionalProperties: false }), response: Type.Object({ delivery: Type.Union([DeliverySchema, Type.Null()]) }, { additionalProperties: true }), scopes: ["deliveries:settle"], providers: DELIVERY_PROVIDERS, mcp: { name: "extend" }, http: { method: "POST", path: "/v2/deliveries/{deliveryId}/extend" }, cli: { command: "extend", options: ["delivery-id", "lease-token", "lease-ms"], response: Type.Union([DeliverySchema, Type.Null()]) } }),
+  operation({ id: "acknowledge_delivery", summary: "Settle a claimed delivery successfully.", request: LeaseSchema, response: Type.Object({ delivery: Type.Union([DeliverySchema, Type.Null()]) }, { additionalProperties: true }), scopes: ["deliveries:settle"], providers: DELIVERY_PROVIDERS, mcp: { name: "acknowledge" }, http: { method: "POST", path: "/v2/deliveries/{deliveryId}/ack" }, cli: { command: "ack", options: ["delivery-id", "lease-token"], response: Type.Union([DeliverySchema, Type.Null()]) } }),
+  operation({ id: "negative_acknowledge_delivery", summary: "Settle a claimed delivery for retry or dead letter.", request: NegativeAcknowledgeRequestSchema, response: Type.Object({ delivery: Type.Union([DeliverySchema, Type.Null()]) }, { additionalProperties: true }), scopes: ["deliveries:settle"], providers: DELIVERY_PROVIDERS, mcp: { name: "negative_acknowledge" }, http: { method: "POST", path: "/v2/deliveries/{deliveryId}/nack" }, cli: { command: "nack", options: ["delivery-id", "lease-token", "error", "disposition", "dead"], response: Type.Union([DeliverySchema, Type.Null()]) } }),
+  operation({ id: "heartbeat", summary: "Publish a leased runtime presence record.", request: Type.Object({ leaseMs: OptionalNumber({ minimum: 1e3, maximum: 9e5 }), runtimeType: OptionalString(), capabilities: Type.Optional(StringArray) }, { additionalProperties: false }), response: PresenceSchema, scopes: ["presence:write"], providers: DELIVERY_PROVIDERS, mcp: { name: "heartbeat" }, http: { method: "POST", path: "/v2/presence/heartbeat" }, cli: { command: "join", options: ["lease-ms", "runtime", "capability"] } }),
+  operation({ id: "presence", summary: "List active agent runtime instances.", request: Empty, response: Type.Object({ agents: Type.Array(PresenceSchema) }, { additionalProperties: true }), scopes: ["presence:read"], providers: DELIVERY_PROVIDERS, mcp: { name: "presence" }, http: { method: "GET", path: "/v2/presence" }, cli: { command: "presence", options: [] } }),
+  operation({ id: "sync", summary: "Replay a gateway outbox and refresh its inbox cache.", request: Type.Object({ maxPush: OptionalNumber(), maxPages: OptionalNumber() }, { additionalProperties: false }), response: SyncResponseSchema, scopes: ["messages:write", "messages:read"], providers: GATEWAY_PROVIDER, mcp: { name: "sync" }, cli: { command: "sync", options: ["max-push", "max-pages", "limit"] } })
+];
+var byId = new Map(operations.map((entry) => [entry.id, entry]));
+var ContractValidationError = class extends Error {
+  constructor(operation2, issues2) {
+    super(`Request does not match the ${operation2} schema`);
+    this.operation = operation2;
+    this.issues = issues2;
+    this.code = "invalid_input";
+    this.status = 400;
+  }
+};
+var ContractResponseError = class extends Error {
+  constructor(operation2, issues2) {
+    super(`Response does not match the ${operation2} schema`);
+    this.operation = operation2;
+    this.issues = issues2;
+    this.code = "protocol_mismatch";
+    this.status = 502;
+  }
+};
+function issues(schema, value) {
+  return [...Errors(schema, value)].map((entry) => ({ path: entry.instancePath || "/", message: entry.message }));
+}
+function operationContract(operationId) {
+  const contract = byId.get(operationId);
+  if (!contract) throw new Error(`Unknown operation contract: ${operationId}`);
+  return contract;
+}
+function validateRequest(operationId, value) {
+  const contract = operationContract(operationId);
+  if (!Check(contract.request, value)) throw new ContractValidationError(operationId, issues(contract.request, value));
+  return value;
+}
+function validateRequestForProtocol(operationId, value, protocolVersion) {
+  if (protocolVersion === LEGACY_PROTOCOL_VERSION) {
+    if (operationId === "publish_message") {
+      if (!Check(LegacyMessageDraftSchema, value)) throw new ContractValidationError(operationId, issues(LegacyMessageDraftSchema, value));
+      return value;
+    }
+    if (["list_deliveries", "list_delivery_events", "cancel_delivery", "requeue_delivery", "capabilities"].includes(operationId)) {
+      throw new ContractValidationError(operationId, [{ path: "/", message: `Operation is not supported by protocol ${LEGACY_PROTOCOL_VERSION}` }]);
+    }
+    if (operationId === "history" && value && typeof value === "object") {
+      const unsupported = ["mailbox", "receiptState", "project"].find((field) => value[field] !== void 0);
+      if (unsupported) throw new ContractValidationError(operationId, [{ path: `/${unsupported}`, message: `Field is not supported by protocol ${LEGACY_PROTOCOL_VERSION}` }]);
+    }
+  }
+  if (operationId !== "negative_acknowledge_delivery" || protocolVersion !== LEGACY_PROTOCOL_VERSION) {
+    return validateRequest(operationId, value);
+  }
+  if (!Check(LegacyNegativeAcknowledgeRequestSchema, value)) {
+    throw new ContractValidationError(operationId, issues(LegacyNegativeAcknowledgeRequestSchema, value));
+  }
+  return value;
+}
+function parseResponse(operationId, value) {
+  const contract = operationContract(operationId);
+  const serialized = JSON.stringify(value);
+  const wireValue = serialized === void 0 ? value : JSON.parse(serialized);
+  if (!Check(contract.response, wireValue)) throw new ContractResponseError(operationId, issues(contract.response, wireValue));
+  return wireValue;
+}
+function parseCliResponse(operationId, value, invocation) {
+  const contract = operationContract(operationId);
+  const optionNames = new Set(invocation?.optionNames ?? []);
+  const variant = contract.cli?.variants?.find((entry) => entry.command === invocation?.command && cliVariantMatches(entry, optionNames));
+  const schema = variant?.response ?? contract.cli?.response ?? contract.response;
+  const serialized = JSON.stringify(value);
+  const wireValue = serialized === void 0 ? value : JSON.parse(serialized);
+  if (!Check(schema, wireValue)) throw new ContractResponseError(operationId, issues(schema, wireValue));
+  return wireValue;
+}
+function availableOperations(context) {
+  return operations.filter((entry) => entry.providers.includes(context.provider) && Boolean(entry[context.surface]));
+}
+function cliVariantMatches(variant, optionNames) {
+  return variant.condition.kind === "always" || optionNames.has(variant.condition.option);
+}
+function operationForCli(command, provider, optionNames = []) {
+  const selectedOptions = new Set(optionNames);
+  return availableOperations({ surface: "cli", provider }).find((entry) => entry.cli?.command === command || entry.cli?.aliases?.includes(command) || entry.cli?.variants?.some((variant) => variant.command === command && cliVariantMatches(variant, selectedOptions)));
+}
+function capabilityDocument(context = { surface: "http", provider: "gateway" }) {
+  const selectedProtocolVersion = context.selectedProtocolVersion ?? PROTOCOL_VERSION;
+  return {
+    protocolVersion: selectedProtocolVersion,
+    currentProtocolVersion: PROTOCOL_VERSION,
+    selectedProtocolVersion,
+    supportedProtocolVersions: [...SUPPORTED_PROTOCOL_VERSIONS],
+    scopeEnforcement: context.provider === "gateway" ? SCOPE_ENFORCEMENT : false,
+    requestAuthority: context.provider === "gateway" && context.requestAuthority === true,
+    rowIsolation: context.provider === "gateway" && context.requestAuthority === true && context.rowIsolation === true,
+    authorizationModel: context.provider === "gateway" ? "scoped-credential" : context.provider === "local" ? "process-identity" : "legacy-key",
+    surface: context.surface,
+    provider: context.provider,
+    operations: availableOperations(context).map(({ request: _request, response, providers: _providers, scopes, cli, ...entry }) => ({
+      ...entry,
+      ...cli ? {
+        cli: {
+          command: cli.command,
+          ...cli.aliases ? { aliases: cli.aliases } : {},
+          options: cli.options,
+          outputSchema: cli.response ?? response,
+          ...cli.variants ? {
+            variants: cli.variants.map((variant) => ({
+              command: variant.command,
+              condition: variant.condition,
+              routesTo: variant.routesTo,
+              options: variant.options,
+              outputSchema: variant.response
+            }))
+          } : {}
+        }
+      } : {},
+      requiredScopes: [...scopes]
+    }))
+  };
+}
+function negotiateProtocolVersion(value) {
+  const requested = Array.isArray(value) ? value[0] : value;
+  if (requested === void 0 || requested.trim() === "") return LEGACY_PROTOCOL_VERSION;
+  if (SUPPORTED_PROTOCOL_VERSIONS.includes(requested.trim())) return requested.trim();
+  const error = new Error("Unsupported Agent Bridge protocol version");
+  error.status = 426;
+  error.code = "unsupported_protocol_version";
+  error.supported = SUPPORTED_PROTOCOL_RANGE;
+  throw error;
+}
+
+export {
+  PROTOCOL_VERSION,
+  LEGACY_PROTOCOL_VERSION,
+  SUPPORTED_PROTOCOL_VERSIONS,
+  PROTOCOL_HEADER,
+  SUPPORTED_PROTOCOL_HEADER,
+  SCOPE_ENFORCEMENT,
+  ErrorEnvelopeSchema,
+  LegacyMessageDraftSchema,
+  LegacyMessageSchema,
+  LegacyDeliverySchema,
+  operations,
+  ContractValidationError,
+  ContractResponseError,
+  operationContract,
+  validateRequest,
+  validateRequestForProtocol,
+  parseResponse,
+  parseCliResponse,
+  availableOperations,
+  operationForCli,
+  capabilityDocument,
+  negotiateProtocolVersion
+};
+//# sourceMappingURL=chunk-GADH244D.js.map