xytara 3.1.16 → 3.2.0

package/lib/protocol_lane_contract.js

@@ -1,117 +0,0 @@
-"use strict";
-
-const { summarizeMcpLanePack } = require("./mcp_lane_contract");
-const { summarizeA2ALanePack } = require("./a2a_lane_contract");
-const { summarizeA2CLanePack } = require("./a2c_lane_contract");
-const { summarizeAcpLanePack } = require("./acp_lane_contract");
-const { summarizeEventSystemLanePack } = require("./event_system_lane_contract");
-
-function buildProtocolLanePack() {
-  return {
-    product: "xytara",
-    category: "machine-commerce-protocol-lane-pack",
-    pack_version: "xytara-protocol-lane-pack-v1",
-    lane_state: "first_party_protocol_family_present",
-    posture: "canonical_public_view_of_runtime_protocol_and_transport_breadth",
-    featured_protocols: {
-      mcp: {
-        protocol_id: "mcp",
-        posture: "primary_tool_and_capability_invocation_lane",
-        summary: summarizeMcpLanePack(),
-        route_ref: "/v1/mcp"
-      },
-      a2a: {
-        protocol_id: "a2a",
-        posture: "agent_to_agent_negotiation_and_settlement_lane",
-        summary: summarizeA2ALanePack(),
-        route_ref: "/v1/a2a"
-      },
-      a2c: {
-        protocol_id: "a2c",
-        posture: "agent_to_client_tooling_and_session_lane",
-        summary: summarizeA2CLanePack(),
-        route_ref: "/v1/a2c"
-      },
-      acp: {
-        protocol_id: "acp",
-        posture: "adapter_ready_agent_coordination_bridge",
-        summary: summarizeAcpLanePack(),
-        route_ref: "/v1/integrations/protocols"
-      },
-      grpc: {
-        protocol_id: "grpc",
-        posture: "adapter_ready_rpc_bridge_for service and system interop",
-        route_ref: "/v1/integrations/protocols"
-      },
-      mqtt: {
-        protocol_id: "mqtt",
-        posture: "event_and_device_oriented bridge lane",
-        route_ref: "/v1/event-systems"
-      },
-      kafka: {
-        protocol_id: "kafka",
-        posture: "durable stream and event bus lane",
-        route_ref: "/v1/event-systems"
-      },
-      nats: {
-        protocol_id: "nats",
-        posture: "subject mesh and jetstream oriented event lane",
-        summary: summarizeEventSystemLanePack(),
-        route_ref: "/v1/event-systems"
-      },
-      ros2: {
-        protocol_id: "ros2",
-        posture: "robotics and embedded coordination bridge",
-        route_ref: "/v1/integrations/protocols"
-      },
-      webhook_event_bus: {
-        protocol_id: "webhook_event_bus",
-        posture: "callback friendly ingress and replay lane",
-        route_ref: "/v1/event-systems"
-      }
-    },
-    supported_surfaces: {
-      mcp_lane_ref: "/v1/mcp",
-      a2a_lane_ref: "/v1/a2a",
-      a2c_lane_ref: "/v1/a2c",
-      acp_lane_ref: "/v1/acp",
-      event_system_lane_ref: "/v1/event-systems",
-      integration_protocols_ref: "/v1/integrations/protocols",
-      integration_matrix_ref: "/v1/integration-matrix"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "protocol_family_selection",
-        recommended_reason: "best first path for callers who need to understand which invocation, coordination, transport, or callback lane fits their system before wiring payment and settlement",
-        sequence: [
-          "inspect_protocol_lane_summary",
-          "choose_mcp_a2a_or_a2c_for_canonical_runtime_entry",
-          "use_event_or_bridge_protocols_only_when_system_shape_requires_them",
-          "continue_into_payment_and_settlement_selection"
-        ]
-      }
-    ],
-    guardrails: [
-      "protocol breadth should improve fit and adoption without fragmenting the canonical command and payment path",
-      "transport and event bridges remain subordinate to the default runtime and settlement spine"
-    ]
-  };
-}
-
-function summarizeProtocolLanePack() {
-  const pack = buildProtocolLanePack();
-  return {
-    product: "xytara",
-    category: "machine-commerce-protocol-lane-pack-summary",
-    summary_version: "xytara-protocol-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    featured_protocol_count: Object.keys(pack.featured_protocols).length,
-    first_run_flow_count: pack.first_run_flows.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildProtocolLanePack,
-  summarizeProtocolLanePack
-};

package/lib/provenance_lane_contract.js

@@ -1,54 +0,0 @@
-"use strict";
-
-function buildProvenanceLanePack() {
-  return {
-    product: "xytara",
-    category: "machine-commerce-provenance-lane-pack",
-    pack_version: "xytara-provenance-lane-pack-v1",
-    lane_state: "first_party_provenance_lane_present",
-    posture: "release_and_execution_supply_chain_trust_lane",
-    standards: ["slsa"],
-    focal_surfaces: ["release_candidate", "release_manifest", "integration_matrix", "adapter_pack"],
-    supported_surfaces: {
-      release_candidate_ref: "/v1/release-candidate",
-      release_manifest_ref: "/v1/release-manifest",
-      release_center_ref: "/v1/release-center",
-      adapter_pack_ref: "/v1/adapter-pack",
-      integration_matrix_ref: "/v1/integration-matrix"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "release_provenance_review",
-        recommended_reason: "best path for builders and operators who need artifact and release trust before integrating xytara into production systems",
-        sequence: [
-          "inspect_provenance_lane_summary",
-          "inspect_release_candidate_and_manifest",
-          "inspect_adapter_and_integration_breadth",
-          "treat_release_and_adapter posture as provenance-carrying artifacts"
-        ]
-      }
-    ],
-    guardrails: [
-      "provenance should strengthen release trust without turning the runtime into a generic attestation service",
-      "supply-chain trust complements runtime truth and proof truth instead of replacing either"
-    ]
-  };
-}
-
-function summarizeProvenanceLanePack() {
-  const pack = buildProvenanceLanePack();
-  return {
-    product: "xytara",
-    category: "machine-commerce-provenance-lane-pack-summary",
-    summary_version: "xytara-provenance-lane-pack-summary-v1",
-    lane_state: pack.lane_state,
-    standard_count: pack.standards.length,
-    focal_surface_count: pack.focal_surfaces.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildProvenanceLanePack,
-  summarizeProvenanceLanePack
-};

package/lib/provider_lane_contract.js

@@ -1,240 +0,0 @@
-"use strict";
-
-const {
-  buildPhase1OpenaiCodexRuntimePack,
-  summarizePhase1OpenaiCodexRuntimePack
-} = require("./phase_1_openai_codex_runtime_pack");
-const {
-  buildPhase1ClaudeMcpRuntimePack,
-  summarizePhase1ClaudeMcpRuntimePack
-} = require("./phase_1_claude_mcp_runtime_pack");
-const { buildAdapterDepthPack } = require("./adapter_depth_contract");
-const { buildFrameworkProviderPromotionPack } = require("./framework_provider_promotion");
-const { summarizeCapabilityExecutionTruthBundle } = require("./capability_execution_truth");
-const { summarizeMarketLaneTracePack } = require("./market_lane_trace_contract");
-const { summarizeMarketLanePromotionPack } = require("./market_lane_promotion_contract");
-
-function uniqueSorted(values) {
-  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
-}
-
-function findAdapterTask(adapterDepth, taskRef) {
-  return (Array.isArray(adapterDepth && adapterDepth.adapter_tasks) ? adapterDepth.adapter_tasks : []).find((entry) => entry && entry.task_ref === taskRef) || null;
-}
-
-function buildProviderProfiles() {
-  const adapterDepth = buildAdapterDepthPack();
-  const frameworkPromotion = buildFrameworkProviderPromotionPack();
-  const executionTruth = summarizeCapabilityExecutionTruthBundle();
-  const marketLaneTraceSummary = summarizeMarketLaneTracePack();
-  const marketLanePromotionSummary = summarizeMarketLanePromotionPack();
-  const openaiPack = buildPhase1OpenaiCodexRuntimePack();
-  const openaiSummary = summarizePhase1OpenaiCodexRuntimePack();
-  const claudePack = buildPhase1ClaudeMcpRuntimePack();
-  const claudeSummary = summarizePhase1ClaudeMcpRuntimePack();
-
-  const adapterInvokeTask = findAdapterTask(adapterDepth, "adapter.mcp.invoke");
-  const providerLiveAnchorReady = Boolean(adapterInvokeTask && adapterInvokeTask.provider_live);
-  const computeTraceReady = Number(marketLaneTraceSummary.provider_live_anchor_trace_count || 0) >= 1;
-  const computePromotionReady = Number(marketLanePromotionSummary.provider_live_ready_count || 0) >= 1;
-  const providerLiveTaskCount = Number(executionTruth.counts && executionTruth.counts.provider_live_count || 0);
-  const frameworkLiveCheckReadyCount = Number(frameworkPromotion.live_check_ready_count || 0);
-  const configuredToolCount = Number(adapterDepth.counts && adapterDepth.counts.configured_tool_count || 0);
-
-  return [
-    {
-      provider_id: "openai_codex",
-      provider_label: "OpenAI Codex",
-      posture: "machine_native_quote_pay_execute_entry",
-      claim_status: "bounded_live",
-      provider_live_anchor_ready: false,
-      first_party_callable_ready: true,
-      revenue_ready: true,
-      proof_followthrough_ready: typeof openaiPack.first_path.followthrough_ref === "string",
-      primary_http_sequence: openaiPack.first_path.first_http_sequence.slice(),
-      primary_cli_sequence: openaiPack.first_path.first_cli_sequence.slice(),
-      primary_call_surfaces: uniqueSorted([
-        "/x402/commands/execute",
-        "/v1/commands/execute",
-        "/v1/release-center/summary",
-        "/v1/release-pack/scenarios/summary"
-      ]),
-      supporting_surfaces: uniqueSorted([
-        "/v1/capability-registry/execution-truth/summary",
-        "/v1/full-catalog/market-lanes/traces/summary",
-        "/v1/full-catalog/market-lanes/promotion/summary",
-        "/v1/release-center/summary",
-        "/v1/x402"
-      ]),
-      activation_http_step_count: openaiSummary.http_step_count,
-      activation_cli_step_count: openaiSummary.cli_step_count,
-      expected_signal_count: openaiSummary.signal_count,
-      runtime_gates: {
-        machine_entry_ready: openaiSummary.http_step_count >= 3,
-        paid_execution_ready: true,
-        commercialization_ready: true,
-        trace_ready: computeTraceReady,
-        proof_followthrough_ready: typeof openaiPack.first_path.followthrough_ref === "string"
-      },
-      followthrough_ref: openaiPack.first_path.followthrough_ref,
-      claim_boundary: "claim_openai_codex_as_a_bounded_machine_entry_surface_into_xytara_not_as_direct_openai_control_plane_ownership"
-    },
-    {
-      provider_id: "claude_mcp",
-      provider_label: "Claude MCP",
-      posture: "adapter_bound_tool_invoke_and_runtime_execution_entry",
-      claim_status: "bounded_live",
-      provider_live_anchor_ready: providerLiveAnchorReady,
-      first_party_callable_ready: true,
-      revenue_ready: providerLiveAnchorReady && computePromotionReady,
-      proof_followthrough_ready: typeof claudePack.first_path.followthrough_ref === "string",
-      primary_http_sequence: claudePack.first_path.first_http_sequence.slice(),
-      primary_cli_sequence: claudePack.first_path.first_cli_sequence.slice(),
-      primary_call_surfaces: uniqueSorted([
-        "/v1/mcp/tools/invoke",
-        "/v1/transaction-center/task-packs/invoke",
-        "/v1/adapter-depth/summary",
-        "/v1/framework-provider-promotion/summary"
-      ]),
-      supporting_surfaces: uniqueSorted([
-        "/v1/adapter-pack/summary",
-        "/v1/adapter-promotion/summary",
-        "/v1/capability-registry/execution-truth/summary",
-        "/v1/full-catalog/market-lanes/depth/summary",
-        "/v1/full-catalog/market-lanes/traces/summary",
-        "/v1/full-catalog/market-lanes/promotion/summary",
-        "/v1/mcp",
-        "/v1/providers/openai_codex"
-      ]),
-      activation_http_step_count: claudeSummary.http_step_count,
-      activation_cli_step_count: claudeSummary.cli_step_count,
-      expected_signal_count: claudeSummary.signal_count,
-      runtime_gates: {
-        mcp_entry_ready: claudeSummary.http_step_count >= 3,
-        adapter_depth_ready: providerLiveAnchorReady,
-        proof_fact_ready: Boolean(adapterInvokeTask && Array.isArray(adapterInvokeTask.execution_targets) && adapterInvokeTask.execution_targets.some((target) => target && target.operational_coverage && target.operational_coverage.proof_fact_compatible)),
-        tool_binding_ready: configuredToolCount >= 1,
-        framework_promotion_gate_ready: frameworkPromotion.framework_candidate_count >= 2,
-        trace_ready: computeTraceReady,
-        promotion_ready: computePromotionReady
-      },
-      live_provider_signals: {
-        provider_live_task_count: providerLiveTaskCount,
-        deepened_provider_live_task_count: Number(adapterDepth.counts && adapterDepth.counts.deepened_provider_live_task_count || 0),
-        configured_execution_target_count: Number(adapterDepth.counts && adapterDepth.counts.configured_execution_target_count || 0),
-        framework_live_check_ready_count: frameworkLiveCheckReadyCount
-      },
-      followthrough_ref: claudePack.first_path.followthrough_ref,
-      claim_boundary: "claim_claude_mcp_provider_depth_only_for_the_listed_mcp_adapter_tool_bindings_and_public_promotion_gates"
-    }
-  ];
-}
-
-function summarizeProviderProfile(profile) {
-  return {
-    provider_id: profile.provider_id,
-    provider_label: profile.provider_label,
-    posture: profile.posture,
-    claim_status: profile.claim_status,
-    provider_live_anchor_ready: profile.provider_live_anchor_ready,
-    first_party_callable_ready: profile.first_party_callable_ready,
-    revenue_ready: profile.revenue_ready,
-    proof_followthrough_ready: profile.proof_followthrough_ready,
-    activation_http_step_count: profile.activation_http_step_count,
-    activation_cli_step_count: profile.activation_cli_step_count,
-    expected_signal_count: profile.expected_signal_count,
-    primary_call_surface_count: uniqueSorted(profile.primary_call_surfaces).length,
-    supporting_surface_count: uniqueSorted(profile.supporting_surfaces).length,
-    claim_boundary: profile.claim_boundary
-  };
-}
-
-function buildProviderLanePack() {
-  const profiles = buildProviderProfiles();
-  const summarizedProfiles = Object.fromEntries(profiles.map((profile) => [profile.provider_id, summarizeProviderProfile(profile)]));
-  return {
-    ok: true,
-    product: "xytara",
-    category: "machine-commerce-provider-lane-pack",
-    pack_version: "xytara-provider-lane-pack-v2",
-    lane_state: "first_party_provider_family_present",
-    posture: "provider_entry_and_runtime_execution_family",
-    breadth_state: profiles.some((profile) => profile.provider_live_anchor_ready)
-      ? "bounded_provider_runtime_breadth_present"
-      : "provider_entry_family_present_without_live_anchor",
-    featured_providers: summarizedProfiles,
-    provider_profile_count: profiles.length,
-    provider_live_anchor_profile_count: profiles.filter((profile) => profile.provider_live_anchor_ready).length,
-    first_party_callable_profile_count: profiles.filter((profile) => profile.first_party_callable_ready).length,
-    revenue_ready_profile_count: profiles.filter((profile) => profile.revenue_ready).length,
-    proof_followthrough_profile_count: profiles.filter((profile) => profile.proof_followthrough_ready).length,
-    provider_profiles: profiles,
-    supported_surfaces: {
-      phase_1_summary_ref: "/v1/phases/phase-1/summary",
-      openai_codex_summary_ref: "/v1/phases/phase-1/openai-codex/runtime/summary",
-      claude_mcp_summary_ref: "/v1/phases/phase-1/claude-mcp/runtime/summary",
-      providers_summary_ref: "/v1/providers/summary",
-      adapter_depth_summary_ref: "/v1/adapter-depth/summary",
-      framework_provider_promotion_summary_ref: "/v1/framework-provider-promotion/summary",
-      execution_truth_summary_ref: "/v1/capability-registry/execution-truth/summary",
-      market_lane_trace_summary_ref: "/v1/full-catalog/market-lanes/traces/summary",
-      market_lane_promotion_summary_ref: "/v1/full-catalog/market-lanes/promotion/summary",
-      provider_runtime_journeys_ref: "/v1/providers/journeys",
-      provider_runtime_journeys_summary_ref: "/v1/providers/journeys/summary",
-      x402_ref: "/v1/x402",
-      mcp_lane_ref: "/v1/mcp",
-      integrations_ref: "/v1/integrations"
-    },
-    first_run_flows: [
-      {
-        flow_ref: "provider_family_selection",
-        recommended_reason: "best first path for understanding how named provider entry points map into the canonical commerce runtime",
-        sequence: [
-          "inspect_provider_lane_summary",
-          "inspect_provider_runtime_journey_summary",
-          "inspect_named_provider_runtime_profiles",
-          "choose_provider_entry_path",
-          "continue_into_paid_execution_and_proof_followthrough"
-        ]
-      }
-    ],
-    guardrails: [
-      "provider lanes should stay entry and interoperability shapes rather than redefine the core runtime model",
-      "named providers improve adoption only when they remain subordinate to canonical protocol, payment, settlement, and proof lanes",
-      "named provider journeys must stay publicly inspectable before stronger revenue or go-to-market claims are made",
-      "claim provider-live runtime breadth only for the listed provider profiles and their public gates",
-      "do not collapse provider entry readiness into unbounded external-provider platform claims"
-    ]
-  };
-}
-
-function getProviderProfileDetail(providerId) {
-  const normalized = String(providerId || "").trim().toLowerCase();
-  return buildProviderProfiles().find((profile) => profile.provider_id === normalized) || null;
-}
-
-function summarizeProviderLanePack() {
-  const pack = buildProviderLanePack();
-  return {
-    ok: true,
-    product: "xytara",
-    category: "machine-commerce-provider-lane-pack-summary",
-    summary_version: "xytara-provider-lane-pack-summary-v2",
-    lane_state: pack.lane_state,
-    breadth_state: pack.breadth_state,
-    featured_provider_count: Object.keys(pack.featured_providers).length,
-    provider_profile_count: pack.provider_profile_count,
-    provider_live_anchor_profile_count: pack.provider_live_anchor_profile_count,
-    first_party_callable_profile_count: pack.first_party_callable_profile_count,
-    revenue_ready_profile_count: pack.revenue_ready_profile_count,
-    proof_followthrough_profile_count: pack.proof_followthrough_profile_count,
-    first_run_flow_count: pack.first_run_flows.length,
-    linked_surfaces: pack.supported_surfaces
-  };
-}
-
-module.exports = {
-  buildProviderLanePack,
-  getProviderProfileDetail,
-  summarizeProviderLanePack
-};

package/lib/provider_network_contract.js

@@ -1,149 +0,0 @@
-"use strict";
-
-// Public, machine-readable integration contract for the open execution-provider network. It
-// tells an external provider (or an agent building one) exactly how to plug in: how to
-// register, the request/response shape the runtime sends to the provider's /execute endpoint,
-// the lifecycle, the routing/health/reputation expectations, and the economics. Read-only; it
-// describes the PUBLIC protocol and exposes no secrets. Numeric limits reflect the runtime's
-// live configuration (same env + defaults the code uses) so a provider sees the real ceilings.
-
-function intEnv(name, fallback) {
-  const n = Number(process.env[name]);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function buildProviderNetworkContract() {
-  const openRegistration = String(process.env.XYTARA_PROVIDER_OPEN_REGISTRATION || "").trim() === "1";
-  const maxRevenueShareBps = (() => {
-    const n = Number(process.env.XYTARA_PROVIDER_MAX_REVENUE_SHARE_BPS);
-    return Number.isInteger(n) && n >= 0 && n <= 10000 ? n : 10000;
-  })();
-
-  return {
-    ok: true,
-    contract_version: "provider-network/v1",
-    product: "xytara open execution-provider network",
-    summary:
-      "Register an execution endpoint that serves one or more capabilities; once an operator activates it, the runtime routes PAID (x402-settled) agent calls to your /execute, surfaces your output as the buyer's deliverable, and accrues your revenue-share for payout.",
-    lifecycle: [
-      "1. REGISTER your provider (endpoint_url + the capabilities you serve + your revenue_share_bps + payout_address). You receive an owner_secret (save it — shown once).",
-      "2. Your provider lands status:'pending' and is NOT routable yet.",
-      "3. An OPERATOR activates it (status:'active').",
-      "4. When a buyer pays (x402) for a capability you serve, the runtime POSTs the job to your endpoint_url; you execute and return the deliverable.",
-      "5. On your success the payment settles on-chain and your revenue_share accrues.",
-      "6. The operator pays out your accrued balance to your payout_address (manually or via a signer). Track it yourself any time via GET /providers/<id>/earnings with your owner_secret."
-    ],
-
-    registration: {
-      endpoint: "POST /v1/provider-network/register",
-      auth: {
-        modes: [
-          "operator-bearer: send Authorization: Bearer <registration token> (obtain from the operator)",
-          "open (permissionless): no bearer required, but rate-limited and pending-capped"
-        ],
-        open_registration_enabled: openRegistration,
-        note: "A re-registration of an EXISTING provider_id ALWAYS requires its owner_secret, in either mode."
-      },
-      body: {
-        provider_id: "string, optional — stable id; omit to be assigned a random one. Keep it: it is your identity.",
-        owner_secret: "string, REQUIRED only when updating an existing provider_id (returned once at first registration).",
-        label: "string, optional display name.",
-        endpoint_url: "string, REQUIRED — your https /execute URL the runtime will POST jobs to.",
-        task_refs: "string[] — task refs you serve (e.g. 'adapter.mcp.invoke'). At least one selector across task_refs/tool_names/integration_ids is required.",
-        tool_names: "string[] — specific tool names you serve (matched against the call's body.tool_name).",
-        integration_ids: "string[] — integration-family ids you serve.",
-        revenue_share_bps: `integer 0..${maxRevenueShareBps} — your share of each settled amount in basis points (e.g. 7000 = 70%). Current operator cap: ${maxRevenueShareBps}.`,
-        payout_address: "string, optional — where your revenue-share is paid (eip155 address shape-checked for eip155 networks).",
-        payout_network: "string, optional — default 'eip155:8453' (Base).",
-        payout_asset: "string, optional — default 'USDC'.",
-        auth_token: "string, optional — a bearer the runtime presents to YOUR /execute (so you can authenticate it)."
-      },
-      response: {
-        ok: true,
-        provider_id: "<your id>",
-        status: "pending",
-        owner_secret: "prvown_… (RETURNED ONLY ON FIRST REGISTRATION — store it securely; required for every future update)",
-        provider: "{ public view: no auth_token, no owner_secret }"
-      }
-    },
-
-    execution_contract: {
-      description: "When a paid call for a capability you serve is routed to you, the runtime sends an HTTP POST to your endpoint_url. Execute the work and return the deliverable.",
-      request: {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: "Bearer <your auth_token> (only if you registered one)"
-        },
-        body: {
-          command: "string — the command label",
-          task_ref: "string — the task ref being invoked",
-          tasks: "array — the task set (when multi-task)",
-          body: "object — the buyer's input, e.g. { tool_name, arguments }",
-          account_id: "string — the buyer's account ref",
-          quote: "object — the priced quote for this call",
-          authorization_context: "object — SANITIZED payment context: { ok, verification_mode, wallet_id, age_seconds, payment_payload (scalar facts only) }. Never the buyer's signed authorization, signatures, or settlement material."
-        }
-      },
-      endpoint_policy: "endpoint_url must be https and publicly routable on the hosted network (loopback, private, link-local and metadata hosts are refused, re-checked by DNS at dispatch); URLs with embedded credentials are refused; redirects are never followed.",
-      execution_budget: "One buyer call has a total wall-clock budget (default 50s, inside the x402 authorization window) shared across ride-out retries and failover; your timeout_ms is capped at 30000 ms. Finish well inside it — a call that outlives the authorization cannot settle.",
-      response: {
-        on_success: "Return HTTP 2xx with the deliverable. The runtime surfaces your output from result.output OR a top-level output_payload / output_ref.",
-        example_success_bodies: [
-          '{ "result": { "output": { "...": "your real result" } } }',
-          '{ "output_payload": { "...": "your real result" } }'
-        ],
-        on_failure: "Return a non-2xx status.",
-        failure_semantics: {
-          failover_safe_statuses: [408, 429, 503],
-          note: "408/429/503 (and connection-refused/DNS) are treated as 'did NOT process' — the runtime may RETRY you and/or FAIL OVER to another provider. Any OTHER failure (5xx, timeout, connection reset, malformed) is treated as AMBIGUOUS: the runtime will NOT retry/fail-over (your side may have executed). Design /execute to be idempotent per request so a safe retry is harmless."
-        },
-        timeout_ms_default: intEnv("XYTARA_EXTERNAL_EXECUTION_DEFAULT_TIMEOUT_MS", 10000)
-      }
-    },
-
-    routing: {
-      capability_matching: "A call routes to you if its task_ref is in your task_refs, OR its body.tool_name is in your tool_names, OR an integration id matches your integration_ids. Only ACTIVE providers are routable.",
-      health: {
-        description: "Consecutive failures mark you unhealthy and temporarily exclude you from routing; a cooldown then lets you back (half-open) for one retry; a success resets you.",
-        unhealthy_threshold: intEnv("XYTARA_PROVIDER_UNHEALTHY_THRESHOLD", 3),
-        unhealthy_cooldown_ms: intEnv("XYTARA_PROVIDER_UNHEALTHY_COOLDOWN_MS", 60000)
-      },
-      reputation: {
-        description: "The runtime tracks your lifetime success rate and prefers higher-reputation providers within the healthy tier. New providers get an optimistic score (a fair first shot); one early failure is recoverable (not disqualifying). The operator may enable recency decay so recent performance outweighs stale history (your raw lifetime counts are still shown either way).",
-        routing_score: "(success + 2) / (success + failure + 2)",
-        recency_decay: intEnv("XYTARA_PROVIDER_REPUTATION_DECAY", 1)
-      },
-      failover_max_candidates: intEnv("XYTARA_PROVIDER_FAILOVER_MAX", 3),
-      note: "Operator-pinned execution targets (if any) take precedence over the registry for a given capability."
-    },
-
-    economics: {
-      settlement: "Buyers pay via x402 (gasless USDC on Base). The runtime settles on-chain only AFTER your execution succeeds — a failed call does not charge the buyer.",
-      revenue_share: "Your provider_share = floor(settled_amount * revenue_share_bps / 10000); the platform keeps the remainder (incl. rounding). settled_amount = min(quote, the amount actually settled on-chain for the call) — never money that was not collected; each ledger row records its settlement_basis.",
-      delivery_receipts: "Every paid call routed to you returns the buyer a signed delivery receipt (naxytra-delivery-receipt/1) naming your provider_id and the sha256 of the request and of the output you returned, bound to the payment (for x402, the settlement tx). Keys: GET /.well-known/delivery-receipt-keys. It attests what you delivered — never whether it was correct.",
-      payouts: "Your accrued share is paid to your payout_address by the operator (reconciled ledger: create -> on-chain send -> confirm). Amounts are tracked in the quote's minor unit (USD_CENTS). Ledger rows and payouts are scoped to your registration: a removed-and-re-registered provider_id starts a fresh ledger and never inherits another owner's rows."
-    },
-
-    discovery: {
-      list: "GET /v1/provider-network/providers — public; lists ACTIVE (vetted) providers with capabilities, status, health, and reputation (never secrets). Pending/suspended records are visible to the operator only.",
-      self: "GET /v1/provider-network/providers/<provider_id> — your public record.",
-      earnings:
-        "GET /v1/provider-network/providers/<provider_id>/earnings — your OWN earnings (read-only): payout_state (accrued/paid/pending/available/owed), your settlement rows, and your payout history. Authenticate with YOUR owner_secret via the 'x-provider-owner-secret' header (or Authorization: Bearer <owner_secret>) — this is the provider side, it needs no operator bearer."
-    },
-
-    operator_gated: [
-      "activation: POST /v1/provider-network/providers/:id/status { status }",
-      "payouts: POST /v1/provider-network/providers/:id/payouts (+ /payouts/:id/confirm|cancel, /payouts/execute)",
-      "removal: POST /v1/provider-network/providers/:id/remove"
-    ],
-
-    guidance: [
-      "Be idempotent per request — key on quote.quote_id (unique per buyer call): retries and failover can re-send a provably-not-processed job, and some proxies return 503 after forwarding a request.",
-      "Be reliable — health and reputation gate your routing and ordering.",
-      "Return a 429 with Retry-After when overloaded (it is treated as 'did not process' and is safely retried)."
-    ]
-  };
-}
-
-module.exports = { buildProviderNetworkContract };