@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
181 lines (170 loc) • 7.14 kB
text/typescript
import { readFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import { fixtureDigest } from "./digest";
import { MCP_ACTION_TOKENS } from "./mcp-stub";
import type {
CaseAuthority,
CaseRecord,
FailureClassification,
FailureRule,
} from "./types";
import { CL01_SUITES, SYNTHETIC_MARKER } from "./types";
const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
// Provenance is the normative CL-00 authority name, not the runtime copy's basename.
const AUTHORITY_FILE = "022_protocol_v1_cases.json";
export function loadCaseAuthority(): CaseAuthority {
const path = join(MODULE_DIR, "fixtures", "protocol-v1-cases.json");
const raw = JSON.parse(readFileSync(path, "utf8")) as CaseAuthority;
validateAuthority(raw);
return raw;
}
export function discoverScenarios(
authority: CaseAuthority,
suites: readonly string[] = CL01_SUITES,
): CaseRecord[] {
return authority.cases.filter((c) => suites.includes(c.suite));
}
export function expandScenario(caseRecord: CaseRecord, authority: CaseAuthority): Record<string, unknown> {
const defaults = authority.manifestDefaults;
const fixtures = caseRecord.initiatingRequest
? [fixtureRef(caseRecord.initiatingRequest, authority), fixtureRef(caseRecord.fixture, authority)]
: [fixtureRef(caseRecord.fixture, authority)];
return {
schemaVersion: authority.schemaVersion,
id: caseRecord.id,
version: defaults.version,
suite: {
id: caseRecord.suite,
version: defaults.suiteVersion,
evidenceLayer: defaults.evidenceLayer,
},
evidenceLayer: defaults.evidenceLayer,
capability: caseRecord.capability,
verificationRole: caseRecord.verificationRole ?? defaults.verificationRole,
requirements: caseRecord.requirements,
fixtures,
executionLimits: defaults.executionLimits,
assertions: caseRecord.assertions,
...(caseRecord.expectedFailure ? { expectedFailure: caseRecord.expectedFailure } : {}),
failureRules: expandFailureRules(caseRecord, authority),
artifactPolicy: defaults.artifactPolicy,
freshness: defaults.freshness,
};
}
function fixtureRef(fixture: CaseRecord["fixture"], authority: CaseAuthority): Record<string, unknown> {
const bytes = new TextEncoder().encode(fixture.bytesUtf8);
return {
id: fixture.id,
role: fixture.role,
mediaType: fixture.mediaType,
digest: fixture.digest,
byteLength: bytes.byteLength,
syntheticMarker: SYNTHETIC_MARKER,
provenance: {
kind: "lab_authored",
authority: AUTHORITY_FILE,
sourceCommit: authority.sourceCommit,
},
};
}
function expandFailureRules(caseRecord: CaseRecord, authority: CaseAuthority): FailureRule[] {
const setName = authority.manifestDefaults.failureRuleSet;
const ruleSet = authority.failureRuleSets[setName];
if (!Array.isArray(ruleSet)) {
throw new Error(`harness_failure: contract_integrity unknown failureRuleSet ${setName}`);
}
const base = [...ruleSet];
if (!caseRecord.expectedFailure) return base;
const template = authority.expectedFailureRuleTemplate;
const controlRule: FailureRule = {
id: template.id,
match: [...template.match],
classification: caseRecord.expectedFailure.expectedClass as FailureClassification,
secondaryCode: caseRecord.expectedFailure.expectedCode,
verdictEffect: caseRecord.expectedFailure.onMatch === "unsupported" ? "unsupported" : "none",
retry: template.retry,
expected: template.expected,
};
const idx = base.findIndex((r) => r.id === "required-assertion");
if (idx >= 0) base.splice(idx, 0, controlRule);
else base.push(controlRule);
return base;
}
export function validateFixtureDigests(caseRecord: CaseRecord): string[] {
const errors: string[] = [];
const check = (fixture: CaseRecord["fixture"], label: string) => {
const bytes = new TextEncoder().encode(fixture.bytesUtf8);
const digest = fixtureDigest(bytes);
if (digest !== fixture.digest) {
errors.push(`${label} digest mismatch: expected ${fixture.digest}, got ${digest}`);
}
};
check(caseRecord.fixture, caseRecord.fixture.id);
if (caseRecord.initiatingRequest) check(caseRecord.initiatingRequest, caseRecord.initiatingRequest.id);
return errors;
}
export function validateExpandedFixtureRef(
ref: Record<string, unknown>,
authority: CaseAuthority,
fixtureBytes: string,
): string[] {
const errors: string[] = [];
const bytes = new TextEncoder().encode(fixtureBytes);
if (ref.syntheticMarker !== SYNTHETIC_MARKER) {
errors.push(`invalid syntheticMarker: ${String(ref.syntheticMarker)}`);
}
const provenance = ref.provenance as Record<string, unknown> | undefined;
if (!provenance || provenance.kind !== "lab_authored") {
errors.push("invalid provenance kind");
} else if (provenance.authority !== AUTHORITY_FILE) {
errors.push(`invalid provenance authority: ${String(provenance.authority)}`);
} else if (provenance.sourceCommit !== authority.sourceCommit) {
errors.push(`invalid provenance sourceCommit: ${String(provenance.sourceCommit)}`);
}
if (ref.digest !== fixtureDigest(bytes)) {
errors.push("fixture digest mismatch in expanded ref");
}
if (ref.byteLength !== bytes.byteLength) {
errors.push("fixture byteLength mismatch in expanded ref");
}
return errors;
}
function validateMcpHarnessFeatures(caseRecord: CaseRecord): string[] {
if (caseRecord.suite !== "mcp-core") return [];
const tokens = caseRecord.requirements.requiredHarnessFeatures.filter(
(f) => MCP_ACTION_TOKENS.includes(f as typeof MCP_ACTION_TOKENS[number]),
);
if (tokens.length !== 1) {
return [`${caseRecord.id}: invalid_manifest MCP action token count ${tokens.length}`];
}
if (caseRecord.fixture.role !== "synthetic_tool") {
return [`${caseRecord.id}: MCP cases require synthetic_tool fixture role`];
}
return [];
}
function validateAuthority(authority: CaseAuthority): void {
if (authority.schemaVersion !== 1) throw new Error("unsupported schemaVersion");
if (!authority.sourceCommit || typeof authority.sourceCommit !== "string") {
throw new Error("missing sourceCommit");
}
if (!Array.isArray(authority.cases) || authority.cases.length === 0) throw new Error("no cases");
for (const caseRecord of authority.cases) {
const errors = [
...validateFixtureDigests(caseRecord),
...validateMcpHarnessFeatures(caseRecord),
];
const expanded = expandScenario(caseRecord, authority);
const fixtures = expanded.fixtures as Array<Record<string, unknown>>;
for (let i = 0; i < fixtures.length; i++) {
const fixtureSource = i === 0 && caseRecord.initiatingRequest
? caseRecord.initiatingRequest.bytesUtf8
: caseRecord.fixture.bytesUtf8;
errors.push(...validateExpandedFixtureRef(fixtures[i], authority, fixtureSource));
}
if (errors.length > 0) throw new Error(errors.join("; "));
if (caseRecord.fixture.role === "upstream_response" && !caseRecord.initiatingRequest) {
throw new Error(`${caseRecord.id}: upstream_response without initiatingRequest`);
}
}
}