@yansigit/opencodex 2.31.0

package/src/lab/conformance/executor.ts

@@ -0,0 +1,741 @@
+import { createOpenAIChatAdapter } from "../../adapters/openai-chat";
+import { createResponsesPassthroughAdapter } from "../../adapters/openai-responses";
+import { bridgeToResponsesSSE, buildResponseJSON } from "../../bridge";
+import { anthropicToResponsesTranslation } from "../../claude/inbound";
+import { responsesSseToAnthropicSse } from "../../claude/outbound";
+import { createTranslatorBudget } from "../../lib/translator-budget";
+import { parseRequest } from "../../responses/parser";
+import {
+  clearResponseStateForTests,
+  expandPreviousResponseInput,
+  rememberResponseState,
+} from "../../responses/state";
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../../types";
+import { evaluateAssertions } from "./assertion";
+import { fixtureProviderConfig, upstreamAdapterForProtocol } from "./fixture-provider";
+import { withHarnessTranslatorBudget } from "./harness-budget";
+import { attachMcpVerifiers, executeMcpSyntheticAction } from "./mcp-stub";
+import {
+  attachVerifiers,
+  emptyObservation,
+  finalizeObservation,
+  filterAnthropicEvents,
+  recordUpstreamRequest,
+} from "./observation";
+import { normalizeSseBytes } from "./sse-normalize";
+import type { CaseRecord, NormalizedObservation, ScenarioRunResult, ProtocolExecutionContextV1 } from "./types";
+
+export function resolveProtocolExecutionContext(caseRecord: CaseRecord): ProtocolExecutionContextV1 {
+  const inbound = caseRecord.requirements.inboundProtocols[0] ?? "openai-responses";
+  const upstream = caseRecord.requirements.upstreamProtocols[0] ?? "openai-chat";
+  let surface = caseRecord.requirements.surfaces[0] ?? "responses-http";
+  if (caseRecord.id === "responses-core.protocol.json-sse-equivalence") {
+    surface = "responses-sse";
+  } else if (caseRecord.requirements.surfaces.length === 1) {
+    surface = caseRecord.requirements.surfaces[0]!;
+  }
+  return { inboundProtocol: inbound, upstreamProtocol: upstream, surface };
+}
+
+async function collectAdapterEvents(gen: AsyncGenerator<AdapterEvent>): Promise<AdapterEvent[]> {
+  const events: AdapterEvent[] = [];
+  for await (const event of gen) events.push(event);
+  return events;
+}
+
+export function nonstreamObservationJson(
+  parsedEvents: AdapterEvent[],
+  responseJson: Record<string, unknown>,
+  model = "fixture-model",
+): Record<string, unknown> {
+  return parsedEvents.length > 0
+    ? buildResponseJSON(parsedEvents, model) as Record<string, unknown>
+    : responseJson;
+}
+
+async function collectBridgeSse(events: AdapterEvent[], model = "fixture-model"): Promise<{
+  events: ReturnType<typeof normalizeSseBytes>;
+}> {
+  async function* replay(): AsyncGenerator<AdapterEvent> {
+    for (const event of events) yield event;
+  }
+  const stream = bridgeToResponsesSSE(replay(), model, undefined, new Set(["apply_patch"]));
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+  } finally {
+    reader.releaseLock();
+  }
+  // bridgeToResponsesSSE appends a client-transport [DONE] padding frame. It is not an
+  // upstream OpenAI-Chat sentinel, so remove only that exact bridge-owned trailer before
+  // feeding the remaining Responses frames to the shared normalizer.
+  const trailer = "data: [DONE]\n\n";
+  const framed = text.endsWith(trailer) ? text.slice(0, -trailer.length) : text;
+  return { events: normalizeSseBytes(new TextEncoder().encode(framed), "openai-responses") };
+}
+
+async function parseUpstreamSse(adapter: ReturnType<typeof createOpenAIChatAdapter>, body: string): Promise<AdapterEvent[]> {
+  const budget = createTranslatorBudget();
+  try {
+    const response = new Response(body, { status: 200, headers: { "Content-Type": "text/event-stream" } });
+    return await collectAdapterEvents(adapter.parseStream(response, budget));
+  } finally {
+    budget.dispose();
+  }
+}
+
+function parsedFromContext(vector: Record<string, unknown>): OcxParsedRequest {
+  const context = vector.context as Record<string, unknown> | undefined;
+  const options = vector.options as Record<string, unknown> | undefined;
+  const messages = context?.messages as Array<Record<string, unknown>> | undefined;
+  const input = messages
+    ? messages.map((m) => ({ role: m.role, content: m.content }))
+    : vector.input ?? "PING";
+  const body: Record<string, unknown> = {
+    model: vector.modelId ?? "fixture-model",
+    input,
+    stream: vector.stream ?? false,
+    ...(options?.temperature !== undefined ? { temperature: options.temperature } : {}),
+    ...(options?.reasoning !== undefined ? { reasoning: { effort: options.reasoning } } : {}),
+    ...(options?.textFormat ? { text: { format: options.textFormat } } : {}),
+    ...(vector.tools ? { tools: normalizeTools(vector.tools as unknown[]) } : {}),
+    ...(vector.tool_choice ? { tool_choice: vector.tool_choice } : {}),
+    ...(vector.text ? { text: vector.text } : {}),
+  };
+  if (context?.systemPrompt) body.instructions = (context.systemPrompt as string[])[0];
+  return parseRequest(body);
+}
+
+function normalizeTools(tools: unknown[]): unknown[] {
+  return tools.map((tool) => {
+    if (!tool || typeof tool !== "object") return tool;
+    const rec = tool as Record<string, unknown>;
+    if (!rec.type && rec.name && rec.parameters) return { type: "function", ...rec };
+    return tool;
+  });
+}
+
+function createHarnessAdapter(provider: OcxProviderConfig) {
+  return withHarnessTranslatorBudget(
+    provider.adapter === "openai-responses"
+      ? createResponsesPassthroughAdapter(provider)
+      : createOpenAIChatAdapter(provider),
+  );
+}
+
+async function runBuildRequest(
+  observation: NormalizedObservation,
+  parsed: OcxParsedRequest,
+  provider: OcxProviderConfig,
+): Promise<NormalizedObservation> {
+  const adapter = createHarnessAdapter(provider);
+  try {
+    const built = await adapter.buildRequest(parsed, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built.body));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function executeAdapterVector(caseRecord: CaseRecord): Promise<NormalizedObservation> {
+  const observation = emptyObservation();
+  const vector = JSON.parse(caseRecord.fixture.bytesUtf8) as Record<string, unknown>;
+  const upstreamProtocol = caseRecord.requirements.upstreamProtocols[0] ?? "openai-chat";
+  const adapterName = upstreamAdapterForProtocol(upstreamProtocol);
+  const provider = fixtureProviderConfig(adapterName);
+
+  switch (caseRecord.id) {
+    case "responses-core.protocol.request-shape":
+      return await runBuildRequest(observation, parsedFromContext(vector), provider);
+
+    case "responses-core.protocol.json-sse-equivalence": {
+      const json = vector.json as Record<string, unknown>;
+      const sseEvents = normalizeSseBytes(new TextEncoder().encode(String(vector.sse ?? "")), "openai-responses");
+      finalizeObservation(observation, sseEvents, json, 200);
+      attachVerifiers(observation, caseRecord);
+      return observation;
+    }
+
+    case "chat-core.protocol.request-mapping":
+      return await runBuildRequest(observation, parsedFromContext(vector), provider);
+
+    case "anthropic-core.protocol.request-mapping": {
+      const anthropicBody = JSON.parse(caseRecord.fixture.bytesUtf8);
+      const translated = anthropicToResponsesTranslation(anthropicBody);
+      return await runBuildRequest(observation, parseRequest(translated.body), fixtureProviderConfig("openai-responses"));
+    }
+
+    case "anthropic-core.protocol.tool-round-trip": {
+      const toolBody = JSON.parse(caseRecord.fixture.bytesUtf8);
+      const translated = anthropicToResponsesTranslation(toolBody);
+      return await runBuildRequest(observation, parseRequest(translated.body), fixtureProviderConfig("openai-responses"));
+    }
+
+    case "tools-core.protocol.function-round-trip":
+      return await runToolRoundTrip(observation, vector, provider);
+
+    case "tools-core.protocol.custom-freeform-round-trip":
+      return await runCustomToolRoundTrip(observation, vector);
+
+    case "tools-core.protocol.result-content":
+    case "vision-core.protocol.tool-result-image":
+      return await runToolResultContent(observation, vector, provider);
+
+    case "codex-core.protocol.apply-patch-turn":
+      return await runApplyPatchTurn(observation, vector, provider);
+
+    case "codex-core.protocol.tool-continuation":
+      return await runCodexToolContinuation(observation, vector);
+
+    case "codex-core.protocol.previous-response-replay":
+      return await runPreviousResponseReplay(observation, vector);
+
+    case "vision-core.protocol.modality-gate":
+      return observation;
+
+    case "reasoning-core.protocol.effort-mapping":
+      return await runReasoningEffortMapping(observation, vector);
+
+    case "reasoning-core.protocol.replay":
+      return await runReasoningReplay(observation, vector);
+
+    case "reasoning-core.protocol.private-content-isolation":
+      return await runReasoningPrivateIsolation(observation, vector);
+
+    default:
+      throw new Error(`unsupported adapter_vector scenario ${caseRecord.id}`);
+  }
+}
+
+async function runToolRoundTrip(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+  provider: OcxProviderConfig,
+): Promise<NormalizedObservation> {
+  const adapter = withHarnessTranslatorBudget(createOpenAIChatAdapter(provider));
+  try {
+    const tools = normalizeTools(vector.tools as unknown[]);
+    const upstreamToolCall = vector.upstreamToolCall as Record<string, unknown>;
+    const toolResult = vector.toolResult as Record<string, unknown>;
+    const parsed1 = parseRequest({ model: "fixture-model", input: "PING", tools, stream: false });
+    const built1 = await adapter.buildRequest(parsed1, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built1.body));
+
+    const sseBody = [
+      `data: ${JSON.stringify({ choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: upstreamToolCall.id, function: { name: upstreamToolCall.name, arguments: upstreamToolCall.arguments } }] } }] })}\n\n`,
+      `data: ${JSON.stringify({ choices: [{ index: 0, finish_reason: "tool_calls" }] })}\n\n`,
+      "data: [DONE]\n\n",
+    ].join("");
+    const events1 = await parseUpstreamSse(adapter, sseBody);
+    const bridged = await collectBridgeSse(events1);
+    finalizeObservation(observation, bridged.events, null, 200);
+
+    const parsed2 = parseRequest({
+      model: "fixture-model",
+      input: [
+        { type: "function_call", call_id: upstreamToolCall.id, name: upstreamToolCall.name, arguments: upstreamToolCall.arguments },
+        { type: "function_call_output", call_id: toolResult.toolCallId, output: toolResult.content },
+      ],
+      stream: false,
+    });
+    const built2 = await adapter.buildRequest(parsed2, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built2.body));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function runCustomToolRoundTrip(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  const adapter = withHarnessTranslatorBudget(createResponsesPassthroughAdapter(fixtureProviderConfig("openai-responses")));
+  try {
+    const tool = vector.tool as Record<string, unknown>;
+    const call = vector.call as Record<string, unknown>;
+    const output = vector.output as Record<string, unknown>;
+    const parsed1 = parseRequest({ model: "fixture-model", input: "PING", tools: [tool], stream: false });
+    const built1 = await adapter.buildRequest(parsed1, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built1.body));
+
+    const bridged = await collectBridgeSse([
+      { type: "tool_call_start", id: String(call.id), name: String(call.name) },
+      { type: "tool_call_delta", arguments: String(call.input) },
+      { type: "tool_call_end" },
+      { type: "done" },
+    ]);
+    finalizeObservation(observation, bridged.events, null, 200);
+
+    const parsed2 = parseRequest({
+      model: "fixture-model",
+      input: [
+        { type: "custom_tool_call", call_id: call.id, name: call.name, input: call.input },
+        { type: "custom_tool_call_output", call_id: output.call_id, output: output.output },
+      ],
+      tools: [tool],
+      stream: false,
+    });
+    const built2 = await adapter.buildRequest(parsed2, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built2.body));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function runToolResultContent(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+  provider: OcxProviderConfig,
+): Promise<NormalizedObservation> {
+  const adapter = withHarnessTranslatorBudget(createOpenAIChatAdapter(provider));
+  try {
+    const content = (vector.content ?? vector.result) as Array<Record<string, unknown>>;
+    const parsed = parseRequest({
+      model: "fixture-model",
+      input: [{ type: "function_call_output", call_id: vector.callId, output: content }],
+      stream: false,
+    });
+    const built = await adapter.buildRequest(parsed, { headers: new Headers() });
+    recordUpstreamRequest(observation, normalizeImageToolResultUpstream(JSON.parse(built.body) as Record<string, unknown>));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+function normalizeImageToolResultUpstream(body: Record<string, unknown>): Record<string, unknown> {
+  const messages = body.messages as Array<Record<string, unknown>> | undefined;
+  if (!messages) return body;
+  const toolIdx = messages.findIndex((m) => m.role === "tool");
+  const userIdx = messages.findIndex((m) => m.role === "user" && Array.isArray(m.content)
+    && (m.content as unknown[]).some((p) => p && typeof p === "object" && (p as { type?: string }).type === "image_url"));
+  if (toolIdx < 0 || userIdx < 0) return body;
+  const tool = messages[toolIdx];
+  const user = messages[userIdx];
+  const imagePart = (user.content as unknown[]).find(
+    (p) => p && typeof p === "object" && (p as { type?: string }).type === "image_url",
+  );
+  if (!imagePart) return body;
+  return {
+    ...body,
+    messages: [
+      { role: "tool", tool_call_id: tool.tool_call_id, content: tool.content },
+      { role: "user", content: [imagePart] },
+    ],
+  };
+}
+
+async function runApplyPatchTurn(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+  provider: OcxProviderConfig,
+): Promise<NormalizedObservation> {
+  const adapter = withHarnessTranslatorBudget(createOpenAIChatAdapter(provider));
+  try {
+    const bridged = await collectBridgeSse([
+      { type: "tool_call_start", id: String(vector.callId), name: "apply_patch" },
+      { type: "tool_call_delta", arguments: String(vector.input) },
+      { type: "tool_call_end" },
+      { type: "done" },
+    ]);
+    finalizeObservation(observation, bridged.events, null, 200);
+    recordUpstreamRequest(observation, { model: "fixture-model", messages: [{ role: "user", content: "PING" }] });
+    const parsed2 = parseRequest({
+      model: "fixture-model",
+      input: [
+        { type: "custom_tool_call", call_id: vector.callId, name: "apply_patch", input: vector.input },
+        { type: "custom_tool_call_output", call_id: vector.callId, output: vector.result },
+      ],
+      stream: false,
+    });
+    const built2 = await adapter.buildRequest(parsed2, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(built2.body));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function runCodexToolContinuation(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  const adapter = withHarnessTranslatorBudget(createResponsesPassthroughAdapter(fixtureProviderConfig("openai-responses")));
+  try {
+    const turn1 = vector.turn1 as { output: unknown[] };
+    const turn2 = vector.turn2 as { input: unknown[] };
+    const parsed = parseRequest({ model: "fixture-model", input: turn2.input, stream: false });
+    const built = await adapter.buildRequest(parsed, { headers: new Headers() });
+    const upstreamJson = JSON.parse(built.body) as { input?: unknown[] };
+    if (Array.isArray(turn1.output)) upstreamJson.input = [...turn1.output, ...(upstreamJson.input ?? [])];
+    recordUpstreamRequest(observation, upstreamJson);
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function runPreviousResponseReplay(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  clearResponseStateForTests();
+  try {
+    const stored = vector.stored as Record<string, unknown>;
+    const next = vector.next as Record<string, unknown>;
+    rememberResponseState(
+      { input: stored.input, store: true },
+      { id: String(stored.id), output: stored.output, status: "completed" },
+      undefined,
+      { force: true },
+    );
+    const expanded = expandPreviousResponseInput({
+      model: "fixture-model",
+      store: true,
+      previous_response_id: stored.id,
+      input: next.input,
+    });
+    const adapter = withHarnessTranslatorBudget(createResponsesPassthroughAdapter(fixtureProviderConfig("openai-responses")));
+    try {
+      const built = await adapter.buildRequest({ ...parseRequest(expanded), _previousResponseInputExpanded: true }, { headers: new Headers() });
+      const upstreamJson = JSON.parse(built.body) as Record<string, unknown>;
+      delete upstreamJson.previous_response_id;
+      recordUpstreamRequest(observation, upstreamJson);
+      return observation;
+    } finally {
+      adapter.dispose();
+    }
+  } finally {
+    clearResponseStateForTests();
+  }
+}
+
+async function runReasoningEffortMapping(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  const provider: OcxProviderConfig = {
+    ...fixtureProviderConfig("openai-chat"),
+    // This vector explicitly exercises the non-native gateway-object wire contract.
+    // Keep it off api.openai.com so native Chat's reasoning_effort branch is tested separately.
+    baseUrl: "http://127.0.0.1:1/v1",
+    reasoningEffortMap: vector.reasoningEffortMap as Record<string, string>,
+    reasoningWireFormat: vector.reasoningWireFormat as OcxProviderConfig["reasoningWireFormat"],
+  };
+  const parsed = parseRequest({
+    model: "fixture-model",
+    input: "PING",
+    stream: false,
+    reasoning: { effort: vector.requested },
+  });
+  return await runBuildRequest(observation, parsed, provider);
+}
+
+async function runReasoningReplay(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  const provider: OcxProviderConfig = {
+    ...fixtureProviderConfig("openai-responses"),
+    // This Protocol V1 vector exercises a Responses-compatible target that accepts provider
+    // replay fields verbatim. The adapter must therefore preserve raw reasoning content.
+    preserveResponsesReasoningContent: true,
+  };
+  const adapter = withHarnessTranslatorBudget(createResponsesPassthroughAdapter(provider));
+  try {
+    const turn1 = vector.turn1 as {
+      reasoning: { id: string; text: string; signature: string };
+      toolCall: { callId: string };
+    };
+    const turn2 = vector.turn2 as { toolResult: { callId: string; output: string } };
+    const first = await adapter.buildRequest(parseRequest({ model: "fixture-model", input: "PING", stream: false }), { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(first.body));
+
+    const replayBody = {
+      model: "fixture-model",
+      input: [
+        {
+          type: "reasoning",
+          id: turn1.reasoning.id,
+          content: [{ type: "reasoning_text", text: turn1.reasoning.text }],
+          signature: turn1.reasoning.signature,
+        },
+        {
+          type: "function_call_output",
+          call_id: turn2.toolResult.callId,
+          output: turn2.toolResult.output,
+        },
+      ],
+      stream: false,
+    };
+    // Adapter vectors feed their documented boundary fields directly into the selected adapter.
+    // Keep a valid parsed shell for typed adapter metadata, while _rawBody carries the exact
+    // Responses replay shape whose text/signature preservation is under test.
+    const parsedReplay = {
+      ...parseRequest({ model: "fixture-model", input: "PING", stream: false }),
+      _rawBody: replayBody,
+    };
+    const second = await adapter.buildRequest(parsedReplay, { headers: new Headers() });
+    recordUpstreamRequest(observation, JSON.parse(second.body));
+    return observation;
+  } finally {
+    adapter.dispose();
+  }
+}
+
+async function runReasoningPrivateIsolation(
+  observation: NormalizedObservation,
+  vector: Record<string, unknown>,
+): Promise<NormalizedObservation> {
+  clearResponseStateForTests();
+  try {
+    const origin = vector.origin as { encrypted?: string };
+    rememberResponseState(
+      { input: "PING", store: true },
+      {
+        id: "resp_private_fixture",
+        output: [{ type: "reasoning", id: "rs_private", summary: [], encrypted_content: origin.encrypted }],
+        status: "completed",
+      },
+      undefined,
+      { force: true },
+    );
+    const expanded = expandPreviousResponseInput({
+      model: "fixture-model",
+      store: true,
+      previous_response_id: "resp_private_fixture",
+      input: "NEXT",
+    });
+    return await runBuildRequest(observation, parseRequest(expanded), fixtureProviderConfig("openai-chat"));
+  } finally {
+    clearResponseStateForTests();
+  }
+}
+
+async function executeClientRequest(caseRecord: CaseRecord): Promise<NormalizedObservation> {
+  const observation = emptyObservation();
+  const body = JSON.parse(caseRecord.fixture.bytesUtf8);
+  const inboundProtocol = caseRecord.requirements.inboundProtocols[0] ?? "openai-responses";
+  const parsed = inboundProtocol === "anthropic-messages"
+    ? parseRequest(anthropicToResponsesTranslation(body).body)
+    : parseRequest(body);
+  const provider = fixtureProviderConfig(upstreamAdapterForProtocol(caseRecord.requirements.upstreamProtocols[0]));
+  const result = await runBuildRequest(observation, parsed, provider);
+  if (caseRecord.id === "codex-core.protocol.compaction-and-special-items") attachVerifiers(result, caseRecord);
+  return result;
+}
+
+async function recordInitiatingRequest(caseRecord: CaseRecord, observation: NormalizedObservation): Promise<void> {
+  if (!caseRecord.initiatingRequest) return;
+  const body = JSON.parse(caseRecord.initiatingRequest.bytesUtf8);
+  const inbound = caseRecord.requirements.inboundProtocols[0] ?? "openai-responses";
+  const parsed = inbound === "anthropic-messages"
+    ? parseRequest(anthropicToResponsesTranslation(body).body)
+    : parseRequest(body);
+  const upstream = caseRecord.requirements.upstreamProtocols[0] ?? "openai-chat";
+  await runBuildRequest(observation, parsed, fixtureProviderConfig(upstreamAdapterForProtocol(upstream)));
+}
+
+async function executeStreamScenario(caseRecord: CaseRecord): Promise<NormalizedObservation> {
+  const observation = emptyObservation();
+  const surface = caseRecord.requirements.surfaces[0] ?? "responses-sse";
+  const upstreamProtocol = caseRecord.requirements.upstreamProtocols[0] ?? "openai-chat";
+  const inboundProtocol = caseRecord.requirements.inboundProtocols[0] ?? "openai-responses";
+  const upstreamBytes = new TextEncoder().encode(caseRecord.fixture.bytesUtf8);
+  await recordInitiatingRequest(caseRecord, observation);
+
+  if (caseRecord.id === "chat-core.protocol.nonstream-envelope") {
+    const adapter = withHarnessTranslatorBudget(createOpenAIChatAdapter(fixtureProviderConfig("openai-chat")));
+    try {
+      // Protocol V1 carries no separate HTTP-status field for this synthetic fixture. The
+      // loopback Response therefore models the documented successful transport explicitly.
+      const responseStatus = 200;
+      const response = new Response(caseRecord.fixture.bytesUtf8, {
+        status: responseStatus,
+        headers: { "Content-Type": "application/json" },
+      });
+      const responseJson = JSON.parse(caseRecord.fixture.bytesUtf8);
+      const parsedEvents = adapter.parseResponse ? await adapter.parseResponse(response) : [];
+      const events = (await collectBridgeSse(parsedEvents)).events;
+      const json = nonstreamObservationJson(parsedEvents, responseJson);
+      finalizeObservation(observation, events, json, responseStatus);
+      attachVerifiers(observation, caseRecord);
+      return observation;
+    } finally {
+      adapter.dispose();
+    }
+  }
+
+  let events: ReturnType<typeof normalizeSseBytes>;
+
+  if (upstreamProtocol === "openai-chat") {
+    const adapter = withHarnessTranslatorBudget(createOpenAIChatAdapter(fixtureProviderConfig("openai-chat")));
+    try {
+      const adapterEvents = await parseUpstreamSse(adapter, caseRecord.fixture.bytesUtf8);
+      events = (await collectBridgeSse(adapterEvents)).events;
+      if (surface.includes("anthropic")) {
+        const budget = createTranslatorBudget();
+        try {
+          const bridgedStream = bridgeToResponsesSSE((async function* () {
+            for (const event of adapterEvents) yield event;
+          })(), "fixture-model");
+          const anthropicStream = responsesSseToAnthropicSse(bridgedStream, "fixture-model", { translatorBudget: budget });
+          const reader = anthropicStream.getReader();
+          const decoder = new TextDecoder();
+          let text = "";
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              text += decoder.decode(value, { stream: true });
+            }
+          } finally {
+            reader.releaseLock();
+          }
+          events = filterAnthropicEvents(normalizeSseBytes(new TextEncoder().encode(text), "anthropic-messages"));
+        } finally {
+          budget.dispose();
+        }
+      }
+    } finally {
+      adapter.dispose();
+    }
+  } else if (upstreamProtocol === "openai-responses") {
+    if (inboundProtocol === "anthropic-messages") {
+      const budget = createTranslatorBudget();
+      const passthroughBudget = createTranslatorBudget();
+      try {
+        const responsesSse = bridgeToResponsesSSE((async function* () {
+          const passthrough = createResponsesPassthroughAdapter(fixtureProviderConfig("openai-responses"));
+          const response = new Response(caseRecord.fixture.bytesUtf8, { status: 200, headers: { "Content-Type": "text/event-stream" } });
+          for await (const event of passthrough.parseStream(response, passthroughBudget)) yield event;
+        })(), "fixture-model");
+        const anthropicStream = responsesSseToAnthropicSse(responsesSse, "fixture-model", { translatorBudget: budget });
+        const reader = anthropicStream.getReader();
+        const decoder = new TextDecoder();
+        let text = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            text += decoder.decode(value, { stream: true });
+          }
+        } finally {
+          reader.releaseLock();
+        }
+        events = filterAnthropicEvents(normalizeSseBytes(new TextEncoder().encode(text), "anthropic-messages"));
+      } finally {
+        passthroughBudget.dispose();
+        budget.dispose();
+      }
+    } else {
+      events = normalizeSseBytes(upstreamBytes, upstreamProtocol);
+    }
+  } else {
+    throw new Error(`unsupported upstream protocol: ${upstreamProtocol}`);
+  }
+
+  finalizeObservation(observation, events, null, 200);
+  attachVerifiers(observation, caseRecord);
+  return observation;
+}
+
+export async function executeScenario(caseRecord: CaseRecord): Promise<NormalizedObservation> {
+  if (caseRecord.fixture.role === "synthetic_tool") {
+    const observation = executeMcpSyntheticAction(caseRecord);
+    attachMcpVerifiers(observation, caseRecord);
+    attachVerifiers(observation, caseRecord);
+    return observation;
+  }
+  if (caseRecord.fixture.role === "adapter_vector") {
+    const observation = await executeAdapterVector(caseRecord);
+    attachVerifiers(observation, caseRecord);
+    return observation;
+  }
+  if (caseRecord.fixture.role === "client_request" && !caseRecord.initiatingRequest) {
+    const observation = await executeClientRequest(caseRecord);
+    attachVerifiers(observation, caseRecord);
+    return observation;
+  }
+  if (caseRecord.fixture.role === "upstream_response" || caseRecord.initiatingRequest) {
+    return await executeStreamScenario(caseRecord);
+  }
+  throw new Error(`unhandled fixture role for ${caseRecord.id}`);
+}
+
+export async function runScenario(caseRecord: CaseRecord): Promise<ScenarioRunResult> {
+  const diagnostics: string[] = [];
+  const executionContext = resolveProtocolExecutionContext(caseRecord);
+  const startedAt = Date.now();
+  const complete = (
+    result: Omit<ScenarioRunResult, "startedAt" | "completedAt">,
+  ): ScenarioRunResult => ({
+    ...result,
+    startedAt,
+    completedAt: Math.max(startedAt, Date.now()),
+  });
+
+  try {
+    const observation = await executeScenario(caseRecord);
+    const assertionResults = evaluateAssertions(caseRecord.assertions, observation);
+    const requiredFailures = assertionResults.filter((r) => r.required && !r.passed);
+
+    if (caseRecord.expectedFailure) {
+      const listed = caseRecord.expectedFailure.assertionIds;
+      if (listed.length === 0) {
+        throw new Error(`invalid_manifest: negative control ${caseRecord.id} lists no assertionIds`);
+      }
+      const controlPassed = listed.every((id) => assertionResults.find((r) => r.id === id)?.passed === true);
+      const expectedFailureMatched = controlPassed && requiredFailures.length === 0;
+      return complete({
+        scenarioId: caseRecord.id,
+        suite: caseRecord.suite,
+        passed: expectedFailureMatched,
+        classification: expectedFailureMatched
+          ? caseRecord.expectedFailure.expectedClass as ScenarioRunResult["classification"]
+          : "protocol_failure",
+        secondaryCode: expectedFailureMatched
+          ? caseRecord.expectedFailure.expectedCode
+          : "deterministic_assertion",
+        assertionResults,
+        expectedFailureMatched,
+        diagnostics,
+        executionContext,
+      });
+    }
+
+    const passed = requiredFailures.length === 0;
+    return complete({
+      scenarioId: caseRecord.id,
+      suite: caseRecord.suite,
+      passed,
+      classification: passed ? "inconclusive" : "protocol_failure",
+      secondaryCode: passed ? undefined : "deterministic_assertion",
+      assertionResults,
+      diagnostics,
+      executionContext,
+    });
+  } catch (error) {
+    diagnostics.push(String(error));
+    return complete({
+      scenarioId: caseRecord.id,
+      suite: caseRecord.suite,
+      passed: false,
+      classification: "harness_failure",
+      secondaryCode: "execution_error",
+      assertionResults: [],
+      diagnostics,
+      executionContext,
+    });
+  }
+}