xytara 1.4.0 → 1.5.0

package/README.md

@@ -66,6 +66,15 @@ The economic artifact posture is also now more explicit across the default machi
 
 The same artifacts now also expose a normalized `default_path` object so the bundled economic center of gravity is visible as data instead of being inferred indirectly.
 
+The package and service also expose a default transaction center surface so the out-of-the-box path is easier to inspect directly:
+
+- default protocol lane: `mcp`
+- default payment protocol: `x402`
+- default settlement center: built-in chain settlement across the canonical bundled settlement modes
+- default treasury landing posture: account treasury destination by settlement mode
+
+That same default center is also reflected in direct helper paths for default MCP usage, so the default path can be previewed or quoted without repeating the full integration-selection story each time.
+
 ## Package Surface
 
 The SDK is broad, but it stays organized into a few repeatable families instead of one-off surfaces.
@@ -195,6 +204,14 @@ The promotion-readiness layer now makes that posture explicit as review data:
 
 That distinction matters as the registry grows.
 
+The promotion-action preview layer now builds on top of that readiness data without introducing mutation:
+
+- action previews stay read-only
+- current posture and resulting posture are both visible
+- requested action validity is explicit
+- blockers and blocker categories remain inspectable as data
+- the preview layer explains what would change before any future control-plane work exists
+
 There is also a small repo-local registry CLI for reviewer/operator use when working from a cloned `xytara` repository:
 
 - `node scripts/registry_cli.js validate-bundle --example protocol`
@@ -207,6 +224,9 @@ There is also a small repo-local registry CLI for reviewer/operator use when wor
 - `node scripts/registry_cli.js review-bundle-set`
 - `node scripts/registry_cli.js review-snapshot`
 - `node scripts/registry_cli.js promotion-readiness --integration partner.protocol.acme_mcp`
+- `node scripts/registry_cli.js promotion-action-preview --integration partner.protocol.acme_mcp --action complete_certification`
+- `node scripts/registry_cli.js promotion-action-set --integration partner.protocol.acme_mcp`
+- `node scripts/registry_cli.js promotion-action-set-summary --source third_party_example --bundled false`
 
 ## Integration Selection
 
@@ -340,6 +360,9 @@ Primary service routes:
 - `GET /v1/integrations/settlement-modes`
 - `GET /v1/integrations/promotion-readiness`
 - `GET /v1/integrations/:integration_id/promotion-readiness`
+- `GET /v1/integrations/promotion-actions`
+- `GET /v1/integrations/:integration_id/promotion-actions`
+- `POST /v1/integrations/promotion-actions/preview`
 - `POST /v1/integrations/review/submission-bundle`
 - `POST /v1/integrations/review/submission-bundle-set`
 - `POST /v1/integrations/review/registry-snapshot`

package/index.js

@@ -32,11 +32,15 @@ const {
   summarizeIntegrationRegistrySnapshotReview,
   summarizeIntegrationPromotionReadiness,
   summarizeIntegrationPromotionWorkflow,
-  summarizeIntegrationPromotionWorkflowList
+  summarizeIntegrationPromotionWorkflowList,
+  validatePromotionActionRequest,
+  summarizeIntegrationPromotionActionPreview,
+  summarizeIntegrationPromotionActionSet,
+  summarizeIntegrationPromotionActionSetList
 } = require("./integrations/registry");
 
 const COMMERCE_SDK_NAME = "xytara";
-const COMMERCE_SDK_VERSION = "1.4.0";
+const COMMERCE_SDK_VERSION = "1.5.0";
 const COMMERCE_API_VERSION = "v1";
 
 function createClient(options) {
@@ -77,5 +81,9 @@ module.exports = {
   summarizeIntegrationPromotionReadiness,
   summarizeIntegrationPromotionWorkflow,
   summarizeIntegrationPromotionWorkflowList,
+  validatePromotionActionRequest,
+  summarizeIntegrationPromotionActionPreview,
+  summarizeIntegrationPromotionActionSet,
+  summarizeIntegrationPromotionActionSetList,
   validateAdapterImplementation
 };

package/integrations/registry.js

@@ -681,6 +681,266 @@ function buildPromotionRecommendationSummary(readiness = {}) {
   };
 }
 
+const PROMOTION_ACTION_DEFINITIONS = {
+  register_integration: {
+    action: "register_integration",
+    title: "Register Integration",
+    stage: "registration",
+    description: "Move an integration into an explicit staged registration posture."
+  },
+  complete_certification: {
+    action: "complete_certification",
+    title: "Complete Certification",
+    stage: "certification",
+    description: "Mark the integration as certified for the current public contract."
+  },
+  promote_maturity: {
+    action: "promote_maturity",
+    title: "Promote Maturity",
+    stage: "maturity",
+    description: "Align integration maturity with production-default rollout posture."
+  },
+  enable_default_selection: {
+    action: "enable_default_selection",
+    title: "Enable Default Selection",
+    stage: "selection",
+    description: "Allow the integration to participate in default selection instead of explicit-only use."
+  },
+  bundle_for_default_rollout: {
+    action: "bundle_for_default_rollout",
+    title: "Bundle For Default Rollout",
+    stage: "rollout",
+    description: "Mark the integration as bundled for production-default rollout."
+  },
+  maintain_production_default: {
+    action: "maintain_production_default",
+    title: "Maintain Production Default",
+    stage: "steady_state",
+    description: "Confirm the integration already satisfies production-default posture."
+  }
+};
+
+function getPromotionActionDefinition(action) {
+  const lookup = String(action || "").trim();
+  return PROMOTION_ACTION_DEFINITIONS[lookup] || null;
+}
+
+function clonePromotionSubject(summary = {}) {
+  return {
+    registration: clone(summary.registration || {}),
+    certification_state: summary.certification_state || null,
+    integration_maturity: summary.integration_maturity || null
+  };
+}
+
+function simulatePromotionActionSubject(summary = {}, action) {
+  const subject = clonePromotionSubject(summary);
+  switch (action) {
+    case "register_integration":
+      subject.registration.registration_state = "staging_registered";
+      if (subject.registration.default_selection_enabled !== true) {
+        subject.registration.default_selection_enabled = false;
+      }
+      if (subject.registration.requires_explicit_selection !== false) {
+        subject.registration.requires_explicit_selection = true;
+      }
+      break;
+    case "complete_certification":
+      subject.certification_state = "certified";
+      break;
+    case "promote_maturity":
+      subject.integration_maturity = "production_default";
+      break;
+    case "enable_default_selection":
+      subject.registration.default_selection_enabled = true;
+      subject.registration.requires_explicit_selection = false;
+      break;
+    case "bundle_for_default_rollout":
+      subject.registration.bundled = true;
+      break;
+    case "maintain_production_default":
+      break;
+    default:
+      break;
+  }
+  return subject;
+}
+
+function buildPromotionActionResultingReadiness(summary = {}, subject = {}) {
+  return buildPromotionReadinessSummary({
+    registration: subject.registration,
+    certification: {
+      certification_state: subject.certification_state || summary.certification_state || null
+    },
+    integration: {
+      integration_maturity: subject.integration_maturity || summary.integration_maturity || null
+    }
+  });
+}
+
+function buildPromotionActionStateChanges(current = {}, simulated = {}) {
+  const changes = [];
+  const currentRegistration = current.registration || {};
+  const simulatedRegistration = simulated.registration || {};
+  const fieldPairs = [
+    ["registration.registration_state", currentRegistration.registration_state, simulatedRegistration.registration_state],
+    ["registration.default_selection_enabled", currentRegistration.default_selection_enabled, simulatedRegistration.default_selection_enabled],
+    ["registration.requires_explicit_selection", currentRegistration.requires_explicit_selection, simulatedRegistration.requires_explicit_selection],
+    ["registration.bundled", currentRegistration.bundled, simulatedRegistration.bundled],
+    ["certification_state", current.certification_state, simulated.certification_state],
+    ["integration_maturity", current.integration_maturity, simulated.integration_maturity]
+  ];
+  fieldPairs.forEach(([field, fromValue, toValue]) => {
+    if (fromValue !== toValue) {
+      changes.push({
+        field,
+        from: fromValue === undefined ? null : fromValue,
+        to: toValue === undefined ? null : toValue
+      });
+    }
+  });
+  return changes;
+}
+
+function validatePromotionActionRequest(request = {}) {
+  const entry = request && typeof request === "object" && !Array.isArray(request) ? request : {};
+  const errors = [];
+  const integrationId = String(entry.integration_id || "").trim();
+  const action = String(entry.action || "").trim();
+  if (!integrationId) {
+    errors.push("promotion_action_request.integration_id is required");
+  }
+  if (!action) {
+    errors.push("promotion_action_request.action is required");
+  } else if (!getPromotionActionDefinition(action)) {
+    errors.push("promotion_action_request.action must be a supported promotion action");
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    request: {
+      integration_id: integrationId || null,
+      action: action || null
+    }
+  };
+}
+
+function summarizeIntegrationPromotionActionPreview(request = {}) {
+  const validation = validatePromotionActionRequest(request);
+  if (!validation.ok) {
+    return {
+      ok: false,
+      reason: "invalid_promotion_action_request",
+      errors: validation.errors
+    };
+  }
+  const workflow = summarizeIntegrationPromotionWorkflow(validation.request.integration_id);
+  if (!workflow.ok) {
+    return workflow;
+  }
+
+  const action = validation.request.action;
+  const definition = getPromotionActionDefinition(action);
+  const currentSubject = clonePromotionSubject(workflow);
+  const simulatedSubject = simulatePromotionActionSubject(workflow, action);
+  const resultingReadiness = buildPromotionActionResultingReadiness(workflow, simulatedSubject);
+  const stateChanges = buildPromotionActionStateChanges(currentSubject, simulatedSubject);
+  const currentNextAction = workflow.next_transition && workflow.next_transition.action
+    ? workflow.next_transition.action
+    : null;
+  const currentLaterActions = Array.isArray(workflow.next_transition && workflow.next_transition.later_actions)
+    ? workflow.next_transition.later_actions
+    : [];
+  const validNow = currentNextAction === action || currentLaterActions.includes(action);
+  const invalidReasons = [];
+  if (!validNow) {
+    invalidReasons.push(action === "maintain_production_default"
+      ? "integration_is_not_yet_production_default_ready"
+      : "action_is_not_currently_recommended_from_present_posture");
+  }
+
+  return {
+    ok: true,
+    integration_id: workflow.integration_id,
+    display_name: workflow.display_name,
+    adapter_class: workflow.adapter_class,
+    source: workflow.source,
+    request: clone(validation.request),
+    action: clone(definition),
+    current_posture: {
+      registration_state: workflow.registration.registration_state || null,
+      certification_state: workflow.certification_state || null,
+      integration_maturity: workflow.integration_maturity || null,
+      promotion_readiness: clone(workflow.promotion_readiness || {})
+    },
+    valid_now: validNow,
+    is_recommended_next: currentNextAction === action,
+    invalid_reasons: invalidReasons,
+    requirements: currentNextAction === action
+      ? clone(workflow.next_transition.requirements || [])
+      : clone(buildNextTransitionSummary(resultingReadiness).requirements || []),
+    blockers: clone(workflow.promotion_readiness.blockers || []),
+    blocker_categories: clone(workflow.blocker_categories || []),
+    resulting_posture: {
+      registration_state: simulatedSubject.registration.registration_state || null,
+      certification_state: simulatedSubject.certification_state || null,
+      integration_maturity: simulatedSubject.integration_maturity || null,
+      promotion_readiness: clone(resultingReadiness)
+    },
+    state_changes: stateChanges,
+    current_transition: clone(workflow.next_transition || {}),
+    resulting_transition: buildNextTransitionSummary(resultingReadiness)
+  };
+}
+
+function summarizeIntegrationPromotionActionSet(integrationOrId) {
+  const workflow = summarizeIntegrationPromotionWorkflow(integrationOrId);
+  if (!workflow.ok) {
+    return workflow;
+  }
+  const actionOrder = [
+    workflow.next_transition && workflow.next_transition.action ? workflow.next_transition.action : null,
+    ...(Array.isArray(workflow.next_transition && workflow.next_transition.later_actions)
+      ? workflow.next_transition.later_actions
+      : []),
+    "maintain_production_default"
+  ].filter(Boolean);
+  const actions = sortStrings(actionOrder).map((action) => summarizeIntegrationPromotionActionPreview({
+    integration_id: workflow.integration_id,
+    action
+  }));
+  return {
+    ...workflow,
+    action_count: actions.length,
+    valid_now_count: actions.filter((entry) => entry.valid_now === true).length,
+    actions
+  };
+}
+
+function summarizeIntegrationPromotionActionSetList(filters = {}) {
+  const integrations = listIntegrations(filters).map((integration) => summarizeIntegrationPromotionActionSet(integration));
+  return {
+    ok: true,
+    integration_count: integrations.length,
+    valid_now_count: integrations.reduce((total, entry) => total + Number(entry.valid_now_count || 0), 0),
+    recommended_actions: summarizeCounts(
+      integrations
+        .map((entry) => entry.next_transition && entry.next_transition.action)
+        .filter(Boolean),
+      "action"
+    ),
+    valid_actions: summarizeCounts(
+      integrations
+        .flatMap((entry) => Array.isArray(entry.actions) ? entry.actions : [])
+        .filter((entry) => entry.valid_now === true)
+        .map((entry) => entry.request && entry.request.action)
+        .filter(Boolean),
+      "action"
+    ),
+    integrations
+  };
+}
+
 function buildPromotionActionQueues(integrations = []) {
   const rows = Array.isArray(integrations) ? integrations.filter((entry) => entry && entry.next_transition) : [];
   const groups = new Map();
@@ -1631,6 +1891,10 @@ module.exports = {
   summarizeIntegrationPromotionReadiness,
   summarizeIntegrationPromotionWorkflow,
   summarizeIntegrationPromotionWorkflowList,
+  validatePromotionActionRequest,
+  summarizeIntegrationPromotionActionPreview,
+  summarizeIntegrationPromotionActionSet,
+  summarizeIntegrationPromotionActionSetList,
   createRegisteredIntegrationFromManifest,
   buildIntegrationRegistrationView,
   buildIntegrationView

package/lib/catalog_contract.js

@@ -2,6 +2,89 @@
 
 const { catalog, findTask, findWorkflow } = require("../fixtures/catalog");
 
+function buildDefaultTransactionCenter() {
+  const settlementProfiles = Array.isArray(catalog.settlement_profiles) ? catalog.settlement_profiles : [];
+  const defaultSettlementProfile = settlementProfiles[0] || null;
+  const settlementModes = settlementProfiles
+    .map((profile) => profile && profile.mode)
+    .filter(Boolean);
+  return {
+    ok: true,
+    brand: "xytara",
+    product: "default transaction center",
+    payment_scheme: catalog.payment_scheme,
+    default_protocol: {
+      protocol: "mcp",
+      integration_id: "builtin.protocol.mcp",
+      task_ref: "adapter.mcp.invoke",
+      workflow_refs: ["a2c.tooling.flow"],
+      selection_reason: "production_default_protocol_lane"
+    },
+    default_payment: {
+      protocol: "x402",
+      integration_id: "builtin.payment.x402",
+      payment_scheme: catalog.payment_scheme,
+      supported_settlement_modes: settlementModes,
+      selection_reason: "production_default_payment_lane"
+    },
+    default_settlement: {
+      integration_id: "builtin.settlement.chain",
+      settlement_mode: defaultSettlementProfile && defaultSettlementProfile.mode ? defaultSettlementProfile.mode : null,
+      adapter: defaultSettlementProfile && defaultSettlementProfile.adapter ? defaultSettlementProfile.adapter : null,
+      asset: defaultSettlementProfile && defaultSettlementProfile.asset ? defaultSettlementProfile.asset : null,
+      payee_agent_id: defaultSettlementProfile && defaultSettlementProfile.payee_agent_id ? defaultSettlementProfile.payee_agent_id : null,
+      payee_label: defaultSettlementProfile && defaultSettlementProfile.payee_label ? defaultSettlementProfile.payee_label : null,
+      supported_modes: settlementModes,
+      profile_count: settlementProfiles.length
+    },
+    default_treasury: {
+      destination_kind: "account_treasury",
+      destination_template: "treasury_{account_id}",
+      settlement_mode: defaultSettlementProfile && defaultSettlementProfile.mode ? defaultSettlementProfile.mode : null,
+      payee_agent_id: defaultSettlementProfile && defaultSettlementProfile.payee_agent_id ? defaultSettlementProfile.payee_agent_id : null,
+      payee_label: defaultSettlementProfile && defaultSettlementProfile.payee_label ? defaultSettlementProfile.payee_label : null
+    },
+    suggested_paths: [
+      {
+        path_id: "default_mcp_x402_path",
+        path_kind: "first_party_default",
+        protocol: "mcp",
+        payment_protocol: "x402",
+        settlement_mode: defaultSettlementProfile && defaultSettlementProfile.mode ? defaultSettlementProfile.mode : null,
+        task_ref: "adapter.mcp.invoke",
+        integration_ids: ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"]
+      },
+      {
+        path_id: "default_a2c_tooling_flow",
+        path_kind: "first_party_default",
+        protocol: "mcp",
+        payment_protocol: "x402",
+        settlement_mode: defaultSettlementProfile && defaultSettlementProfile.mode ? defaultSettlementProfile.mode : null,
+        workflow_ref: "a2c.tooling.flow",
+        integration_ids: ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"]
+      }
+    ]
+  };
+}
+
+function summarizeDefaultTransactionCenter() {
+  const center = buildDefaultTransactionCenter();
+  return {
+    ok: true,
+    brand: center.brand,
+    product: center.product,
+    payment_scheme: center.payment_scheme,
+    default_protocol: center.default_protocol.protocol,
+    default_payment_protocol: center.default_payment.protocol,
+    default_settlement_mode: center.default_settlement.settlement_mode,
+    default_treasury_kind: center.default_treasury.destination_kind,
+    settlement_mode_count: Array.isArray(center.default_settlement.supported_modes) ? center.default_settlement.supported_modes.length : 0,
+    settlement_modes: center.default_settlement.supported_modes,
+    suggested_path_count: Array.isArray(center.suggested_paths) ? center.suggested_paths.length : 0,
+    suggested_paths: center.suggested_paths
+  };
+}
+
 function buildCatalogResponse() {
   return {
     ok: true,
@@ -133,9 +216,11 @@ function getWorkflowDetail(ref) {
 
 module.exports = {
   buildCatalogResponse,
+  buildDefaultTransactionCenter,
   getCatalog,
   getTaskDetail,
   getWorkflowDetail,
   getWorkflowList,
-  summarizeCatalog
+  summarizeCatalog,
+  summarizeDefaultTransactionCenter
 };

package/lib/commerce_client.js

@@ -866,6 +866,34 @@ function summarizeCatalogPayload(payload) {
   };
 }
 
+function summarizeDefaultTransactionCenterPayload(payload) {
+  const center = payload && typeof payload === "object" ? payload : {};
+  return {
+    ok: center.ok === true,
+    brand: center.brand || null,
+    product: center.product || null,
+    default_protocol: center.default_protocol && center.default_protocol.protocol
+      ? center.default_protocol.protocol
+      : center.default_protocol || null,
+    default_payment_protocol: center.default_payment && center.default_payment.protocol
+      ? center.default_payment.protocol
+      : center.default_payment_protocol || null,
+    default_settlement_mode: center.default_settlement && center.default_settlement.settlement_mode
+      ? center.default_settlement.settlement_mode
+      : center.default_settlement_mode || null,
+    default_treasury_kind: center.default_treasury && center.default_treasury.destination_kind
+      ? center.default_treasury.destination_kind
+      : center.default_treasury_kind || null,
+    settlement_mode_count: Array.isArray(center.default_settlement && center.default_settlement.supported_modes)
+      ? center.default_settlement.supported_modes.length
+      : Number(center.settlement_mode_count || 0),
+    suggested_path_count: Array.isArray(center.suggested_paths)
+      ? center.suggested_paths.length
+      : Number(center.suggested_path_count || 0),
+    suggested_paths: Array.isArray(center.suggested_paths) ? center.suggested_paths : []
+  };
+}
+
 function buildCatalogSummarySource(client) {
   const baseCatalog = client && client.catalogCache && typeof client.catalogCache === "object"
     ? client.catalogCache
@@ -1601,6 +1629,45 @@ class CommerceClient {
     return result && result.data && Array.isArray(result.data.settlement_modes) ? result.data.settlement_modes : [];
   }
 
+  async getIntegrationPromotionReadiness(integrationId) {
+    const result = await this.getJson(`/v1/integrations/${encodeURIComponent(integrationId)}/promotion-readiness`);
+    return result && result.data ? result.data : { ok: false, reason: "integration_not_found" };
+  }
+
+  async listIntegrationPromotionReadiness(filters) {
+    const suffix = buildQueryString(filters || {});
+    const result = await this.getJson(`/v1/integrations/promotion-readiness${suffix}`);
+    return result && result.data && Array.isArray(result.data.integrations) ? result.data.integrations : [];
+  }
+
+  async getIntegrationPromotionWorkflow(integrationId) {
+    const result = await this.getJson(`/v1/integrations/${encodeURIComponent(integrationId)}/promotion-workflow`);
+    return result && result.data ? result.data : { ok: false, reason: "integration_not_found" };
+  }
+
+  async listIntegrationPromotionWorkflows(filters) {
+    const suffix = buildQueryString(filters || {});
+    const result = await this.getJson(`/v1/integrations/promotion-workflow${suffix}`);
+    return result && result.data ? result.data : { ok: true, integration_count: 0, integrations: [] };
+  }
+
+  async getIntegrationPromotionActionSet(integrationId) {
+    const result = await this.getJson(`/v1/integrations/${encodeURIComponent(integrationId)}/promotion-actions`);
+    return result && result.data ? result.data : { ok: false, reason: "integration_not_found" };
+  }
+
+  async listIntegrationPromotionActionSets(filters) {
+    const suffix = buildQueryString(filters || {});
+    const result = await this.getJson(`/v1/integrations/promotion-actions${suffix}`);
+    return result && result.data ? result.data : { ok: true, integration_count: 0, integrations: [] };
+  }
+
+  async previewIntegrationPromotionAction(request) {
+    const payload = request && typeof request === "object" && !Array.isArray(request) ? request : {};
+    const result = await this.postJson("/v1/integrations/promotion-actions/preview", {}, payload);
+    return result && result.data ? result.data : { ok: false, reason: "invalid_promotion_action_request" };
+  }
+
   async getTaskExecutionModeSummaries(forceRefresh) {
     const tasks = await this.listTasks(forceRefresh);
     return summarizeFacetCounts(
@@ -2259,6 +2326,23 @@ class CommerceClient {
     return summarizeSettlementPayees(profiles);
   }
 
+  async getDefaultTransactionCenter(forceRefresh) {
+    if (!forceRefresh && this.catalogSummaryCache && this.catalogSummaryCache.defaultTransactionCenter) {
+      return this.catalogSummaryCache.defaultTransactionCenter;
+    }
+    const result = await this.getJson("/v1/transaction-center");
+    if (!forceRefresh) {
+      this.catalogSummaryCache = this.catalogSummaryCache || {};
+      this.catalogSummaryCache.defaultTransactionCenter = result.data;
+    }
+    return result.data;
+  }
+
+  async getDefaultTransactionCenterSummary(forceRefresh) {
+    const center = await this.getDefaultTransactionCenter(forceRefresh);
+    return this.summarizeDefaultTransactionCenter(center);
+  }
+
   async listSettlementPayees(forceRefresh) {
     const summary = await this.getSettlementPayeeSummaries(forceRefresh);
     return extractSummaryValues(summary, "settlement_payees", "payee_agent_id");
@@ -3341,6 +3425,81 @@ class CommerceClient {
     return this.summarizeCommandResult(result);
   }
 
+  async previewDefaultMcpToolQuote(toolName, args, options) {
+    const opts = options || {};
+    return this.previewTaskSetQuote([
+      {
+        task_ref: "adapter.mcp.invoke",
+        body: {
+          tool_name: String(toolName || "").trim(),
+          arguments: args && typeof args === "object" && !Array.isArray(args) ? args : {}
+        }
+      }
+    ], {
+      ...opts,
+      command: opts.command || `default.mcp.preview:${String(toolName || "").trim() || "tool"}`,
+      protocol: opts.protocol || "mcp",
+      paymentProtocol: opts.paymentProtocol || "x402",
+      integrationId: opts.integrationId || "builtin.protocol.mcp",
+      integrationIds: Array.isArray(opts.integrationIds) && opts.integrationIds.length > 0
+        ? opts.integrationIds
+        : ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"],
+      settlementMode: opts.settlementMode || "evm_payment"
+    });
+  }
+
+  async previewDefaultMcpToolQuoteSummary(toolName, args, options) {
+    const preview = await this.previewDefaultMcpToolQuote(toolName, args, options);
+    return this.summarizeQuotePreview(preview);
+  }
+
+  async createDefaultMcpToolQuote(toolName, args, options) {
+    const opts = options || {};
+    return this.createTaskSetQuote([
+      {
+        task_ref: "adapter.mcp.invoke",
+        body: {
+          tool_name: String(toolName || "").trim(),
+          arguments: args && typeof args === "object" && !Array.isArray(args) ? args : {}
+        }
+      }
+    ], {
+      ...opts,
+      command: opts.command || `default.mcp.quote:${String(toolName || "").trim() || "tool"}`,
+      protocol: opts.protocol || "mcp",
+      paymentProtocol: opts.paymentProtocol || "x402",
+      integrationId: opts.integrationId || "builtin.protocol.mcp",
+      integrationIds: Array.isArray(opts.integrationIds) && opts.integrationIds.length > 0
+        ? opts.integrationIds
+        : ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"],
+      settlementMode: opts.settlementMode || "evm_payment"
+    });
+  }
+
+  async createDefaultMcpToolQuoteSummary(toolName, args, options) {
+    const quote = await this.createDefaultMcpToolQuote(toolName, args, options);
+    return this.summarizeQuote(quote);
+  }
+
+  async invokeDefaultMcpTool(toolName, args, options) {
+    const opts = options || {};
+    return this.invokeMcpTool(toolName, args, {
+      ...opts,
+      protocol: opts.protocol || "mcp",
+      paymentProtocol: opts.paymentProtocol || "x402",
+      integrationId: opts.integrationId || "builtin.protocol.mcp",
+      integrationIds: Array.isArray(opts.integrationIds) && opts.integrationIds.length > 0
+        ? opts.integrationIds
+        : ["builtin.protocol.mcp", "builtin.payment.x402", "builtin.settlement.chain"],
+      settlementMode: opts.settlementMode || "evm_payment"
+    });
+  }
+
+  async invokeDefaultMcpToolSummary(toolName, args, options) {
+    const result = await this.invokeDefaultMcpTool(toolName, args, options);
+    return this.summarizeCommandResult(result);
+  }
+
   async runNamedTaskRoute(path, payload) {
     if (!this.apiKey || !this.walletId || !this.walletSecret) {
       throw new Error("named task routes require apiKey, walletId, and walletSecret");
@@ -4820,6 +4979,10 @@ class CommerceClient {
     return summarizeCatalogPayload(payload);
   }
 
+  summarizeDefaultTransactionCenter(payload) {
+    return summarizeDefaultTransactionCenterPayload(payload);
+  }
+
   summarizeTask(task) {
     return summarizeCatalogTask(task);
   }
@@ -5571,6 +5734,7 @@ module.exports = {
   extractTrailingIdFromUrl,
   summarizeQuotePayload,
   summarizeQuotePreviewPayload,
+  summarizeDefaultTransactionCenterPayload,
   summarizeActivitySnapshotPayload,
   summarizeOpenIssuesPayload,
   summarizeExecutionExceptionsPayload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xytara",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Machine commerce SDK for discovery, quoting, execution, lifecycle inspection, and adapters.",
   "main": "index.js",
   "type": "commonjs",

package/server.js

@@ -4,11 +4,13 @@ const http = require("http");
 const { URL } = require("url");
 const { readJsonBody, sendJson } = require("./lib/http_transport");
 const {
+  buildDefaultTransactionCenter,
   getCatalog,
   getTaskDetail,
   getWorkflowDetail,
   getWorkflowList,
-  summarizeCatalog
+  summarizeCatalog,
+  summarizeDefaultTransactionCenter
 } = require("./lib/catalog_contract");
 const {
   createCommandResult,
@@ -55,6 +57,9 @@ const {
   summarizeIntegrationPromotionReadiness,
   summarizeIntegrationPromotionWorkflow,
   summarizeIntegrationPromotionWorkflowList,
+  summarizeIntegrationPromotionActionPreview,
+  summarizeIntegrationPromotionActionSet,
+  summarizeIntegrationPromotionActionSetList,
   summarizeIntegrationRegistrySnapshotReview,
   summarizeIntegrationSubmissionBundleReview,
   summarizeIntegrationSubmissionBundleSetReview,
@@ -373,6 +378,16 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center") {
+    sendJson(res, 200, buildDefaultTransactionCenter());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/transaction-center/summary") {
+    sendJson(res, 200, summarizeDefaultTransactionCenter());
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/v1/catalog/task") {
     const response = buildTaskDetailResponse(getTaskDetail(url.searchParams.get("ref")));
     sendJson(res, response.status, response.payload);
@@ -508,6 +523,33 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/v1/integrations/promotion-actions") {
+    const response = buildIntegrationListResponse({
+      ...summarizeIntegrationPromotionActionSetList({
+        adapter_class: url.searchParams.get("class"),
+        protocol: url.searchParams.get("protocol"),
+        settlement_mode: url.searchParams.get("settlement_mode"),
+        capability: url.searchParams.get("capability"),
+        task_ref: url.searchParams.get("task_ref"),
+        source: url.searchParams.get("source"),
+        certification_state: url.searchParams.get("certification_state"),
+        integration_maturity: url.searchParams.get("integration_maturity"),
+        bundled: url.searchParams.get("bundled")
+      })
+    });
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/v1/integrations/promotion-actions/preview") {
+    const body = await readJsonBody(req);
+    const response = buildIntegrationListResponse(
+      summarizeIntegrationPromotionActionPreview(body)
+    );
+    sendJson(res, response.status, response.payload);
+    return;
+  }
+
   if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/") && url.pathname.endsWith("/promotion-readiness")) {
     const integrationId = getDecodedSuffixId(
       url.pathname.slice(0, -"/promotion-readiness".length),
@@ -520,6 +562,18 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/") && url.pathname.endsWith("/promotion-actions")) {
+    const integrationId = getDecodedSuffixId(
+      url.pathname.slice(0, -"/promotion-actions".length),
+      "/v1/integrations/"
+    );
+    const response = buildIntegrationListResponse(
+      summarizeIntegrationPromotionActionSet(integrationId)
+    );
+    sendJson(res, response.status || 200, response.payload || response);
+    return;
+  }
+
   if (req.method === "GET" && url.pathname.startsWith("/v1/integrations/") && url.pathname.endsWith("/promotion-workflow")) {
     const integrationId = getDecodedSuffixId(
       url.pathname.slice(0, -"/promotion-workflow".length),