@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
180 lines (166 loc) • 6.21 kB
text/typescript
import type { CaseRecord, NormalizedObservation } from "./types";
import { emptyObservation, projectMcpCalls, setClientResponse } from "./observation";
export const MCP_ACTION_TOKENS = [
"mcp_namespace_round_trip_v1",
"mcp_schema_bounds_v1",
"mcp_call_result_v1",
"mcp_resource_round_trip_v1",
] as const;
export type McpActionToken = typeof MCP_ACTION_TOKENS[number];
export function mcpActionToken(caseRecord: CaseRecord): McpActionToken | null {
const features = caseRecord.requirements.requiredHarnessFeatures;
const tokens = features.filter((f) => MCP_ACTION_TOKENS.includes(f as McpActionToken));
if (tokens.length !== 1) return null;
return tokens[0] as McpActionToken;
}
export function executeMcpSyntheticAction(caseRecord: CaseRecord): NormalizedObservation {
const token = mcpActionToken(caseRecord);
if (!token) throw new Error(`invalid_manifest: missing or ambiguous MCP action token for ${caseRecord.id}`);
const decoded = JSON.parse(caseRecord.fixture.bytesUtf8) as Record<string, unknown>;
switch (token) {
case "mcp_namespace_round_trip_v1":
return runNamespaceRoundTrip(decoded);
case "mcp_schema_bounds_v1":
return runSchemaBounds(decoded);
case "mcp_call_result_v1":
return runCallResult(decoded);
case "mcp_resource_round_trip_v1":
return runResourceRoundTrip(decoded);
}
}
function nonEmptyString(value: unknown): value is string {
return typeof value === "string" && value.length > 0;
}
function runNamespaceRoundTrip(decoded: Record<string, unknown>): NormalizedObservation {
if (!nonEmptyString(decoded.namespace) || !nonEmptyString(decoded.name)) {
throw new Error("invalid_manifest: MCP namespace/name must be non-empty strings");
}
const namespace = decoded.namespace;
const name = decoded.name;
const wireName = `${namespace}__${name}`;
const observation = emptyObservation();
observation.upstream.requests.push({
status: 0,
headers: {},
json: {
model: "fixture-model",
tools: [{
name: wireName,
description: decoded.description,
inputSchema: decoded.inputSchema,
}],
},
rawBytes: 0,
});
const toolCalls = [{
id: "call_fixture",
name: wireName,
arguments: {},
kind: "function" as const,
ordinal: 0,
}];
setClientResponse(observation, {
toolCalls,
mcpCalls: projectMcpCalls(toolCalls),
status: 200,
});
return observation;
}
function utf8ByteLength(value: string): number {
return new TextEncoder().encode(value).byteLength;
}
function parsesJson(value: string): boolean {
try {
JSON.parse(value);
return true;
} catch {
return false;
}
}
function runSchemaBounds(decoded: Record<string, unknown>): NormalizedObservation {
const observation = emptyObservation();
const limitBytes = decoded.limitBytes;
const exactSchema = decoded.exactSchema;
const overSchema = decoded.overSchema;
if (!Number.isInteger(limitBytes) || (limitBytes as number) <= 0
|| typeof exactSchema !== "string" || typeof overSchema !== "string") {
observation.verifiers = {
exact_bound: "fail",
one_over_rejected: "fail",
partial_commit: false,
};
return observation;
}
const limit = limitBytes as number;
const exactValid = utf8ByteLength(exactSchema) === limit && parsesJson(exactSchema);
// The inert stub models two isolated catalogue transactions. The over-bound transaction
// is rejected before commit; its validity matters so this tests the byte ceiling rather
// than malformed JSON.
const overRejected = utf8ByteLength(overSchema) === limit + 1 && parsesJson(overSchema);
observation.verifiers = {
exact_bound: exactValid ? "pass" : "fail",
one_over_rejected: overRejected ? "pass" : "fail",
partial_commit: false,
};
return observation;
}
function runCallResult(decoded: Record<string, unknown>): NormalizedObservation {
if (!nonEmptyString(decoded.namespace) || !nonEmptyString(decoded.name)) {
throw new Error("invalid_manifest: MCP namespace/name must be non-empty strings");
}
const namespace = decoded.namespace;
const name = decoded.name;
const argumentsValue = decoded.arguments ?? {};
const result = decoded.result;
const wireName = `${namespace}__${name}`;
const observation = emptyObservation();
const toolCalls = [{
id: "call_fixture",
name: wireName,
arguments: argumentsValue,
kind: "function" as const,
ordinal: 0,
}];
setClientResponse(observation, {
toolCalls,
mcpCalls: projectMcpCalls(toolCalls),
json: result,
status: 200,
});
observation.verifiers = {
stub_received: { namespace, name, arguments: argumentsValue },
};
return observation;
}
function runResourceRoundTrip(decoded: Record<string, unknown>): NormalizedObservation {
if (!Array.isArray(decoded.resources) || !decoded.read || typeof decoded.read !== "object") {
throw new Error("invalid_manifest: invalid MCP resource fixture");
}
const read = decoded.read as { uri?: unknown; contents?: unknown[] };
if (!nonEmptyString(read.uri) || !Array.isArray(read.contents)) {
throw new Error("invalid_manifest: invalid MCP resource read fixture");
}
const matching = decoded.resources.filter((resource) =>
resource && typeof resource === "object" && (resource as { uri?: unknown }).uri === read.uri
);
if (matching.length !== 1) throw new Error("invalid_manifest: MCP resource URI must resolve exactly once");
const observation = emptyObservation();
setClientResponse(observation, {
json: {
resources: decoded.resources,
contents: read.contents,
},
status: 200,
});
return observation;
}
export function attachMcpVerifiers(observation: NormalizedObservation, caseRecord: CaseRecord): void {
if (caseRecord.id === "mcp-core.protocol.namespace-mapping") {
const toolCalls = observation.client.response.toolCalls;
if (toolCalls.length === 1) {
observation.client.response.mcpCalls = projectMcpCalls(toolCalls);
}
}
// runCallResult records the literal one-invocation receipt. Do not reconstruct it here:
// assertions must inspect the action result that actually ran.
}