xytara 3.1.16 → 3.2.0

package/scripts/verify_adapters.js

@@ -1,554 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const fs = require("fs");
-const path = require("path");
-
-const manifestSchema = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "adapter-manifest.schema.json"), "utf8")
-);
-const registrationRecordSchema = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-registration-record.schema.json"), "utf8")
-);
-const certificationPackSchema = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-certification-pack.schema.json"), "utf8")
-);
-const submissionBundleSchema = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-submission-bundle.schema.json"), "utf8")
-);
-const exampleManifest = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-execution-adapter.manifest.json"), "utf8")
-);
-const exampleSettlementManifest = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-settlement-adapter.manifest.json"), "utf8")
-);
-const exampleRegistrationRecord = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.record.json"), "utf8")
-);
-const exampleCertificationPack = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.certification-pack.json"), "utf8")
-);
-const exampleIdentityRegistrationRecord = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.record.json"), "utf8")
-);
-const exampleIdentityCertificationPack = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.certification-pack.json"), "utf8")
-);
-const exampleSettlementRegistrationRecord = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.record.json"), "utf8")
-);
-const exampleSettlementCertificationPack = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.certification-pack.json"), "utf8")
-);
-const exampleSubmissionBundle = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.submission-bundle.json"), "utf8")
-);
-const minimalThirdPartyExecutionManifest = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution-adapter.manifest.json"), "utf8")
-);
-const langgraphReferenceManifest = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "langgraph-reference-execution-adapter.manifest.json"), "utf8")
-);
-const langchainReferenceManifest = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "langchain-reference-execution-adapter.manifest.json"), "utf8")
-);
-const minimalThirdPartyExecutionRegistrationRecord = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution-registration.record.json"), "utf8")
-);
-const minimalThirdPartyExecutionCertificationPack = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution.certification-pack.json"), "utf8")
-);
-const minimalThirdPartyExecutionSubmissionBundle = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution.submission-bundle.json"), "utf8")
-);
-const exampleIdentitySubmissionBundle = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.submission-bundle.json"), "utf8")
-);
-const exampleSettlementSubmissionBundle = JSON.parse(
-  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.submission-bundle.json"), "utf8")
-);
-const minimalThirdPartyExecutionAdapter = require("../adapters/examples/minimal-third-party-execution-adapter");
-const langgraphReferenceAdapter = require("../adapters/examples/langgraph-reference-execution-adapter");
-const langchainReferenceAdapter = require("../adapters/examples/langchain-reference-execution-adapter");
-const exampleAdapter = require("../adapters/examples/example-execution-adapter");
-const exampleSettlementAdapter = require("../adapters/examples/example-settlement-adapter");
-const { ADAPTER_INTERFACE_VERSION, validateAdapterImplementation } = require("../adapters/interfaces");
-const {
-  createIntegrationSubmissionBundle,
-  validateIntegrationCertificationPack,
-  validateIntegrationSubmission,
-  validateIntegrationSubmissionBundle
-} = require("../integrations/registry");
-
-function validateType(value, type) {
-  if (type === "array") return Array.isArray(value);
-  if (type === "object") return value !== null && typeof value === "object" && !Array.isArray(value);
-  if (type === "boolean") return typeof value === "boolean";
-  if (type === "string") return typeof value === "string";
-  return true;
-}
-
-function validateManifest(manifest, schema, pathLabel, errors) {
-  const targetPath = pathLabel || "manifest";
-  if (!validateType(manifest, schema.type)) {
-    errors.push(`${targetPath} should be ${schema.type}`);
-    return;
-  }
-
-  if (schema.type === "object") {
-    const properties = schema.properties || {};
-    const required = Array.isArray(schema.required) ? schema.required : [];
-
-    for (const key of required) {
-      if (!Object.prototype.hasOwnProperty.call(manifest, key)) {
-        errors.push(`${targetPath}.${key} is required`);
-      }
-    }
-
-    if (schema.additionalProperties === false) {
-      for (const key of Object.keys(manifest)) {
-        if (!Object.prototype.hasOwnProperty.call(properties, key)) {
-          errors.push(`${targetPath}.${key} is not allowed`);
-        }
-      }
-    }
-
-    for (const [key, propertySchema] of Object.entries(properties)) {
-      if (Object.prototype.hasOwnProperty.call(manifest, key)) {
-        validateManifest(manifest[key], propertySchema, `${targetPath}.${key}`, errors);
-      }
-    }
-    return;
-  }
-
-  if (schema.type === "array") {
-    if (typeof schema.minItems === "number" && manifest.length < schema.minItems) {
-      errors.push(`${targetPath} must contain at least ${schema.minItems} item(s)`);
-    }
-    manifest.forEach((value, index) => {
-      validateManifest(value, schema.items || {}, `${targetPath}[${index}]`, errors);
-    });
-    return;
-  }
-
-  if (schema.type === "string") {
-    if (typeof schema.minLength === "number" && manifest.length < schema.minLength) {
-      errors.push(`${targetPath} must be at least ${schema.minLength} character(s)`);
-    }
-    if (Array.isArray(schema.enum) && !schema.enum.includes(manifest)) {
-      errors.push(`${targetPath} must be one of: ${schema.enum.join(", ")}`);
-    }
-  }
-}
-
-async function main() {
-  const errors = [];
-  validateManifest(exampleManifest, manifestSchema, "manifest", errors);
-  validateManifest(exampleSettlementManifest, manifestSchema, "settlement_manifest", errors);
-  validateManifest(exampleRegistrationRecord, registrationRecordSchema, "registration_record", errors);
-  validateManifest(exampleCertificationPack, certificationPackSchema, "certification_pack", errors);
-  validateManifest(exampleIdentityRegistrationRecord, registrationRecordSchema, "identity_registration_record", errors);
-  validateManifest(exampleIdentityCertificationPack, certificationPackSchema, "identity_certification_pack", errors);
-  validateManifest(exampleSettlementRegistrationRecord, registrationRecordSchema, "settlement_registration_record", errors);
-  validateManifest(exampleSettlementCertificationPack, certificationPackSchema, "settlement_certification_pack", errors);
-  validateManifest(exampleSubmissionBundle, submissionBundleSchema, "submission_bundle", errors);
-  validateManifest(minimalThirdPartyExecutionManifest, manifestSchema, "minimal_third_party_execution_manifest", errors);
-  validateManifest(langgraphReferenceManifest, manifestSchema, "langgraph_reference_manifest", errors);
-  validateManifest(langchainReferenceManifest, manifestSchema, "langchain_reference_manifest", errors);
-  validateManifest(minimalThirdPartyExecutionRegistrationRecord, registrationRecordSchema, "minimal_third_party_execution_registration_record", errors);
-  validateManifest(minimalThirdPartyExecutionCertificationPack, certificationPackSchema, "minimal_third_party_execution_certification_pack", errors);
-  validateManifest(minimalThirdPartyExecutionSubmissionBundle, submissionBundleSchema, "minimal_third_party_execution_submission_bundle", errors);
-  validateManifest(exampleIdentitySubmissionBundle, submissionBundleSchema, "identity_submission_bundle", errors);
-  validateManifest(exampleSettlementSubmissionBundle, submissionBundleSchema, "settlement_submission_bundle", errors);
-  assert.deepStrictEqual(errors, [], `adapter manifest validation failed:\n${errors.join("\n")}`);
-
-  assert.strictEqual(exampleManifest.adapter_class, "execution_adapter", "example adapter class mismatch");
-  assert.strictEqual(exampleManifest.proof_contract.emits_proof_compatible_facts, true, "example adapter proof contract mismatch");
-  assert.strictEqual(
-    exampleManifest.compatibility.commerce_contract,
-    "commerce-repo-final-contract/v1",
-    "example adapter commerce compatibility mismatch"
-  );
-  assert.strictEqual(
-    exampleManifest.compatibility.proof_contract,
-    "proof-repo-final-contract/v1",
-    "example adapter proof compatibility mismatch"
-  );
-  assert.strictEqual(
-    exampleManifest.registration_contract.integration_id,
-    exampleManifest.adapter_id,
-    "example adapter registration integration_id mismatch"
-  );
-  assert.strictEqual(
-    exampleManifest.registration_contract.integration_maturity,
-    "reference_example",
-    "example adapter registration maturity mismatch"
-  );
-  assert.strictEqual(
-    exampleManifest.certification_contract.certification_state,
-    "reference_example",
-    "example adapter certification state mismatch"
-  );
-  assert.strictEqual(
-    exampleManifest.failure_contract.retryable_categories.every((entry) => exampleManifest.failure_contract.categories.includes(entry)),
-    true,
-    "retryable categories must be declared in categories"
-  );
-  assert.strictEqual(exampleManifest.interface_version, ADAPTER_INTERFACE_VERSION, "example adapter interface version mismatch");
-  assert.strictEqual(exampleSettlementManifest.adapter_class, "settlement_adapter", "example settlement adapter class mismatch");
-  assert.strictEqual(exampleSettlementManifest.interface_version, ADAPTER_INTERFACE_VERSION, "example settlement adapter interface version mismatch");
-  assert.strictEqual(
-    exampleSettlementManifest.registration_contract.integration_id,
-    exampleSettlementManifest.adapter_id,
-    "example settlement adapter registration integration_id mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementManifest.certification_contract.certification_state,
-    "reference_example",
-    "example settlement adapter certification state mismatch"
-  );
-  assert.strictEqual(
-    exampleRegistrationRecord.adapter_class,
-    "agent_protocol_adapter",
-    "example registration record adapter class mismatch"
-  );
-  assert.strictEqual(
-    exampleRegistrationRecord.registration_state,
-    "staging_registered",
-    "example registration record state mismatch"
-  );
-  assert.strictEqual(
-    exampleRegistrationRecord.bundled,
-    false,
-    "example registration record bundled posture mismatch"
-  );
-  assert.strictEqual(
-    exampleRegistrationRecord.requires_explicit_selection,
-    true,
-    "example registration record explicit-selection posture mismatch"
-  );
-  assert.strictEqual(
-    exampleIdentityRegistrationRecord.adapter_class,
-    "identity_registry_adapter",
-    "example identity registration record adapter class mismatch"
-  );
-  assert.strictEqual(
-    exampleIdentityRegistrationRecord.registration_state,
-    "staging_registered",
-    "example identity registration record state mismatch"
-  );
-  assert.strictEqual(
-    exampleIdentityRegistrationRecord.requires_explicit_selection,
-    true,
-    "example identity registration record explicit-selection posture mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementRegistrationRecord.adapter_class,
-    "settlement_adapter",
-    "example settlement registration record adapter class mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementRegistrationRecord.registration_state,
-    "staging_registered",
-    "example settlement registration record state mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementRegistrationRecord.requires_explicit_selection,
-    true,
-    "example settlement registration record explicit-selection posture mismatch"
-  );
-  assert.strictEqual(
-    exampleCertificationPack.integration_id,
-    exampleRegistrationRecord.integration_id,
-    "example certification pack integration_id mismatch"
-  );
-  assert.strictEqual(
-    exampleCertificationPack.adapter_class,
-    exampleRegistrationRecord.adapter_class,
-    "example certification pack adapter class mismatch"
-  );
-  assert.strictEqual(
-    exampleIdentityCertificationPack.integration_id,
-    exampleIdentityRegistrationRecord.integration_id,
-    "example identity certification pack integration_id mismatch"
-  );
-  assert.strictEqual(
-    exampleIdentityCertificationPack.adapter_class,
-    exampleIdentityRegistrationRecord.adapter_class,
-    "example identity certification pack adapter class mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementCertificationPack.integration_id,
-    exampleSettlementRegistrationRecord.integration_id,
-    "example settlement certification pack integration_id mismatch"
-  );
-  assert.strictEqual(
-    exampleSettlementManifest.failure_contract.retryable_categories.every((entry) => exampleSettlementManifest.failure_contract.categories.includes(entry)),
-    true,
-    "settlement adapter retryable categories must be declared in categories"
-  );
-  assert.strictEqual(
-    validateIntegrationCertificationPack(exampleCertificationPack).ok,
-    true,
-    "example certification pack validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationCertificationPack(exampleIdentityCertificationPack).ok,
-    true,
-    "example identity certification pack validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationCertificationPack(exampleSettlementCertificationPack).ok,
-    true,
-    "example settlement certification pack validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmission({
-      adapter_id: exampleRegistrationRecord.adapter_id,
-      adapter_class: exampleRegistrationRecord.adapter_class
-    }, exampleRegistrationRecord, exampleCertificationPack).ok,
-    true,
-    "third-party protocol submission validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmission({
-      adapter_id: exampleIdentityRegistrationRecord.adapter_id,
-      adapter_class: exampleIdentityRegistrationRecord.adapter_class
-    }, exampleIdentityRegistrationRecord, exampleIdentityCertificationPack).ok,
-    true,
-    "third-party identity submission validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmission({
-      adapter_id: exampleSettlementRegistrationRecord.adapter_id,
-      adapter_class: exampleSettlementRegistrationRecord.adapter_class
-    }, exampleSettlementRegistrationRecord, exampleSettlementCertificationPack).ok,
-    true,
-    "third-party settlement submission validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmissionBundle(exampleSubmissionBundle).ok,
-    true,
-    "submission bundle validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmissionBundle(exampleIdentitySubmissionBundle).ok,
-    true,
-    "identity submission bundle validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmissionBundle(exampleSettlementSubmissionBundle).ok,
-    true,
-    "settlement submission bundle validation mismatch"
-  );
-  assert.strictEqual(
-    minimalThirdPartyExecutionManifest.adapter_class,
-    "execution_adapter",
-    "minimal third-party execution manifest adapter class mismatch"
-  );
-  assert.strictEqual(
-    minimalThirdPartyExecutionManifest.registration_contract.bundled,
-    false,
-    "minimal third-party execution bundled posture mismatch"
-  );
-  assert.strictEqual(langgraphReferenceManifest.adapter_class, "execution_adapter", "langgraph reference adapter class mismatch");
-  assert.strictEqual(langgraphReferenceManifest.registration_contract.bundled, true, "langgraph reference bundled posture mismatch");
-  assert.strictEqual(langgraphReferenceManifest.certification_contract.certification_state, "reference_example", "langgraph reference certification mismatch");
-  assert.strictEqual(langchainReferenceManifest.adapter_class, "execution_adapter", "langchain reference adapter class mismatch");
-  assert.strictEqual(langchainReferenceManifest.registration_contract.bundled, true, "langchain reference bundled posture mismatch");
-  assert.strictEqual(langchainReferenceManifest.certification_contract.certification_state, "reference_example", "langchain reference certification mismatch");
-  assert.strictEqual(
-    minimalThirdPartyExecutionRegistrationRecord.integration_id,
-    minimalThirdPartyExecutionManifest.adapter_id,
-    "minimal third-party execution registration integration_id mismatch"
-  );
-  assert.strictEqual(
-    minimalThirdPartyExecutionCertificationPack.integration_id,
-    minimalThirdPartyExecutionRegistrationRecord.integration_id,
-    "minimal third-party execution certification integration_id mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationCertificationPack(minimalThirdPartyExecutionCertificationPack).ok,
-    true,
-    "minimal third-party execution certification pack validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmission(minimalThirdPartyExecutionManifest, minimalThirdPartyExecutionRegistrationRecord, minimalThirdPartyExecutionCertificationPack).ok,
-    true,
-    "minimal third-party execution submission validation mismatch"
-  );
-  assert.strictEqual(
-    validateIntegrationSubmissionBundle(minimalThirdPartyExecutionSubmissionBundle).ok,
-    true,
-    "minimal third-party execution submission bundle validation mismatch"
-  );
-  assert.strictEqual(
-    createIntegrationSubmissionBundle(minimalThirdPartyExecutionSubmissionBundle, {
-      source: "third_party_example",
-      protocols: [],
-      execution_backends: ["http"],
-      adapter_lanes: ["http"],
-      task_refs: ["task.execute", "task.preview"]
-    }).snapshot_entry.integration_id,
-    "partner.execution.minimal_echo",
-    "minimal third-party execution submission bundle normalization mismatch"
-  );
-  assert.strictEqual(
-    createIntegrationSubmissionBundle(exampleIdentitySubmissionBundle, {
-      source: "third_party_example",
-      protocols: [],
-      execution_backends: ["http", "chain"],
-      adapter_lanes: ["http", "chain"],
-      task_refs: ["registry.register", "trust.handoff.emit", "trust.handoff.validate"]
-    }).snapshot_entry.integration_id,
-    "partner.identity.attest_registry",
-    "identity submission bundle normalization mismatch"
-  );
-  assert.strictEqual(
-    createIntegrationSubmissionBundle(exampleSubmissionBundle, {
-      source: "third_party_example",
-      protocols: ["mcp"],
-      execution_backends: ["mcp"],
-      adapter_lanes: ["mcp"],
-      task_refs: ["adapter.mcp.invoke"]
-    }).snapshot_entry.integration_id,
-    "partner.protocol.acme_mcp",
-    "submission bundle normalization mismatch"
-  );
-
-  const implementationErrors = validateAdapterImplementation(exampleAdapter);
-  assert.deepStrictEqual(implementationErrors, [], `adapter implementation validation failed:\n${implementationErrors.join("\n")}`);
-  assert.deepStrictEqual(exampleAdapter.manifest, exampleManifest, "example adapter manifest/export mismatch");
-  const minimalImplementationErrors = validateAdapterImplementation(minimalThirdPartyExecutionAdapter);
-  assert.deepStrictEqual(minimalImplementationErrors, [], `minimal execution adapter implementation validation failed:\n${minimalImplementationErrors.join("\n")}`);
-  assert.deepStrictEqual(
-    minimalThirdPartyExecutionAdapter.manifest,
-    minimalThirdPartyExecutionManifest,
-    "minimal third-party execution adapter manifest/export mismatch"
-  );
-  const langgraphImplementationErrors = validateAdapterImplementation(langgraphReferenceAdapter);
-  assert.deepStrictEqual(langgraphImplementationErrors, [], `langgraph reference adapter implementation validation failed:\n${langgraphImplementationErrors.join("\n")}`);
-  assert.deepStrictEqual(langgraphReferenceAdapter.manifest, langgraphReferenceManifest, "langgraph reference adapter manifest/export mismatch");
-  const langchainImplementationErrors = validateAdapterImplementation(langchainReferenceAdapter);
-  assert.deepStrictEqual(langchainImplementationErrors, [], `langchain reference adapter implementation validation failed:\n${langchainImplementationErrors.join("\n")}`);
-  assert.deepStrictEqual(langchainReferenceAdapter.manifest, langchainReferenceManifest, "langchain reference adapter manifest/export mismatch");
-  const settlementImplementationErrors = validateAdapterImplementation(exampleSettlementAdapter);
-  assert.deepStrictEqual(
-    settlementImplementationErrors,
-    [],
-    `settlement adapter implementation validation failed:\n${settlementImplementationErrors.join("\n")}`
-  );
-  assert.deepStrictEqual(
-    exampleSettlementAdapter.manifest,
-    exampleSettlementManifest,
-    "example settlement adapter manifest/export mismatch"
-  );
-
-  const health = await exampleAdapter.getHealth();
-  assert.strictEqual(health.status, "ok", "example adapter health mismatch");
-  assert.strictEqual(health.adapter_id, exampleManifest.adapter_id, "example adapter health adapter_id mismatch");
-
-  const capabilities = exampleAdapter.describeCapabilities();
-  assert.deepStrictEqual(capabilities.capabilities, exampleManifest.capabilities, "example adapter capabilities mismatch");
-
-  const preview = await exampleAdapter.preview({
-    task_ref: "trust.verify",
-    body: { subject_id: "subject-1" }
-  });
-  assert.strictEqual(preview.accepted, true, "example adapter preview acceptance mismatch");
-  assert.strictEqual(preview.preview.task_ref, "trust.verify", "example adapter preview task_ref mismatch");
-
-  const minimalHealth = await minimalThirdPartyExecutionAdapter.getHealth();
-  assert.strictEqual(minimalHealth.status, "ok", "minimal execution adapter health mismatch");
-  assert.strictEqual(minimalHealth.adapter_id, minimalThirdPartyExecutionManifest.adapter_id, "minimal execution adapter health adapter_id mismatch");
-
-  const minimalPreview = await minimalThirdPartyExecutionAdapter.preview({
-    task_ref: "task.execute",
-    body: { subject_id: "subject-minimal-1" }
-  });
-  assert.strictEqual(minimalPreview.accepted, true, "minimal execution adapter preview acceptance mismatch");
-  assert.strictEqual(minimalPreview.preview.task_ref, "task.execute", "minimal execution adapter preview task_ref mismatch");
-
-  const minimalExecution = await minimalThirdPartyExecutionAdapter.execute({
-    task_ref: "task.execute",
-    body: { subject_id: "subject-minimal-1" }
-  });
-  assert.strictEqual(minimalExecution.status, "completed", "minimal execution adapter execute status mismatch");
-  assert.strictEqual(
-    minimalExecution.proof_facts.emits_proof_compatible_facts,
-    true,
-    "minimal execution adapter execute proof contract mismatch"
-  );
-
-  const langgraphHealth = await langgraphReferenceAdapter.getHealth();
-  assert.strictEqual(langgraphHealth.status, "ok", "langgraph reference health mismatch");
-  const langgraphExecution = await langgraphReferenceAdapter.execute({
-    task_ref: "framework.langgraph.execute",
-    body: {
-      graph_ref: "graph.demo",
-      node_ref: "summarize",
-      checkpoint_ref: "checkpoint.demo",
-      input: { text: "demo" }
-    }
-  });
-  assert.strictEqual(langgraphExecution.status, "completed", "langgraph reference execution status mismatch");
-  assert.strictEqual(langgraphExecution.result.framework, "langgraph", "langgraph reference framework mismatch");
-  assert.strictEqual(langgraphExecution.proof_facts.graph_ref, "graph.demo", "langgraph proof graph ref mismatch");
-
-  const langchainHealth = await langchainReferenceAdapter.getHealth();
-  assert.strictEqual(langchainHealth.status, "ok", "langchain reference health mismatch");
-  const langchainExecution = await langchainReferenceAdapter.execute({
-    task_ref: "framework.langchain.execute",
-    body: {
-      chain_ref: "chain.demo",
-      tool_trace_ref: "trace.demo",
-      context_ref: "context.demo",
-      input: { text: "demo" }
-    }
-  });
-  assert.strictEqual(langchainExecution.status, "completed", "langchain reference execution status mismatch");
-  assert.strictEqual(langchainExecution.result.framework, "langchain", "langchain reference framework mismatch");
-  assert.strictEqual(langchainExecution.proof_facts.chain_ref, "chain.demo", "langchain proof chain ref mismatch");
-
-  const execution = await exampleAdapter.execute({
-    task_ref: "trust.verify",
-    body: { subject_id: "subject-1" }
-  });
-  assert.strictEqual(execution.status, "completed", "example adapter execute status mismatch");
-  assert.strictEqual(
-    execution.proof_facts.emits_proof_compatible_facts,
-    true,
-    "example adapter execute proof contract mismatch"
-  );
-
-  const settlementHealth = await exampleSettlementAdapter.getHealth();
-  assert.strictEqual(settlementHealth.status, "ok", "example settlement adapter health mismatch");
-  assert.strictEqual(settlementHealth.adapter_id, exampleSettlementManifest.adapter_id, "example settlement adapter health adapter_id mismatch");
-
-  const settlementCapabilities = exampleSettlementAdapter.describeCapabilities();
-  assert.deepStrictEqual(
-    settlementCapabilities.capabilities,
-    exampleSettlementManifest.capabilities,
-    "example settlement adapter capabilities mismatch"
-  );
-
-  const settlementResult = await exampleSettlementAdapter.settle({
-    intent_id: "intent-demo"
-  });
-  assert.strictEqual(settlementResult.status, "submitted", "example settlement adapter settle status mismatch");
-  assert.strictEqual(
-    settlementResult.proof_facts.emits_proof_compatible_facts,
-    true,
-    "example settlement adapter proof contract mismatch"
-  );
-
-  const finality = await exampleSettlementAdapter.getFinality(settlementResult.settlement_ref);
-  assert.strictEqual(finality.finality_status, "confirmed", "example settlement adapter finality mismatch");
-
-  process.stdout.write("xytara verify:adapters passed\n");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});