@devlab.group/agent-commerce 2.1.0 → 2.2.0

package/dist/cli/chunk-SS3QFF5N.js

@@ -0,0 +1,614 @@
+import { ACP_CHECKOUT_OPERATIONS, ACP_SPEC_VERSION } from './chunk-2ZZOGI5I.js';
+import { openSqliteDatabase } from './chunk-3MGAJ5FX.js';
+import { PACKAGE_VERSION } from './chunk-FRMLWGSS.js';
+import { NOOP_LOGGER, systemClock, toCommerceError, CommerceError } from './chunk-QQ3WY5L3.js';
+import { randomUUID } from 'crypto';
+import { accessSync, constants } from 'fs';
+
+// src/storage/receipts/redact.ts
+var SECRET_KEY_PATTERN = /private[-_ ]?key|secret|password|mnemonic|seed[-_ ]?phrase|api[-_ ]?key|authoriz(e|ation)|^auth$|auth[-_]?header|payment[-_ ]?proof|^proof$|x-payment|signature|signed[-_ ]?message|token|bearer|credential|cookie|session|jwt/i;
+var REDACTED = "[REDACTED]";
+function isSecretKey(key) {
+  return SECRET_KEY_PATTERN.test(key);
+}
+function redact(value) {
+  return redactValue(value);
+}
+function redactValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactValue);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = isSecretKey(key) ? REDACTED : redactValue(inner);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/storage/receipts/rows.ts
+function receiptToRow(receipt) {
+  return {
+    id: receipt.id,
+    request_id: receipt.requestId,
+    resource_id: receipt.resourceId,
+    payment_json: receipt.payment !== void 0 ? JSON.stringify(redact(receipt.payment)) : null,
+    delivered_at: receipt.deliveredAt,
+    backend_status: receipt.backendStatus,
+    duration_ms: receipt.durationMs ?? null,
+    protocol: receipt.protocol ?? null,
+    metadata_json: receipt.metadata !== void 0 ? JSON.stringify(redact(receipt.metadata)) : null,
+    authorization_json: receipt.authorization !== void 0 ? JSON.stringify(redact(receipt.authorization)) : null
+  };
+}
+function rowToReceipt(row) {
+  const payment = row.payment_json !== null ? JSON.parse(row.payment_json) : void 0;
+  const metadata = row.metadata_json !== null ? JSON.parse(row.metadata_json) : void 0;
+  const authorization = row.authorization_json !== null ? JSON.parse(row.authorization_json) : void 0;
+  return {
+    id: row.id,
+    requestId: row.request_id,
+    resourceId: row.resource_id,
+    deliveredAt: row.delivered_at,
+    backendStatus: row.backend_status,
+    ...payment !== void 0 ? { payment } : {},
+    ...row.duration_ms !== null ? { durationMs: row.duration_ms } : {},
+    ...row.protocol !== null ? { protocol: row.protocol } : {},
+    ...metadata !== void 0 ? { metadata } : {},
+    ...authorization !== void 0 ? { authorization } : {}
+  };
+}
+function eventToRow(event) {
+  return {
+    id: event.id,
+    type: event.type,
+    request_id: event.requestId,
+    resource_id: event.resourceId ?? null,
+    at: event.at,
+    adapter: event.adapter ?? null,
+    payment_provider: event.paymentProvider ?? null,
+    duration_ms: event.durationMs ?? null,
+    status: event.status ?? null,
+    data_json: event.data !== void 0 ? JSON.stringify(redact(event.data)) : null
+  };
+}
+function rowToEvent(row) {
+  const data = row.data_json !== null ? JSON.parse(row.data_json) : void 0;
+  return {
+    id: row.id,
+    type: row.type,
+    requestId: row.request_id,
+    at: row.at,
+    ...row.resource_id !== null ? { resourceId: row.resource_id } : {},
+    ...row.adapter !== null ? { adapter: row.adapter } : {},
+    ...row.payment_provider !== null ? { paymentProvider: row.payment_provider } : {},
+    ...row.duration_ms !== null ? { durationMs: row.duration_ms } : {},
+    ...row.status !== null ? { status: row.status } : {},
+    ...data !== void 0 ? { data } : {}
+  };
+}
+function rowToPaymentAttempt(row) {
+  return {
+    id: row.id,
+    requestId: row.request_id,
+    resourceId: row.resource_id,
+    provider: row.provider,
+    replayKey: row.replay_key,
+    status: row.status,
+    amount: row.amount,
+    currency: row.currency,
+    ...row.payer !== null ? { payer: row.payer } : {},
+    ...row.payee !== null ? { payee: row.payee } : {},
+    ...row.external_reference !== null ? { externalReference: row.external_reference } : {},
+    ...row.rejection_reason !== null ? { rejectionReason: row.rejection_reason } : {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/storage/receipts/schema.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    up(db) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS receipts (
+          seq             INTEGER PRIMARY KEY AUTOINCREMENT,
+          id              TEXT NOT NULL UNIQUE,
+          request_id      TEXT NOT NULL,
+          resource_id     TEXT NOT NULL,
+          payment_json    TEXT,
+          delivered_at    TEXT NOT NULL,
+          backend_status  INTEGER NOT NULL,
+          duration_ms     INTEGER,
+          protocol        TEXT,
+          metadata_json   TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_receipts_request_id ON receipts(request_id);
+        CREATE INDEX IF NOT EXISTS idx_receipts_delivered_at ON receipts(delivered_at);
+
+        CREATE TABLE IF NOT EXISTS events (
+          seq               INTEGER PRIMARY KEY AUTOINCREMENT,
+          id                TEXT NOT NULL UNIQUE,
+          type              TEXT NOT NULL,
+          request_id        TEXT NOT NULL,
+          resource_id       TEXT,
+          at                TEXT NOT NULL,
+          adapter           TEXT,
+          payment_provider  TEXT,
+          duration_ms       INTEGER,
+          status            TEXT,
+          data_json         TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_events_request_id ON events(request_id);
+        CREATE INDEX IF NOT EXISTS idx_events_at ON events(at);
+
+        CREATE TABLE IF NOT EXISTS payment_attempts (
+          seq                 INTEGER PRIMARY KEY AUTOINCREMENT,
+          id                  TEXT NOT NULL UNIQUE,
+          request_id          TEXT NOT NULL,
+          resource_id         TEXT NOT NULL,
+          provider             TEXT NOT NULL,
+          replay_key          TEXT NOT NULL UNIQUE,
+          status              TEXT NOT NULL,
+          amount              TEXT NOT NULL,
+          currency            TEXT NOT NULL,
+          payer               TEXT,
+          payee               TEXT,
+          external_reference  TEXT,
+          rejection_reason    TEXT,
+          created_at          TEXT NOT NULL,
+          updated_at          TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_payment_attempts_request_id ON payment_attempts(request_id);
+        CREATE INDEX IF NOT EXISTS idx_payment_attempts_created_at ON payment_attempts(created_at);
+      `);
+    }
+  },
+  {
+    version: 2,
+    up(db) {
+      db.exec(`ALTER TABLE receipts ADD COLUMN authorization_json TEXT;`);
+    }
+  },
+  {
+    version: 3,
+    up(db) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS payment_attempt_history (
+          seq                 INTEGER PRIMARY KEY AUTOINCREMENT,
+          id                  TEXT NOT NULL,
+          request_id          TEXT NOT NULL,
+          resource_id         TEXT NOT NULL,
+          provider            TEXT NOT NULL,
+          replay_key          TEXT NOT NULL,
+          status              TEXT NOT NULL,
+          amount              TEXT NOT NULL,
+          currency            TEXT NOT NULL,
+          payer               TEXT,
+          payee               TEXT,
+          external_reference  TEXT,
+          rejection_reason    TEXT,
+          created_at          TEXT NOT NULL,
+          updated_at          TEXT NOT NULL,
+          superseded_at       TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_payment_attempt_history_replay_key ON payment_attempt_history(replay_key);
+        CREATE INDEX IF NOT EXISTS idx_payment_attempt_history_request_id ON payment_attempt_history(request_id);
+      `);
+    }
+  }
+];
+var SCHEMA_VERSION = MIGRATIONS.at(-1)?.version ?? 0;
+function migrate(db) {
+  const current = db.pragma("user_version", { simple: true });
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= current) continue;
+    const apply = db.transaction(() => {
+      migration.up(db);
+      db.pragma(`user_version = ${migration.version}`);
+    });
+    apply();
+  }
+}
+
+// src/storage/receipts/store.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 500;
+function clampListLimit(limit) {
+  const base = limit !== void 0 && Number.isFinite(limit) ? limit : DEFAULT_LIST_LIMIT;
+  return Math.min(Math.max(Math.trunc(base), 1), MAX_LIST_LIMIT);
+}
+var defaultIds = {
+  next: (prefix) => prefix !== void 0 ? `${prefix}_${randomUUID()}` : randomUUID()
+};
+function isUniqueConstraintOn(err, column) {
+  return err instanceof Error && "code" in err && err.code === "SQLITE_CONSTRAINT_UNIQUE" && err.message.includes(column);
+}
+function createSqliteReceiptStore(options) {
+  const logger = options.logger ?? NOOP_LOGGER;
+  const clock = options.clock ?? systemClock;
+  const ids = options.ids ?? defaultIds;
+  const path = options.path;
+  const isFileBacked = path !== ":memory:";
+  const db = openSqliteDatabase({ path, label: "Receipt database", logger });
+  migrate(db);
+  const insertReceiptStmt = db.prepare(
+    `INSERT INTO receipts (id, request_id, resource_id, payment_json, delivered_at, backend_status, duration_ms, protocol, metadata_json, authorization_json)
+     VALUES (@id, @request_id, @resource_id, @payment_json, @delivered_at, @backend_status, @duration_ms, @protocol, @metadata_json, @authorization_json)`
+  );
+  const getReceiptStmt = db.prepare("SELECT * FROM receipts WHERE id = ?");
+  const listReceiptsStmt = db.prepare(
+    "SELECT * FROM receipts ORDER BY delivered_at DESC, seq DESC LIMIT ?"
+  );
+  const listReceiptsByRequestStmt = db.prepare(
+    "SELECT * FROM receipts WHERE request_id = ? ORDER BY delivered_at DESC, seq DESC LIMIT ?"
+  );
+  const countReceiptsStmt = db.prepare(
+    "SELECT COUNT(*) AS count FROM receipts"
+  );
+  const countUndeliveredReceiptsStmt = db.prepare(
+    "SELECT COUNT(*) AS count FROM receipts WHERE backend_status NOT BETWEEN 200 AND 299"
+  );
+  const insertEventStmt = db.prepare(
+    `INSERT INTO events (id, type, request_id, resource_id, at, adapter, payment_provider, duration_ms, status, data_json)
+     VALUES (@id, @type, @request_id, @resource_id, @at, @adapter, @payment_provider, @duration_ms, @status, @data_json)`
+  );
+  const listEventsStmt = db.prepare(
+    "SELECT * FROM events ORDER BY at DESC, seq DESC LIMIT ?"
+  );
+  const listEventsByRequestStmt = db.prepare(
+    "SELECT * FROM events WHERE request_id = ? ORDER BY at DESC, seq DESC LIMIT ?"
+  );
+  const insertPaymentAttemptStmt = db.prepare(
+    `INSERT INTO payment_attempts (id, request_id, resource_id, provider, replay_key, status, amount, currency, payer, payee, external_reference, rejection_reason, created_at, updated_at)
+     VALUES (@id, @request_id, @resource_id, @provider, @replay_key, @status, @amount, @currency, @payer, @payee, @external_reference, @rejection_reason, @created_at, @updated_at)
+     RETURNING *`
+  );
+  const archiveRejectedAttemptStmt = db.prepare(
+    `INSERT INTO payment_attempt_history (id, request_id, resource_id, provider, replay_key, status, amount, currency, payer, payee, external_reference, rejection_reason, created_at, updated_at, superseded_at)
+     SELECT id, request_id, resource_id, provider, replay_key, status, amount, currency, payer, payee, external_reference, rejection_reason, created_at, updated_at, @created_at
+     FROM payment_attempts
+     WHERE replay_key = @replay_key AND provider = @provider AND status = 'rejected'`
+  );
+  const reclaimPaymentAttemptStmt = db.prepare(
+    `UPDATE payment_attempts SET id = @id, request_id = @request_id, resource_id = @resource_id,
+       status = 'reserved', amount = @amount, currency = @currency,
+       payer = @payer, payee = @payee, external_reference = NULL, rejection_reason = NULL,
+       created_at = @created_at, updated_at = @updated_at
+     WHERE replay_key = @replay_key AND provider = @provider AND status = 'rejected'
+     RETURNING *`
+  );
+  const updatePaymentAttemptStmt = db.prepare(
+    `UPDATE payment_attempts SET status = @status,
+       external_reference = COALESCE(@external_reference, external_reference),
+       rejection_reason = COALESCE(@rejection_reason, rejection_reason),
+       updated_at = @updated_at
+     WHERE replay_key = @replay_key`
+  );
+  const listPaymentAttemptsStmt = db.prepare(
+    "SELECT * FROM payment_attempts ORDER BY created_at DESC, seq DESC LIMIT ?"
+  );
+  const listPaymentAttemptsByRequestStmt = db.prepare(
+    "SELECT * FROM payment_attempts WHERE request_id = ? ORDER BY created_at DESC, seq DESC LIMIT ?"
+  );
+  const paymentAttemptStatusStmt = db.prepare(
+    "SELECT status FROM payment_attempts WHERE replay_key = ?"
+  );
+  const reclaimRejectedAttempt = db.transaction(
+    (params) => {
+      archiveRejectedAttemptStmt.run(params);
+      return reclaimPaymentAttemptStmt.get(params);
+    }
+  );
+  let closed = false;
+  const descriptor = {
+    name: "sqlite-receipt-store",
+    kind: "storage",
+    implementationVersion: PACKAGE_VERSION,
+    supportedSpec: `sqlite-schema-v${SCHEMA_VERSION}`,
+    capabilities: ["receipts", "events", "payment-attempts"],
+    status: "stable"
+  };
+  const store = {
+    async init() {
+      const version = db.pragma("user_version", { simple: true });
+      if (version !== SCHEMA_VERSION) {
+        throw new CommerceError(
+          "STORAGE_ERROR",
+          `Receipt store schema version mismatch (found ${version}, expected ${SCHEMA_VERSION})`
+        );
+      }
+    },
+    async appendEvent(event) {
+      try {
+        insertEventStmt.run(eventToRow(event));
+      } catch (err) {
+        logger.warn(
+          {
+            err: err instanceof Error ? err.message : String(err),
+            eventId: event.id,
+            requestId: event.requestId
+          },
+          "receipt-store: failed to persist commerce event"
+        );
+      }
+    },
+    async reservePaymentAttempt(reservation) {
+      const now = clock.nowIso();
+      const params = {
+        id: ids.next("attempt"),
+        request_id: reservation.requestId,
+        resource_id: reservation.resourceId,
+        provider: reservation.provider,
+        replay_key: reservation.replayKey,
+        amount: reservation.amount,
+        currency: reservation.currency,
+        payer: reservation.payer ?? null,
+        payee: reservation.payee ?? null,
+        created_at: now,
+        updated_at: now
+      };
+      let row;
+      try {
+        row = (reservation.reclaimRejected === true ? reclaimRejectedAttempt.immediate(params) : void 0) ?? // RETURNING on a successful insert always yields the inserted row
+        insertPaymentAttemptStmt.get({
+          ...params,
+          status: "reserved",
+          external_reference: null,
+          rejection_reason: null
+        });
+      } catch (err) {
+        if (isUniqueConstraintOn(err, "payment_attempts.replay_key")) {
+          const existing = paymentAttemptStatusStmt.get(reservation.replayKey);
+          throw new CommerceError(
+            "PAYMENT_REPLAYED",
+            `Payment authorization has already been used (replayKey=${reservation.replayKey})`,
+            {
+              requestId: reservation.requestId,
+              resourceId: reservation.resourceId,
+              ...existing !== void 0 ? { details: { attemptStatus: existing.status } } : {}
+            }
+          );
+        }
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to reserve payment attempt");
+      }
+      return rowToPaymentAttempt(row);
+    },
+    async updatePaymentAttempt(update) {
+      try {
+        const result = updatePaymentAttemptStmt.run({
+          replay_key: update.replayKey,
+          status: update.status,
+          external_reference: update.externalReference ?? null,
+          rejection_reason: update.rejectionReason ?? null,
+          updated_at: clock.nowIso()
+        });
+        if (result.changes === 0) {
+          throw new CommerceError(
+            "STORAGE_ERROR",
+            `No payment attempt found for replayKey=${update.replayKey}`
+          );
+        }
+      } catch (err) {
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to update payment attempt");
+      }
+    },
+    async saveReceipt(receipt) {
+      try {
+        insertReceiptStmt.run(receiptToRow(receipt));
+      } catch (err) {
+        throw toCommerceError(err, "STORAGE_ERROR", "Failed to save receipt");
+      }
+    },
+    async getReceipt(id) {
+      const row = getReceiptStmt.get(id);
+      return row !== void 0 ? rowToReceipt(row) : void 0;
+    },
+    async listReceipts(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listReceiptsByRequestStmt.all(listOptions.requestId, limit) : listReceiptsStmt.all(limit);
+      return rows.map(rowToReceipt);
+    },
+    // Exact total, not bounded by the listReceipts clamp (see ReceiptStore.countReceipts)
+    async countReceipts() {
+      return countReceiptsStmt.get()?.count ?? 0;
+    },
+    // Exact count of non-2xx receipts (see ReceiptStore.countUndeliveredReceipts)
+    async countUndeliveredReceipts() {
+      return countUndeliveredReceiptsStmt.get()?.count ?? 0;
+    },
+    async listEvents(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listEventsByRequestStmt.all(listOptions.requestId, limit) : listEventsStmt.all(limit);
+      return rows.map(rowToEvent);
+    },
+    async listPaymentAttempts(listOptions = {}) {
+      const limit = clampListLimit(listOptions.limit);
+      const rows = listOptions.requestId !== void 0 ? listPaymentAttemptsByRequestStmt.all(listOptions.requestId, limit) : listPaymentAttemptsStmt.all(limit);
+      return rows.map(rowToPaymentAttempt);
+    },
+    descriptor,
+    async health() {
+      const startedAt = clock.monotonicMs();
+      if (closed) {
+        return { status: "fail", detail: "store-unavailable", checkedAt: clock.nowIso() };
+      }
+      if (isFileBacked) {
+        try {
+          accessSync(path, constants.W_OK);
+        } catch (err) {
+          logger.warn(
+            { err: err instanceof Error ? err.message : String(err) },
+            "receipt-store: health check failed (store not writable)"
+          );
+          return {
+            status: "fail",
+            detail: "store-unwritable",
+            checkedAt: clock.nowIso(),
+            durationMs: clock.monotonicMs() - startedAt
+          };
+        }
+      }
+      try {
+        const version = db.pragma("user_version", { simple: true });
+        if (version !== SCHEMA_VERSION) {
+          logger.warn(
+            { found: version, expected: SCHEMA_VERSION },
+            "receipt-store: health check failed (schema version mismatch)"
+          );
+          return {
+            status: "fail",
+            detail: "store-schema-mismatch",
+            checkedAt: clock.nowIso(),
+            durationMs: clock.monotonicMs() - startedAt
+          };
+        }
+        return {
+          status: "pass",
+          detail: `sqlite schema v${SCHEMA_VERSION} writable`,
+          checkedAt: clock.nowIso(),
+          durationMs: clock.monotonicMs() - startedAt
+        };
+      } catch (err) {
+        logger.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          "receipt-store: health check failed (store unavailable)"
+        );
+        return {
+          status: "fail",
+          detail: "store-unavailable",
+          checkedAt: clock.nowIso(),
+          durationMs: clock.monotonicMs() - startedAt
+        };
+      }
+    },
+    async close() {
+      if (!closed) {
+        closed = true;
+        db.close();
+      }
+    }
+  };
+  return store;
+}
+
+// src/protocols/a2a/constants.ts
+var A2A_SPEC_VERSION = "1.0.1";
+var A2A_PROTOCOL_VERSION = "1.0";
+var A2A_PROTOCOL_BINDING = "JSONRPC";
+var A2A_AGENT_CARD_PATH = "/.well-known/agent-card.json";
+var A2A_DEFAULT_MOUNT_PATH = "/a2a";
+var A2A_JSON_MEDIA_TYPE = "application/json";
+var A2A_DEFAULT_AGENT_NAME = "agent-commerce";
+var A2A_VERSION_HEADER = "a2a-version";
+var A2A_METHOD_SEND_MESSAGE = "SendMessage";
+var A2A_PUSH_CONFIG_METHODS = [
+  "CreateTaskPushNotificationConfig",
+  "GetTaskPushNotificationConfig",
+  "ListTaskPushNotificationConfigs",
+  "DeleteTaskPushNotificationConfig"
+];
+var A2A_UNSUPPORTED_METHODS = [
+  "SendStreamingMessage",
+  "GetTask",
+  "ListTasks",
+  "CancelTask",
+  "SubscribeToTask",
+  ...A2A_PUSH_CONFIG_METHODS,
+  "GetExtendedAgentCard"
+];
+var A2A_TASK_LOOKUP_METHODS = ["GetTask", "CancelTask"];
+var A2A_TASK_STATE_COMPLETED = "TASK_STATE_COMPLETED";
+var A2A_TASK_STATE_FAILED = "TASK_STATE_FAILED";
+var A2A_TASK_STATE_INPUT_REQUIRED = "TASK_STATE_INPUT_REQUIRED";
+var A2A_EXTENSIONS_HEADER = "a2a-extensions";
+
+// src/protocols/a2a/descriptor.ts
+var A2A_CAPABILITIES = [
+  "agent-card",
+  "jsonrpc",
+  "SendMessage",
+  // The x402 A2A transport, opt-in per request
+  "x402-extension"
+];
+var A2A_UNSUPPORTED = [
+  // Methods, as the protocol names them; the transport refuses the same list
+  ...A2A_UNSUPPORTED_METHODS,
+  // Transports other than the one binding served
+  "HTTP+JSON/REST binding",
+  "gRPC binding",
+  // Behaviors
+  "SSE",
+  "long-running task persistence",
+  "task resumption other than an x402 extension payment",
+  "push notifications",
+  "multi-turn conversational continuation",
+  "authenticated extended agent cards",
+  "A2A authentication schemes",
+  "artifact types beyond Agent Commerce outcome data",
+  // Pending x402 payments live in process memory
+  "x402 extension payments across gateway restarts or instances"
+];
+function buildDescriptor(implementationVersion) {
+  return {
+    name: "a2a",
+    kind: "protocol",
+    implementationVersion,
+    supportedSpec: A2A_SPEC_VERSION,
+    capabilities: A2A_CAPABILITIES,
+    status: "experimental",
+    unsupported: A2A_UNSUPPORTED
+  };
+}
+
+// src/protocols/acp/descriptor.ts
+var ACP_CAPABILITIES = [
+  "rest transport",
+  "well-known discovery",
+  "bearer authentication",
+  "API-Version enforcement",
+  // Forwarded as received: the gateway verifies neither signature header
+  "request header forwarding to the merchant",
+  "checkout service",
+  ...ACP_CHECKOUT_OPERATIONS
+];
+var ACP_UNSUPPORTED = [
+  // Services this seller does not implement, named as ACP names them. The
+  // discovery document advertises `checkout` alone, and these are the reason.
+  "carts service",
+  "feed service",
+  "standalone orders service",
+  "delegate_payment",
+  "delegate_authentication",
+  // Bindings and delivery directions
+  "ACP MCP transport binding",
+  "webhooks",
+  "outbound merchant-to-agent delivery",
+  "ACP client role",
+  // Request authentication beyond the bearer token
+  "Signature header verification",
+  "Timestamp replay-window verification",
+  // Extensions, versioning and payment handlers
+  "discount extension",
+  "general ACP extension framework",
+  "multiple ACP API versions",
+  "seller-backed payment handler integration"
+];
+function buildDescriptor2(implementationVersion) {
+  return {
+    name: "acp",
+    kind: "protocol",
+    implementationVersion,
+    supportedSpec: ACP_SPEC_VERSION,
+    capabilities: ACP_CAPABILITIES,
+    status: "experimental",
+    unsupported: ACP_UNSUPPORTED
+  };
+}
+
+export { A2A_AGENT_CARD_PATH, A2A_DEFAULT_AGENT_NAME, A2A_DEFAULT_MOUNT_PATH, A2A_EXTENSIONS_HEADER, A2A_JSON_MEDIA_TYPE, A2A_METHOD_SEND_MESSAGE, A2A_PROTOCOL_BINDING, A2A_PROTOCOL_VERSION, A2A_PUSH_CONFIG_METHODS, A2A_SPEC_VERSION, A2A_TASK_LOOKUP_METHODS, A2A_TASK_STATE_COMPLETED, A2A_TASK_STATE_FAILED, A2A_TASK_STATE_INPUT_REQUIRED, A2A_UNSUPPORTED, A2A_UNSUPPORTED_METHODS, A2A_VERSION_HEADER, ACP_UNSUPPORTED, buildDescriptor, buildDescriptor2, createSqliteReceiptStore };
+//# sourceMappingURL=chunk-SS3QFF5N.js.map
+//# sourceMappingURL=chunk-SS3QFF5N.js.map