xytara 2.6.0 → 2.8.0

package/scripts/verify_examples.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+function runExample(scriptPath) {
+  const result = spawnSync(process.execPath, [scriptPath], {
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    process.exit(result.status || 1);
+  }
+}
+
+runExample(path.join(__dirname, "..", "examples", "quickstart.js"));
+runExample(path.join(__dirname, "..", "examples", "export_carried_handoff.js"));
+runExample(path.join(__dirname, "..", "examples", "partner_launch_walkthrough.js"));
+runExample(path.join(__dirname, "..", "examples", "funded_runtime_walkthrough.js"));
+runExample(path.join(__dirname, "..", "examples", "adapter_review_walkthrough.js"));

package/scripts/verify_framework_provider_promotion.js

@@ -0,0 +1,152 @@
+"use strict";
+
+const assert = require("assert");
+const {
+  FRAMEWORK_PROVIDER_CANDIDATES,
+  buildFrameworkProviderPromotionPack,
+  summarizeFrameworkProviderPromotionPack,
+  validateFrameworkProviderPromotionEvidence
+} = require("../lib/framework_provider_promotion");
+
+function normalizeUrl(baseUrl, healthPath) {
+  const url = new URL(baseUrl);
+  const normalizedPath = String(healthPath || "/health").startsWith("/")
+    ? String(healthPath || "/health")
+    : `/${healthPath}`;
+  url.pathname = normalizedPath;
+  return url.toString();
+}
+
+async function checkHealth(candidate, env) {
+  const endpoint = env[candidate.endpoint_env];
+  const token = env[candidate.auth_env];
+  const healthPath = env[candidate.health_path_env] || "/health";
+  const started = Date.now();
+  const response = await fetch(normalizeUrl(endpoint, healthPath), {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+  const latencyMs = Date.now() - started;
+  let body = null;
+  try {
+    body = await response.json();
+  } catch (_error) {
+    body = null;
+  }
+  return {
+    framework_id: candidate.framework_id,
+    adapter_id: candidate.adapter_id,
+    status_code: response.status,
+    latency_ms: latencyMs,
+    health_ok: response.ok && (!body || ["ok", "ready", "auth_required"].includes(String(body.status || body.readiness || "ok"))),
+    body_status: body && (body.status || body.readiness || null)
+  };
+}
+
+function buildValidPromotionEvidence(candidateSummary) {
+  return {
+    framework_id: candidateSummary.framework_id,
+    adapter_id: candidateSummary.adapter_id,
+    task_ref: candidateSummary.task_ref,
+    operator_evidence_ref: `ops.framework_provider.${candidateSummary.framework_id}.2026-04-22`,
+    auth_boundary_ref: `ops.framework_provider.auth_boundary.${candidateSummary.framework_id}.2026-04-22`,
+    health_check: {
+      status_code: 200,
+      health_ok: true
+    },
+    latency_ms: 250,
+    latency_budget_ms: 2000,
+    failure_behavior_ref: `ops.framework_provider.failure_behavior.${candidateSummary.framework_id}.2026-04-22`,
+    proof_fact_shape_ref: `ops.framework_provider.proof_facts.${candidateSummary.framework_id}.2026-04-22`
+  };
+}
+
+function assertRejected(pack, evidence, expectedCode) {
+  const validation = validateFrameworkProviderPromotionEvidence(pack, evidence);
+  assert.strictEqual(validation.promotion_allowed, false, `expected ${expectedCode} to block framework provider promotion`);
+  assert.strictEqual(
+    validation.rejection_codes.includes(expectedCode),
+    true,
+    `missing deterministic rejection code ${expectedCode}`
+  );
+  return validation;
+}
+
+async function main() {
+  const pack = buildFrameworkProviderPromotionPack();
+  const summary = summarizeFrameworkProviderPromotionPack();
+  assert.strictEqual(pack.ok, true, "framework provider promotion pack failed");
+  assert.strictEqual(summary.framework_candidate_count, FRAMEWORK_PROVIDER_CANDIDATES.length, "framework candidate count mismatch");
+  assert.strictEqual(pack.promoted_provider_count, 0, "promotion pack must not auto-promote providers");
+  assert.strictEqual(pack.deterministic_rejection_codes.length >= 13, true, "framework promotion rejection codes missing");
+  assert.strictEqual(summary.deterministic_rejection_code_count, pack.deterministic_rejection_codes.length, "framework promotion summary rejection code count mismatch");
+  assert.strictEqual(
+    pack.strict_boundaries.includes("reference_framework_adapters_do_not_equal_live_provider_integrations"),
+    true,
+    "framework reference boundary missing"
+  );
+
+  assertRejected(pack, buildValidPromotionEvidence(pack.candidates[0]), "candidate_not_live_check_ready");
+  assertRejected(pack, { framework_id: "unknown_framework" }, "framework_not_registered");
+
+  const syntheticEnv = {
+    XYTARA_LANGGRAPH_PROVIDER_URL: "https://provider.example.test",
+    XYTARA_LANGGRAPH_PROVIDER_TOKEN: "configured-token-placeholder",
+    XYTARA_LANGGRAPH_PROVIDER_HEALTH_PATH: "/health"
+  };
+  const promotablePack = buildFrameworkProviderPromotionPack({ env: syntheticEnv });
+  const promotableCandidate = promotablePack.candidates.find((candidate) => candidate.framework_id === "langgraph");
+  const validEvidence = buildValidPromotionEvidence(promotableCandidate);
+  const validValidation = validateFrameworkProviderPromotionEvidence(promotablePack, validEvidence);
+  assert.strictEqual(promotableCandidate.state, "live_check_ready", "synthetic provider should be live-check ready");
+  assert.strictEqual(validValidation.promotion_allowed, true, "complete synthetic evidence should validate");
+  assert.deepStrictEqual(validValidation.rejection_codes, [], "complete synthetic evidence should not carry rejections");
+
+  assertRejected(promotablePack, { ...validEvidence, adapter_id: "wrong.adapter" }, "adapter_id_mismatch");
+  assertRejected(promotablePack, { ...validEvidence, task_ref: "wrong.task" }, "task_ref_mismatch");
+  assertRejected(promotablePack, { ...validEvidence, operator_evidence_ref: null }, "operator_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, auth_boundary_ref: null }, "auth_boundary_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, health_check: null }, "health_check_missing");
+  assertRejected(promotablePack, { ...validEvidence, health_check: { status_code: 503, health_ok: false } }, "health_check_failed");
+  assertRejected(promotablePack, { ...validEvidence, latency_ms: null }, "latency_measurement_missing");
+  assertRejected(promotablePack, { ...validEvidence, latency_ms: 3000, latency_budget_ms: 1000 }, "latency_budget_exceeded");
+  assertRejected(promotablePack, { ...validEvidence, failure_behavior_ref: null }, "failure_behavior_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, proof_fact_shape_ref: null }, "proof_fact_shape_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, provider_token: "sk_live_accidental_secret" }, "secret_material_forbidden");
+
+  const readyCandidates = pack.candidates.filter((candidate) => candidate.state === "live_check_ready");
+  if (pack.require_live) {
+    assert.strictEqual(readyCandidates.length > 0, true, "live provider promotion required but no endpoint/auth pair is configured");
+  }
+
+  const live_checks = [];
+  for (const candidate of FRAMEWORK_PROVIDER_CANDIDATES) {
+    const candidateSummary = pack.candidates.find((entry) => entry.framework_id === candidate.framework_id);
+    if (!candidateSummary || candidateSummary.state !== "live_check_ready") continue;
+    const result = await checkHealth(candidate, process.env);
+    assert.strictEqual(result.health_ok, true, `${candidate.framework_id} live health check failed`);
+    live_checks.push(result);
+  }
+
+  const result = {
+    ok: true,
+    product: "xytara",
+    category: "xytara-framework-provider-promotion-verification",
+    status: live_checks.length > 0 ? "live_provider_health_checks_passed" : "no_live_provider_evidence_configured",
+    live_check_count: live_checks.length,
+    promotion_allowed: false,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
+    adversarial_case_count: 13,
+    live_checks,
+    boundary: "this_verifier_checks_promotion_evidence_but_does_not_promote_reference_adapters_to_live_provider_claims"
+  };
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});