@intentrax/sdk 1.0.0

package/index.ts

@@ -0,0 +1,626 @@
+import { createHash } from "node:crypto";
+
+export const SDK_VERSION = "1.0.0";
+export const API_VERSION = "v1";
+export const VERIFY_REQUEST_HASH_DOMAIN = "INTENTRAX_PUBLIC_SDK_VERIFY_REQUEST_V1";
+export const IDEMPOTENCY_KEY_DOMAIN = "INTENTRAX_PUBLIC_SDK_IDEMPOTENCY_V1";
+export const AGENT_GATEWAY_ADMISSION_REQUEST_HASH_DOMAIN = "INTENTRAX_AGENT_GATEWAY_ADMISSION_REQUEST_V1";
+export const AGENT_ADMISSION_SCHEMA_VERSION = "intentrax.runtime.agent_admission_request/1.0";
+export const AGENT_ADMISSION_ENDPOINT = "/v1/agent/admissions";
+// Live intent execution lane. The schema_version below is the exact string the
+// engine's intentexecute.DecodeRequest requires; the endpoint is fail-closed
+// (HTTP 423 until LiveExecutionEnabled, HTTP 403 until the tenant is
+// allowlisted). See engine/internal/runtime/intentexecute/intentexecute.go.
+export const INTENT_EXECUTE_REQUEST_SCHEMA_VERSION = "intentrax.runtime.intent_execute.request/1.0";
+export const INTENT_EXECUTE_ENDPOINT = "/v1/intents/execute";
+// Mirrors intentexecute.MaxRequestBytes: the engine rejects a canonical body
+// larger than this with HTTP 400.
+export const INTENT_EXECUTE_MAX_REQUEST_BYTES = 4096;
+export const RECEIPT_VERIFICATION_REQUEST_SCHEMA_VERSION = "intentrax.runtime.proof_verification.request/1.0";
+export const RECEIPT_VERIFICATION_ENDPOINT = "/v1/proofs/verify";
+export const RECEIPT_VERIFICATION_REQUEST_HASH_DOMAIN = "INTENTRAX_RECEIPT_VERIFICATION_REQUEST_V1";
+export const RECEIPT_VERIFICATION_IDEMPOTENCY_DOMAIN = "INTENTRAX_RECEIPT_VERIFICATION_IDEMPOTENCY_V1";
+export const PROOF_EXPORT_ENDPOINT_PREFIX = "/v1/proofs";
+export const PROOF_REPLAY_REQUEST_SCHEMA_VERSION = "intentrax.runtime.proof_replay.request/1.0";
+export const PROOF_REPLAY_ENDPOINT = "/v1/proofs/replay";
+export const VERIFIER_HANDOFF_ENDPOINT_PREFIX = "/v1/evidence/dry-run";
+export const SDK_INPUT_ERROR_CODE = "INTX-SDK-INPUT-001";
+
+const REQUIRED_FIELDS = [
+  "action",
+  "execution_id",
+  "intent_id",
+  "payload_hash",
+  "principal_id",
+  "proof_id",
+  "request_body_hash",
+  "request_method",
+  "request_path",
+  "required_tier",
+  "timestamp",
+];
+
+const AGENT_ADMISSION_REQUIRED_FIELDS = [
+  "schema_version",
+  "tenant_id",
+  "surface_id",
+  "action",
+  "adapter_id",
+  "evidence_refs",
+  "proof_refs",
+  "request_payload_hash",
+  "protocol_payload_ref",
+  "idempotency_key_hash",
+];
+
+// The engine decodes exactly these six fields with DisallowUnknownFields, so
+// any extra field is a 400. The order here is the sorted invalid-field order
+// the engine's validateRequest emits.
+const INTENT_EXECUTE_REQUIRED_FIELDS = [
+  "schema_version",
+  "intent_id",
+  "tenant_id",
+  "action",
+  "idempotency_key",
+  "proof_chain_fixture_ref",
+];
+
+const RECEIPT_VERIFICATION_REQUIRED_FIELDS = [
+  "schema_version",
+  "receipt_id",
+  "receipt_hash",
+  "evidence_record_hash",
+  "handoff_hash",
+  "proof_chain_fixture_ref",
+  "proof_chain_fixture_hash",
+];
+
+const VALID_TIERS = new Set(["TIER_1", "TIER_2", "TIER_3", "TIER_4"]);
+const PROOF_EXPORT_FORMATS = new Set(["json", "aep-json", "pdf"]);
+const SHA256_RE = /^[a-f0-9]{64}$/;
+const SHA256_REF_RE = /^sha256:[a-f0-9]{64}$/;
+
+export function sha256Hex(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+export function isSha256Hex(value) {
+  return typeof value === "string" && SHA256_RE.test(value);
+}
+
+export function isSha256Ref(value) {
+  return typeof value === "string" && SHA256_REF_RE.test(value);
+}
+
+export function canonicalJson(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map((item) => canonicalJson(item)).join(",") + "]";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    return "{" + Object.keys(value).sort().map((key) => {
+      const member = value[key];
+      if (member === undefined) {
+        throw new Error("canonical_json: undefined member " + key);
+      }
+      return JSON.stringify(key) + ":" + canonicalJson(member);
+    }).join(",") + "}";
+  }
+  throw new Error("canonical_json: unsupported value");
+}
+
+export function validateVerificationRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["verification_request"];
+  }
+  for (const field of REQUIRED_FIELDS) {
+    if (typeof request[field] !== "string" || request[field].length === 0) {
+      invalid.push(field);
+    }
+  }
+  if (!isSha256Hex(request.payload_hash)) {
+    invalid.push("payload_hash");
+  }
+  if (!isSha256Hex(request.request_body_hash)) {
+    invalid.push("request_body_hash");
+  }
+  if (!VALID_TIERS.has(request.required_tier)) {
+    invalid.push("required_tier");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function verificationRequestHash(request) {
+  return sha256Hex(VERIFY_REQUEST_HASH_DOMAIN + canonicalJson(request));
+}
+
+export function idempotencyInput(request) {
+  return {
+    payload_hash: request.payload_hash,
+    proof_id: request.proof_id,
+    request_body_hash: request.request_body_hash,
+    request_method: request.request_method,
+    request_path: request.request_path,
+  };
+}
+
+export function createIdempotencyKey(request) {
+  return sha256Hex(IDEMPOTENCY_KEY_DOMAIN + canonicalJson(idempotencyInput(request)));
+}
+
+export function buildVerificationEnvelope(request) {
+  const invalidFields = validateVerificationRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Verification request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.verify/1.0",
+      request_hash: verificationRequestHash(request),
+      idempotency_key: createIdempotencyKey(request),
+      request,
+    },
+  };
+}
+
+export function validateReceiptVerificationRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["receipt_verification_request"];
+  }
+  for (const field of RECEIPT_VERIFICATION_REQUIRED_FIELDS) {
+    if (!(field in request)) {
+      invalid.push(field);
+    }
+  }
+  if (request.schema_version !== RECEIPT_VERIFICATION_REQUEST_SCHEMA_VERSION) {
+    invalid.push("schema_version");
+  }
+  if (!isSafeReceiptID(request.receipt_id)) {
+    invalid.push("receipt_id");
+  }
+  for (const field of ["receipt_hash", "evidence_record_hash", "handoff_hash", "proof_chain_fixture_hash"]) {
+    if (!isSha256Hex(request[field])) {
+      invalid.push(field);
+    }
+  }
+  if (typeof request.proof_chain_fixture_ref !== "string" ||
+      request.proof_chain_fixture_ref.length === 0 ||
+      request.proof_chain_fixture_ref.trim() !== request.proof_chain_fixture_ref ||
+      request.proof_chain_fixture_ref.includes("..")) {
+    invalid.push("proof_chain_fixture_ref");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function receiptVerificationRequestHash(request) {
+  return sha256Hex(RECEIPT_VERIFICATION_REQUEST_HASH_DOMAIN + canonicalJson(request));
+}
+
+export function receiptVerificationIdempotencyInput(request) {
+  return {
+    evidence_record_hash: request.evidence_record_hash,
+    handoff_hash: request.handoff_hash,
+    proof_chain_fixture_hash: request.proof_chain_fixture_hash,
+    proof_chain_fixture_ref: request.proof_chain_fixture_ref,
+    receipt_hash: request.receipt_hash,
+    receipt_id: request.receipt_id,
+  };
+}
+
+export function createReceiptVerificationIdempotencyKey(request) {
+  return sha256Hex(RECEIPT_VERIFICATION_IDEMPOTENCY_DOMAIN + canonicalJson(receiptVerificationIdempotencyInput(request)));
+}
+
+export function buildReceiptVerificationEnvelope(request) {
+  const invalidFields = validateReceiptVerificationRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Receipt verification request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.receipt_verification/1.0",
+      endpoint: RECEIPT_VERIFICATION_ENDPOINT,
+      request_hash: receiptVerificationRequestHash(request),
+      idempotency_key: createReceiptVerificationIdempotencyKey(request),
+      request,
+    },
+  };
+}
+
+export function normalizeProofExportFormat(format) {
+  if (format === undefined || format === null || format === "") {
+    return "json";
+  }
+  return String(format).toLowerCase();
+}
+
+export function validateProofExportRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["proof_export_request"];
+  }
+  if (!isSafeProofID(request.proof_id)) {
+    invalid.push("proof_id");
+  }
+  if (!PROOF_EXPORT_FORMATS.has(normalizeProofExportFormat(request.format))) {
+    invalid.push("format");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function buildProofExportEnvelope(request) {
+  const invalidFields = validateProofExportRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Proof export request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  const format = normalizeProofExportFormat(request.format);
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.proof_export/1.0",
+      endpoint: `${PROOF_EXPORT_ENDPOINT_PREFIX}/${request.proof_id}/export`,
+      format,
+      authoritative_json: format !== "pdf",
+      pdf_receipt_non_authoritative: format === "pdf",
+      request: {
+        proof_id: request.proof_id,
+        format,
+      },
+    },
+  };
+}
+
+export function validateProofReadRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["proof_read_request"];
+  }
+  if (!isSafeProofID(request.proof_id)) {
+    invalid.push("proof_id");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function buildProofReadEnvelope(request) {
+  const invalidFields = validateProofReadRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Proof read request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.proof_read/1.0",
+      endpoint: `${PROOF_EXPORT_ENDPOINT_PREFIX}/${request.proof_id}`,
+      request: {
+        proof_id: request.proof_id,
+      },
+    },
+  };
+}
+
+export function validateProofReplayRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["proof_replay_request"];
+  }
+  if (request.schema_version !== PROOF_REPLAY_REQUEST_SCHEMA_VERSION) {
+    invalid.push("schema_version");
+  }
+  if (!isSafeProofID(request.proof_id)) {
+    invalid.push("proof_id");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function buildProofReplayEnvelope(request) {
+  const invalidFields = validateProofReplayRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Proof replay request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.proof_replay/1.0",
+      endpoint: PROOF_REPLAY_ENDPOINT,
+      request,
+    },
+  };
+}
+
+export function validateProofInclusionRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["proof_inclusion_request"];
+  }
+  if (!isSafeProofID(request.proof_id)) {
+    invalid.push("proof_id");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function buildProofInclusionEnvelope(request) {
+  const invalidFields = validateProofInclusionRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Proof inclusion request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.proof_inclusion/1.0",
+      endpoint: `${PROOF_EXPORT_ENDPOINT_PREFIX}/${request.proof_id}/inclusion`,
+      request: {
+        proof_id: request.proof_id,
+      },
+    },
+  };
+}
+
+export function validateVerifierHandoffRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["verifier_handoff_request"];
+  }
+  if (!isSafeReceiptID(request.receipt_id)) {
+    invalid.push("receipt_id");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+export function buildVerifierHandoffEnvelope(request) {
+  const invalidFields = validateVerifierHandoffRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Verifier handoff request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.verifier_handoff/1.0",
+      endpoint: `${VERIFIER_HANDOFF_ENDPOINT_PREFIX}/${request.receipt_id}/verifier-handoff`,
+      request: {
+        receipt_id: request.receipt_id,
+      },
+    },
+  };
+}
+
+export function validateAgentGatewayAdmissionRequest(request) {
+  const invalid = [];
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["agent_admission_request"];
+  }
+  for (const field of AGENT_ADMISSION_REQUIRED_FIELDS) {
+    if (!(field in request)) {
+      invalid.push(field);
+    }
+  }
+  for (const field of ["tenant_id", "surface_id", "action", "adapter_id"]) {
+    if (typeof request[field] !== "string" || request[field].length === 0) {
+      invalid.push(field);
+    }
+  }
+  if (request.schema_version !== AGENT_ADMISSION_SCHEMA_VERSION) {
+    invalid.push("schema_version");
+  }
+  for (const field of ["evidence_refs", "proof_refs"]) {
+    if (!Array.isArray(request[field]) || request[field].length === 0 || request[field].some((ref) => !isSha256Ref(ref))) {
+      invalid.push(field);
+    }
+  }
+  if (!isSha256Hex(request.request_payload_hash)) {
+    invalid.push("request_payload_hash");
+  }
+  if (!isSha256Ref(request.protocol_payload_ref)) {
+    invalid.push("protocol_payload_ref");
+  }
+  if (!isSha256Hex(request.idempotency_key_hash)) {
+    invalid.push("idempotency_key_hash");
+  }
+  return [...new Set(invalid)].sort();
+}
+
+function isNonEmptyStable(value) {
+  return typeof value === "string" && value.length > 0 && value.trim() === value;
+}
+
+// Mirrors engine intentexecute.isUpperSnake: UPPER_SNAKE over [A-Z0-9_] with no
+// leading/trailing whitespace and no "__" run.
+function isUpperSnakeAction(value) {
+  return isNonEmptyStable(value) && /^[A-Z0-9_]+$/.test(value) && !value.includes("__");
+}
+
+function isSafeReceiptID(value) {
+  return typeof value === "string" && /^[A-Za-z0-9_-]+$/.test(value);
+}
+
+function isSafeProofID(value) {
+  return typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= 128 &&
+    value.trim() === value &&
+    !value.includes("..") &&
+    !value.includes("\u0000") &&
+    /^[A-Za-z0-9_.-]+$/.test(value);
+}
+
+export function agentGatewayAdmissionRequestHash(request) {
+  return sha256Hex(AGENT_GATEWAY_ADMISSION_REQUEST_HASH_DOMAIN + canonicalJson(request));
+}
+
+export function buildAgentGatewayAdmissionEnvelope(request) {
+  const invalidFields = validateAgentGatewayAdmissionRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Agent Gateway admission request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.agent_gateway_admission/1.0",
+      request_hash: agentGatewayAdmissionRequestHash(request),
+      idempotency_key_hash: request.idempotency_key_hash,
+      endpoint: AGENT_ADMISSION_ENDPOINT,
+      request,
+    },
+  };
+}
+
+// validateIntentExecuteRequest mirrors the engine's intentexecute.validateRequest
+// (and its DecodeRequest strictness): exactly the six fields, an UPPER_SNAKE
+// action, and a canonical body no larger than the engine's limit. It computes
+// NO proof/hash truth — receipt_id, request_hash, registry_proof_id, and
+// response_hash are the engine's to produce.
+export function validateIntentExecuteRequest(request) {
+  if (request === null || typeof request !== "object" || Array.isArray(request)) {
+    return ["intent_execute_request"];
+  }
+  const invalid = [];
+  // Unknown fields are a 400 at the engine (DisallowUnknownFields); reject them
+  // here too so the SDK never emits a body the engine would refuse.
+  for (const key of Object.keys(request)) {
+    if (!INTENT_EXECUTE_REQUIRED_FIELDS.includes(key)) {
+      invalid.push("body");
+    }
+  }
+  if (request.schema_version !== INTENT_EXECUTE_REQUEST_SCHEMA_VERSION) {
+    invalid.push("schema_version");
+  }
+  if (!isNonEmptyStable(request.intent_id)) {
+    invalid.push("intent_id");
+  }
+  if (!isNonEmptyStable(request.tenant_id)) {
+    invalid.push("tenant_id");
+  }
+  if (!isUpperSnakeAction(request.action)) {
+    invalid.push("action");
+  }
+  // idempotency_key is a caller-supplied OPAQUE body field. It is NOT hashed by
+  // the SDK; the engine derives RequestHash over the whole canonical body.
+  if (!isNonEmptyStable(request.idempotency_key)) {
+    invalid.push("idempotency_key");
+  }
+  if (!isNonEmptyStable(request.proof_chain_fixture_ref)) {
+    invalid.push("proof_chain_fixture_ref");
+  }
+  if (invalid.every((field) => field !== "body")) {
+    const canonicalBytes = Buffer.byteLength(canonicalJson(request), "utf8");
+    if (canonicalBytes > INTENT_EXECUTE_MAX_REQUEST_BYTES) {
+      invalid.push("body");
+    }
+  }
+  return [...new Set(invalid)].sort();
+}
+
+// buildIntentExecuteEnvelope is a THIN envelope builder: it validates and
+// passes the caller-supplied body through verbatim. It performs no hashing and
+// asserts no proof truth.
+export function buildIntentExecuteEnvelope(request) {
+  const invalidFields = validateIntentExecuteRequest(request);
+  if (invalidFields.length > 0) {
+    return {
+      status: "FAIL",
+      error: {
+        error_code: SDK_INPUT_ERROR_CODE,
+        error_type: "public_sdk_input_error",
+        message: "Intent execute request is missing or malformed.",
+        invalid_fields: invalidFields,
+        retriable: false,
+      },
+    };
+  }
+  return {
+    status: "PASS",
+    output: {
+      schema_version: "intentrax.public_sdk.intent_execute/1.0",
+      endpoint: INTENT_EXECUTE_ENDPOINT,
+      // Passthrough of the caller-supplied body. No client-computed
+      // request_hash/receipt_id: those are returned verbatim from the engine.
+      request,
+    },
+  };
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@intentrax/sdk",
+  "version": "1.0.0",
+  "description": "Intentrax deterministic public SDK for proof verification and API-wrapper execution.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "scripts": {
+    "test": "node conformance.test.mjs"
+  },
+  "bin": {
+    "intentrax": "./cli/intentrax.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./http": {
+      "types": "./http.d.ts",
+      "default": "./http.js"
+    }
+  },
+  "types": "./index.d.ts",
+  "files": [
+    "LICENSE",
+    "cli/intentrax.mjs",
+    "examples",
+    "index.js",
+    "index.ts",
+    "index.d.ts",
+    "http.js",
+    "http.ts",
+    "http.d.ts",
+    "README.md"
+  ],
+  "keywords": [
+    "intentrax",
+    "aep",
+    "eeo",
+    "proof-verification",
+    "deterministic-ai",
+    "mcp"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Adelodun-Adejare/Intentrax.git",
+    "directory": "sdk/typescript"
+  },
+  "homepage": "https://intentrax.dev",
+  "bugs": {
+    "url": "https://github.com/Adelodun-Adejare/Intentrax/issues"
+  },
+  "intentrax": {
+    "sharedSpec": "../shared-specs/public-sdk-conformance.v1.json"
+  }
+}