@finalai/agent-provider 0.1.0

package/dist/modules/conformance/harness-kit.mjs

@@ -0,0 +1,1303 @@
+import {
+  client,
+  methods,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk/experimental/v2";
+import {
+  accumulateAgentMessages,
+  acpSchemas,
+  advertisedFinalExtensions,
+  isUnsupportedProtocolVersionError,
+  jsonValueSchema,
+  MAX_ACP_FRAME_BYTES,
+  MAX_INLINE_MEDIA_BYTES,
+  requireProtocolV2,
+  RESOURCE_LINK_DESCRIPTION_BYTES,
+  resumeReplayFor,
+  serializedFrameBytes,
+  watchInitializeVersion
+} from "@finalai/acp-session";
+import * as z from "zod";
+import {
+  harnessDescriptionSchema,
+  McpTransportKind,
+  PromptWhileRunning
+} from "../harness.mjs";
+import { emptyManifest } from "../manifest.mjs";
+import {
+  answerConformanceMcpMessage,
+  createConformanceMcpHttpHandler
+} from "./fixtures.mjs";
+import {
+  CONFORMANCE_ACP_SERVER_ID,
+  CONFORMANCE_ACP_SERVER_NAME,
+  CONFORMANCE_ELICITATION_ANSWER,
+  CONFORMANCE_HTTP_SERVER_NAME,
+  CONFORMANCE_MCP_TOOL,
+  ConformanceDirective,
+  conformanceEchoText,
+  directive,
+  FINAL_META_KEY,
+  OBSERVE_METHOD
+} from "./protocol.mjs";
+import { createLegacyProtocolAgent } from "./v1-agent.mjs";
+var ConformanceProfile = /* @__PURE__ */ ((ConformanceProfile2) => {
+  ConformanceProfile2["Final"] = "final";
+  ConformanceProfile2["PlainAcpV2"] = "plain-acp-v2";
+  return ConformanceProfile2;
+})(ConformanceProfile || {});
+var ConformanceCaseStatus = /* @__PURE__ */ ((ConformanceCaseStatus2) => {
+  ConformanceCaseStatus2["Passed"] = "passed";
+  ConformanceCaseStatus2["Failed"] = "failed";
+  ConformanceCaseStatus2["Skipped"] = "skipped";
+  return ConformanceCaseStatus2;
+})(ConformanceCaseStatus || {});
+var HarnessConformanceCase = /* @__PURE__ */ ((HarnessConformanceCase2) => {
+  HarnessConformanceCase2["Describe"] = "describe";
+  HarnessConformanceCase2["Open"] = "open";
+  HarnessConformanceCase2["Initialize"] = "initialize";
+  HarnessConformanceCase2["NewSession"] = "session/new";
+  HarnessConformanceCase2["Prompt"] = "prompt";
+  HarnessConformanceCase2["Stream"] = "stream";
+  HarnessConformanceCase2["Permission"] = "permission";
+  HarnessConformanceCase2["Elicitation"] = "elicitation";
+  HarnessConformanceCase2["McpAcp"] = "mcp over acp";
+  HarnessConformanceCase2["McpHttp"] = "mcp over http";
+  HarnessConformanceCase2["Observe"] = "observe";
+  HarnessConformanceCase2["ErrorStop"] = "error stop";
+  HarnessConformanceCase2["Cancel"] = "cancel";
+  HarnessConformanceCase2["ResumeReplay"] = "resume with replay";
+  HarnessConformanceCase2["ParkResume"] = "park/resume";
+  HarnessConformanceCase2["PromptWhileRunning"] = "prompt while running";
+  HarnessConformanceCase2["CancelWhileRunning"] = "cancel reaching a prompt sent while running";
+  HarnessConformanceCase2["NoResend"] = "unanswered prompt across a dropped connection";
+  HarnessConformanceCase2["DisconnectMidTurn"] = "disconnect mid-turn";
+  HarnessConformanceCase2["DisconnectMidPermission"] = "disconnect mid-permission";
+  HarnessConformanceCase2["NativeIdPreservation"] = "native session identity across resume";
+  HarnessConformanceCase2["NativeIdChange"] = "native session id change";
+  HarnessConformanceCase2["OversizedFrame"] = "multi-megabyte tool result and image";
+  HarnessConformanceCase2["GracefulClose"] = "graceful close";
+  HarnessConformanceCase2["V1Rejected"] = "ACP v1 agent rejected";
+  HarnessConformanceCase2["Health"] = "health";
+  HarnessConformanceCase2["Close"] = "close";
+  return HarnessConformanceCase2;
+})(HarnessConformanceCase || {});
+const HARNESS_CONFORMANCE_CASES = Object.values(HarnessConformanceCase);
+const failure = (message) => new Error(message);
+const check = (condition, message) => {
+  if (!condition) throw failure(message);
+};
+const withTimeout = async (promise, ms, what) => {
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(failure(`${what} timed out after ${ms} ms`)), ms);
+      })
+    ]);
+  } finally {
+    if (timer != null) clearTimeout(timer);
+  }
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const textOfUpdates = (updates) => accumulateAgentMessages(updates).map((message) => message.text).join("");
+const isIdle = (update) => update.sessionUpdate === "state_update" && "state" in update && update.state === "idle";
+const stopReasonSchema = z.object({ stopReason: z.string() });
+const stopReasonOf = (update) => stopReasonSchema.safeParse(update).data?.stopReason ?? null;
+const echoSchema = z.object({
+  sessionUpdate: z.union([z.literal("user_message"), z.literal("user_message_chunk")]),
+  messageId: z.string(),
+  content: z.unknown().optional()
+});
+const echoOf = (update) => {
+  const parsed = echoSchema.safeParse(update);
+  return parsed.success ? { messageId: parsed.data.messageId, content: JSON.stringify(parsed.data.content ?? null) } : null;
+};
+const isRunning = (update) => update.sessionUpdate === "state_update" && "state" in update && update.state === "running";
+const toolContentSchema = z.object({
+  sessionUpdate: z.literal("tool_call_update"),
+  content: z.array(
+    z.object({ type: z.literal("content"), content: z.looseObject({ type: z.string() }) })
+  )
+});
+const resourceLinkSchema = z.object({
+  type: z.literal("resource_link"),
+  uri: z.string().min(1),
+  mimeType: z.string().nullish(),
+  size: z.number().nullish(),
+  description: z.string().nullish()
+});
+const inlineTextSchema = z.object({ type: z.literal("text"), text: z.string() });
+const rawMcpBlocks = (value, depth = 0) => {
+  if (depth > 4) return [];
+  const wrapper = z.object({ result: jsonValueSchema }).safeParse(value);
+  if (wrapper.success) return rawMcpBlocks(wrapper.data.result, depth + 1);
+  const result = z.object({ content: z.array(jsonValueSchema) }).safeParse(value);
+  if (!result.success) return [];
+  return result.data.content.flatMap((block) => {
+    const text = z.object({ type: z.literal("text"), text: z.string() }).safeParse(block);
+    if (text.success) {
+      try {
+        const nested = rawMcpBlocks(jsonValueSchema.parse(JSON.parse(text.data.text)), depth + 1);
+        if (nested.length > 0) return nested;
+      } catch {
+      }
+    }
+    const content = acpSchemas.zContentBlock.safeParse(block);
+    return content.success ? [content.data] : [];
+  });
+};
+const toolBlocksOf = (updates) => updates.flatMap((update) => {
+  const content = (toolContentSchema.safeParse(update).data?.content ?? []).map(
+    (entry) => entry.content
+  );
+  const raw = z.object({ sessionUpdate: z.literal("tool_call_update"), rawOutput: jsonValueSchema }).safeParse(update);
+  return [...content, ...raw.success ? rawMcpBlocks(raw.data.rawOutput) : []];
+});
+const requestIdSchema = z.object({ id: z.union([z.string(), z.number()]), method: z.string() });
+const responseIdSchema = z.object({ id: z.union([z.string(), z.number(), z.null()]) });
+const isBatch = (wire) => Array.isArray(wire);
+const BIG_RESULT_BYTES = 3 * 1024 * 1024;
+const providerErrorSchema = z.object({
+  [FINAL_META_KEY]: z.object({
+    providerError: z.object({ code: z.string(), message: z.string(), retryable: z.boolean() })
+  })
+});
+const conformanceOpenArgs = (overrides = {}) => {
+  const manifest = emptyManifest("Conformance");
+  return {
+    session: {
+      sessionId: crypto.randomUUID(),
+      organizationId: crypto.randomUUID(),
+      definitionId: crypto.randomUUID(),
+      revisionId: crypto.randomUUID(),
+      sessionServiceUrl: "http://conformance.invalid"
+    },
+    harnessSessionId: crypto.randomUUID(),
+    config: {},
+    manifest: {
+      ...manifest,
+      harness: { harness: manifest.harness.harness, config: {} },
+      mcpServers: [],
+      sandboxes: {}
+    },
+    mcpServers: [],
+    baseTools: {},
+    sandboxes: {},
+    credentials: {
+      brokerUrl: "http://conformance.invalid/broker",
+      grants: [],
+      atOpen: null,
+      refresh: null
+    },
+    secrets: { get: async () => null },
+    trace: { traceparent: null, tracestate: null },
+    ...overrides
+  };
+};
+const runHarnessConformance = async (args) => {
+  const profile = args.profile === "final" /* Final */ ? "final" /* Final */ : "plain-acp-v2" /* PlainAcpV2 */;
+  const final = profile === "final" /* Final */;
+  const timeoutMs = args.timeoutMs ?? 15e3;
+  const replayGraceMs = args.replayGraceMs ?? 300;
+  const cwd = args.cwd ?? "/workspace";
+  const nonce = crypto.randomUUID().slice(0, 8);
+  const cases = [];
+  const passed = /* @__PURE__ */ new Set();
+  const cleanups = [];
+  const logs = /* @__PURE__ */ new Map();
+  const logFor = (sessionId2) => {
+    let log = logs.get(sessionId2);
+    if (log == null) {
+      log = { items: [], listeners: /* @__PURE__ */ new Set() };
+      logs.set(sessionId2, log);
+    }
+    return log;
+  };
+  const permissionRequests = [];
+  const elicitations = [];
+  const mcpMessages = [];
+  const permissionIds = [];
+  let epoch = 0;
+  let holdPermissions = false;
+  const releaseHeld = [];
+  const inboundFrameBytes = [];
+  const promptDrop = {
+    armed: false,
+    id: null,
+    dropped: false
+  };
+  const knownSessions = /* @__PURE__ */ new Set();
+  const foreignUpdates = [];
+  const kitClient = client({ name: "final-conformance-kit" }).onRequest(methods.client.session.requestPermission, ({ params, requestId }) => {
+    permissionRequests.push({ optionKinds: params.options.map((option2) => option2.kind) });
+    permissionIds.push({ requestId, epoch });
+    if (holdPermissions) {
+      return new Promise((resolve) => {
+        releaseHeld.push(() => resolve({ outcome: { outcome: "cancelled" } }));
+      });
+    }
+    const option = params.options.find((entry) => entry.kind === "allow_once") ?? params.options[0];
+    return option == null ? { outcome: { outcome: "cancelled" } } : { outcome: { outcome: "selected", optionId: option.optionId } };
+  }).onRequest(methods.client.elicitation.create, ({ params }) => {
+    elicitations.push({ mode: params.mode });
+    return { action: "accept", content: { answer: CONFORMANCE_ELICITATION_ANSWER } };
+  }).onRequest(methods.client.mcp.message, ({ params }) => {
+    mcpMessages.push({ serverId: params.serverId, method: params.method });
+    return answerConformanceMcpMessage(nonce, params);
+  }).onNotification(methods.client.session.update, ({ params }) => {
+    if (!knownSessions.has(params.sessionId)) foreignUpdates.push(params.sessionId);
+    const log = logFor(params.sessionId);
+    log.items.push(params.update);
+    for (const listener of [...log.listeners]) listener();
+  });
+  const waitFor = (sessionId2, predicate, what) => {
+    const log = logFor(sessionId2);
+    return withTimeout(
+      new Promise((resolve) => {
+        const listener = () => {
+          if (!predicate(log.items)) return;
+          log.listeners.delete(listener);
+          resolve();
+        };
+        log.listeners.add(listener);
+        listener();
+      }),
+      timeoutMs,
+      what
+    );
+  };
+  let description = null;
+  const described = () => description;
+  let endpoint = null;
+  let connection = null;
+  let stream = null;
+  let advertised = advertisedFinalExtensions({});
+  let sessionId = null;
+  let mcpServers = [];
+  let firstPrompt = null;
+  let echoText = "";
+  const step = async (name, options, run) => {
+    const started = Date.now();
+    const missing = (options.requires ?? []).filter((required) => !passed.has(required));
+    const skip = args.surfaceLimits?.[name] ?? options.skip ?? null;
+    if (skip != null || missing.length > 0) {
+      cases.push({
+        name,
+        status: "skipped" /* Skipped */,
+        durationMs: 0,
+        error: null,
+        detail: skip ?? `requires ${missing.join(", ")}`
+      });
+      return;
+    }
+    try {
+      const detail = await withTimeout(
+        run(),
+        name === "park/resume" /* ParkResume */ ? args.parkTimeoutMs ?? timeoutMs : timeoutMs,
+        name
+      );
+      passed.add(name);
+      cases.push({
+        name,
+        status: "passed" /* Passed */,
+        durationMs: Date.now() - started,
+        error: null,
+        detail: detail ?? null
+      });
+    } catch (cause) {
+      cases.push({
+        name,
+        status: "failed" /* Failed */,
+        durationMs: Date.now() - started,
+        error: cause instanceof Error ? cause.message : String(cause),
+        detail: null
+      });
+    }
+  };
+  const requireConnection = () => {
+    if (connection == null) throw failure("no connection");
+    return connection;
+  };
+  const requireSession = () => {
+    if (sessionId == null) throw failure("no session");
+    return sessionId;
+  };
+  const promptMeta = {
+    [FINAL_META_KEY]: {
+      author: { participantId: "conformance-user", kind: "user", displayName: "Conformance" },
+      replyExpected: true
+    }
+  };
+  const sendPrompt = async (text) => {
+    const id = requireSession();
+    const from = logFor(id).items.length;
+    const response = await requireConnection().agent.request(methods.agent.session.prompt, {
+      sessionId: id,
+      prompt: [{ type: "text", text }],
+      _meta: promptMeta
+    });
+    return { messageId: response.messageId, from };
+  };
+  const awaitTurn = async (sent) => {
+    const id = requireSession();
+    const hasIdle = (items2) => items2.slice(sent.from).some(isIdle);
+    await waitFor(id, hasIdle, "turn end");
+    const items = logFor(id).items;
+    const updates = [];
+    let idle = null;
+    for (const update of items.slice(sent.from)) {
+      updates.push(update);
+      if (isIdle(update)) {
+        idle = update;
+        break;
+      }
+    }
+    if (idle == null) throw failure("turn did not end");
+    return {
+      messageId: sent.messageId,
+      updates,
+      idle,
+      stopReason: stopReasonOf(idle),
+      text: textOfUpdates(updates)
+    };
+  };
+  const turn = async (text) => awaitTurn(await sendPrompt(text));
+  const tap = (inner) => {
+    const writer = inner.writable.getWriter();
+    const writable = new WritableStream({
+      write: async (wire) => {
+        for (const message of isBatch(wire) ? wire : [wire]) {
+          const request = requestIdSchema.safeParse(message);
+          if (promptDrop.armed && promptDrop.id == null && request.success && request.data.method === methods.agent.session.prompt) {
+            promptDrop.id = JSON.stringify(request.data.id);
+          }
+        }
+        await writer.write(wire);
+      },
+      close: () => writer.close(),
+      abort: (reason) => writer.abort(reason)
+    });
+    const readable = inner.readable.pipeThrough(
+      new TransformStream({
+        transform: (wire, controller) => {
+          inboundFrameBytes.push(serializedFrameBytes(wire));
+          const response = responseIdSchema.safeParse(wire);
+          if (promptDrop.id != null && !isBatch(wire) && !("method" in wire) && response.success && JSON.stringify(response.data.id) === promptDrop.id) {
+            promptDrop.id = null;
+            promptDrop.armed = false;
+            promptDrop.dropped = true;
+            return;
+          }
+          controller.enqueue(wire);
+        }
+      })
+    );
+    return { readable, writable };
+  };
+  let initialized = null;
+  const initializeResponse = () => initialized;
+  const initializeOver = (target, watch) => (
+    // The session service's check: any version but 2 is refused.
+    requireProtocolV2({
+      watch,
+      initialize: target.agent.request(methods.agent.initialize, {
+        protocolVersion: PROTOCOL_VERSION,
+        info: { name: "final-conformance-kit", version: "1" },
+        capabilities: { elicitation: { form: {} } }
+      })
+    })
+  );
+  const connect = async (target) => {
+    stream = await args.dial(target);
+    const watch = watchInitializeVersion(tap(stream));
+    connection = kitClient.connect(watch.stream);
+    epoch += 1;
+    const response = await initializeOver(requireConnection(), watch);
+    initialized = response;
+    advertised = advertisedFinalExtensions(response);
+    return response;
+  };
+  const disconnect = async () => {
+    const current = connection;
+    const dialed = stream;
+    connection = null;
+    stream = null;
+    for (const release of releaseHeld.splice(0)) release();
+    if (current != null) {
+      current.close();
+      await withTimeout(current.closed, timeoutMs, "connection close").catch(() => void 0);
+    }
+    dialed?.close?.();
+  };
+  const reconnect = async (next) => {
+    endpoint = next.resumed;
+    await connect(next.resumed);
+    const keeps = next.resumed.ref.generation === next.previous.ref.generation && described()?.supports.resumeReplay === true;
+    if (keeps) {
+      await requireConnection().agent.request(methods.agent.session.resume, {
+        sessionId: requireSession(),
+        cwd,
+        mcpServers,
+        // Null: resume without replay.
+        replayFrom: next.replayFrom
+      });
+      return "resumed";
+    }
+    const created = await requireConnection().agent.request(methods.agent.session.new, {
+      cwd,
+      mcpServers
+    });
+    sessionId = created.sessionId;
+    knownSessions.add(created.sessionId);
+    return "recreated";
+  };
+  const dropAndResume = async (replayFrom) => {
+    if (endpoint == null) throw failure("no endpoint");
+    const previous = endpoint;
+    const before = requireSession();
+    await disconnect();
+    const resumed = await args.harness.resume({
+      ...args.openArgs,
+      ref: previous.ref,
+      lastSeq: logFor(before).items.length
+    });
+    const from = logFor(before).items.length;
+    const how = await reconnect({ resumed, previous, replayFrom });
+    return { how, from: how === "resumed" ? from : 0 };
+  };
+  const waitForText = (id, from, needle, what) => waitFor(id, (items) => textOfUpdates(items.slice(from)).includes(needle), what);
+  const afterEcho = (id, from, messageId) => {
+    const items = logFor(id).items.slice(from);
+    const index = items.findIndex((update) => echoOf(update)?.messageId === messageId);
+    return index < 0 ? null : items.slice(index + 1);
+  };
+  const ownTurn = async (sent) => {
+    const id = requireSession();
+    await waitFor(
+      id,
+      () => afterEcho(id, sent.from, sent.messageId)?.some(isIdle) === true,
+      "the prompt to be answered"
+    );
+    const after = afterEcho(id, sent.from, sent.messageId) ?? [];
+    const end = after.findIndex(isIdle);
+    const updates = after.slice(0, end + 1);
+    const idle = updates.at(-1);
+    if (idle == null) throw failure("turn did not end");
+    return {
+      messageId: sent.messageId,
+      updates,
+      idle,
+      stopReason: stopReasonOf(idle),
+      text: textOfUpdates(updates)
+    };
+  };
+  const refused = (cause) => failure(
+    `a session/prompt sent while the session was running was refused (${cause instanceof Error ? cause.message : String(cause)}); it must be accepted`
+  );
+  try {
+    await step("describe" /* Describe */, {}, async () => {
+      description = harnessDescriptionSchema.parse(
+        await args.harness.describe({
+          config: args.openArgs.config,
+          secrets: args.openArgs.secrets
+        })
+      );
+      return `transports ${description.acp.transports.join(", ")}; mcp ${description.acp.mcp.join(", ") || "none"}`;
+    });
+    await step(
+      "open" /* Open */,
+      { requires: ["describe" /* Describe */] },
+      async () => {
+        endpoint = await args.harness.open(args.openArgs);
+        check(endpoint.ref.harnessSessionRef.length > 0, "endpoint has no harnessSessionRef");
+        return `transport ${endpoint.transport}`;
+      }
+    );
+    await step(
+      "initialize" /* Initialize */,
+      { requires: ["open" /* Open */] },
+      async () => {
+        if (endpoint == null) throw failure("no endpoint");
+        const response = await connect(endpoint);
+        check(
+          response.protocolVersion === PROTOCOL_VERSION,
+          `protocolVersion ${response.protocolVersion}, expected ${PROTOCOL_VERSION}`
+        );
+        return `${response.info.name} ${response.info.version}`;
+      }
+    );
+    const httpFixture = args.httpMcp == null ? null : await (async () => {
+      const fixture = createConformanceMcpHttpHandler(nonce);
+      const served = await args.httpMcp?.serve(fixture.fetch);
+      cleanups.push(async () => {
+        await served?.close();
+        await fixture.close();
+      });
+      return served ?? null;
+    })();
+    await step(
+      "session/new" /* NewSession */,
+      { requires: ["initialize" /* Initialize */] },
+      async () => {
+        const mcp = described()?.acp.mcp ?? [];
+        mcpServers = [...args.openArgs.mcpServers];
+        if (mcp.includes(McpTransportKind.Acp)) {
+          mcpServers.push({
+            type: "acp",
+            name: CONFORMANCE_ACP_SERVER_NAME,
+            serverId: CONFORMANCE_ACP_SERVER_ID
+          });
+        }
+        if (mcp.includes(McpTransportKind.Http) && httpFixture != null) {
+          mcpServers.push({
+            type: "http",
+            name: CONFORMANCE_HTTP_SERVER_NAME,
+            url: httpFixture.url,
+            headers: Object.entries(httpFixture.headers).map(([headerName, value]) => ({
+              name: headerName,
+              value
+            }))
+          });
+        }
+        const response = await requireConnection().agent.request(methods.agent.session.new, {
+          cwd,
+          mcpServers
+        });
+        check(response.sessionId.length > 0, "empty sessionId");
+        sessionId = response.sessionId;
+        knownSessions.add(response.sessionId);
+        return `session ${response.sessionId}`;
+      }
+    );
+    const sessionCases = ["session/new" /* NewSession */];
+    await step("prompt" /* Prompt */, { requires: sessionCases }, async () => {
+      echoText = `hello conformance ${nonce}`;
+      firstPrompt = sendPrompt(directive(ConformanceDirective.Echo, echoText));
+      const sent = await firstPrompt;
+      check(sent.messageId.length > 0, "session/prompt returned no messageId");
+      return `messageId ${sent.messageId}`;
+    });
+    await step(
+      "stream" /* Stream */,
+      { requires: ["prompt" /* Prompt */] },
+      async () => {
+        if (firstPrompt == null) throw failure("no prompt");
+        const result = await awaitTurn(await firstPrompt);
+        check(
+          result.updates.some((update) => update.sessionUpdate === "agent_message_chunk"),
+          "no agent_message_chunk before idle"
+        );
+        check(
+          result.text === echoText,
+          `streamed text ${JSON.stringify(result.text)}, expected ${JSON.stringify(echoText)}`
+        );
+        check(
+          result.stopReason === "end_turn",
+          `stopReason ${result.stopReason}, expected end_turn`
+        );
+        return `${result.updates.length} updates`;
+      }
+    );
+    await step("permission" /* Permission */, { requires: sessionCases }, async () => {
+      const before = permissionRequests.length;
+      const result = await turn(directive(ConformanceDirective.Permission));
+      check(permissionRequests.length > before, "no session/request_permission was sent");
+      check(
+        permissionRequests[permissionRequests.length - 1]?.optionKinds.includes("allow_once") === true,
+        "the permission request had no allow_once option"
+      );
+      check(result.text === "permission:allow_once", `reply ${JSON.stringify(result.text)}`);
+      check(result.stopReason === "end_turn", `stopReason ${result.stopReason}`);
+    });
+    await step(
+      "elicitation" /* Elicitation */,
+      {
+        requires: sessionCases,
+        skip: mcpServers.length === 0 ? "no client MCP fixture can be attached" : null
+      },
+      async () => {
+        const before = elicitations.length;
+        const result = await turn(directive(ConformanceDirective.Elicit));
+        check(elicitations.length > before, "no elicitation/create was sent");
+        check(
+          result.text === `elicitation:accept:${CONFORMANCE_ELICITATION_ANSWER}`,
+          `reply ${JSON.stringify(result.text)}`
+        );
+      }
+    );
+    await step(
+      "mcp over acp" /* McpAcp */,
+      {
+        requires: sessionCases,
+        skip: described()?.acp.mcp.includes(McpTransportKind.Acp) === true ? null : "harness does not accept acp MCP servers"
+      },
+      async () => {
+        const before = mcpMessages.length;
+        const result = await turn(
+          directive(
+            ConformanceDirective.Mcp,
+            `${CONFORMANCE_ACP_SERVER_NAME} ${CONFORMANCE_MCP_TOOL} {"text":"via-acp"}`
+          )
+        );
+        check(
+          mcpMessages.slice(before).some((message) => message.serverId === CONFORMANCE_ACP_SERVER_ID),
+          "no mcp/message reached the client"
+        );
+        const expected = `mcp:${conformanceEchoText(nonce, "via-acp")}`;
+        check(
+          result.text === expected,
+          `reply ${JSON.stringify(result.text)}, expected ${JSON.stringify(expected)}`
+        );
+      }
+    );
+    await step(
+      "mcp over http" /* McpHttp */,
+      {
+        requires: sessionCases,
+        skip: described()?.acp.mcp.includes(McpTransportKind.Http) !== true ? "harness does not accept http MCP servers" : httpFixture == null ? "no httpMcp host given" : null
+      },
+      async () => {
+        const result = await turn(
+          directive(
+            ConformanceDirective.Mcp,
+            `${CONFORMANCE_HTTP_SERVER_NAME} ${CONFORMANCE_MCP_TOOL} {"text":"via-http"}`
+          )
+        );
+        const expected = `mcp:${conformanceEchoText(nonce, "via-http")}`;
+        check(
+          result.text === expected,
+          `reply ${JSON.stringify(result.text)}, expected ${JSON.stringify(expected)}`
+        );
+      }
+    );
+    await step(
+      "observe" /* Observe */,
+      {
+        requires: sessionCases,
+        skip: !final ? "not part of the plain ACP v2 profile" : described()?.supports.observe !== true ? "harness does not declare supports.observe" : null
+      },
+      async () => {
+        const id = requireSession();
+        const observed = `observed-${nonce}`;
+        const before = logFor(id).items.length;
+        await requireConnection().agent.notify(OBSERVE_METHOD, {
+          sessionId: id,
+          content: [{ type: "text", text: observed }]
+        });
+        await sleep(200);
+        check(
+          !logFor(id).items.slice(before).some((update) => update.sessionUpdate === "state_update"),
+          "_final/session/observe started a turn"
+        );
+        const result = await turn(directive(ConformanceDirective.History));
+        check(
+          result.text.split("\n").includes(observed),
+          "observed content is missing from the history"
+        );
+      }
+    );
+    await step("error stop" /* ErrorStop */, { requires: sessionCases }, async () => {
+      const result = await turn(directive(ConformanceDirective.Error));
+      check(result.stopReason === "error", `stopReason ${result.stopReason}, expected error`);
+      if (final) {
+        const meta = providerErrorSchema.safeParse(
+          "_meta" in result.idle ? result.idle._meta : null
+        );
+        check(
+          meta.success,
+          '_meta["final.ai"].providerError {code, message, retryable} is missing on the error stop'
+        );
+      }
+    });
+    await step("cancel" /* Cancel */, { requires: sessionCases }, async () => {
+      const id = requireSession();
+      const sent = await sendPrompt(directive(ConformanceDirective.Slow));
+      await waitFor(
+        id,
+        (items) => items.slice(sent.from).some((update) => update.sessionUpdate === "agent_message_chunk"),
+        "slow turn start"
+      );
+      await requireConnection().agent.notify(methods.agent.session.cancel, { sessionId: id });
+      const result = await awaitTurn(sent);
+      check(
+        result.stopReason === "cancelled",
+        `stopReason ${result.stopReason}, expected cancelled`
+      );
+    });
+    await step(
+      "resume with replay" /* ResumeReplay */,
+      {
+        requires: ["stream" /* Stream */],
+        skip: described()?.supports.resumeReplay === true ? null : "harness does not declare supports.resumeReplay (resume re-seeds with session/new)"
+      },
+      async () => {
+        const id = requireSession();
+        if (endpoint == null) throw failure("no endpoint");
+        const previous = endpoint;
+        const original = [...logFor(id).items];
+        await disconnect();
+        const resumed = await args.harness.resume({
+          ...args.openArgs,
+          ref: previous.ref,
+          lastSeq: original.length
+        });
+        check(
+          resumed.ref.generation === previous.ref.generation,
+          `resume() moved the generation (${previous.ref.generation} to ${resumed.ref.generation}) although the harness declares supports.resumeReplay`
+        );
+        const from = logFor(id).items.length;
+        await reconnect({ resumed, previous, replayFrom: { type: "start" } });
+        await sleep(replayGraceMs);
+        const replayed = logFor(id).items.slice(from);
+        check(
+          textOfUpdates(replayed).includes(echoText),
+          "replay from start did not include the first turn"
+        );
+        if (!final) return `${replayed.length} updates replayed`;
+        if (!advertised.afterSeqReplay) {
+          return `${replayed.length} updates replayed; _final/after_seq not advertised`;
+        }
+        const tail = 2;
+        const fromSeq = logFor(id).items.length;
+        const cursor = resumeReplayFor({ advertised, held: original.length - tail });
+        await requireConnection().agent.request(methods.agent.session.resume, {
+          sessionId: id,
+          cwd,
+          mcpServers,
+          replayFrom: cursor.replayFrom
+        });
+        await sleep(replayGraceMs);
+        const afterSeq = logFor(id).items.slice(fromSeq);
+        check(
+          afterSeq.length === tail && afterSeq.every(
+            (update, index) => update.sessionUpdate === original[original.length - tail + index]?.sessionUpdate
+          ),
+          `replay after seq returned ${afterSeq.length} updates, expected the last ${tail}`
+        );
+        return `${replayed.length} updates replayed; after_seq ok`;
+      }
+    );
+    await step("park/resume" /* ParkResume */, { requires: sessionCases }, async () => {
+      const id = requireSession();
+      if (endpoint == null) throw failure("no endpoint");
+      const previous = endpoint;
+      await args.harness.park(previous.ref);
+      await disconnect();
+      const resumed = await args.harness.resume({
+        ...args.openArgs,
+        ref: previous.ref,
+        lastSeq: logFor(id).items.length
+      });
+      const how = await reconnect({ resumed, previous, replayFrom: null });
+      const text = `after park ${nonce}`;
+      const result = await turn(directive(ConformanceDirective.Echo, text));
+      check(result.text === text, `reply after resume ${JSON.stringify(result.text)}`);
+      check(result.stopReason === "end_turn", `stopReason ${result.stopReason}`);
+      return how === "resumed" ? "session resumed" : "session recreated (state did not survive)";
+    });
+    const declaredSteer = () => described()?.promptWhileRunning ?? PromptWhileRunning.Queue;
+    const survives = () => described()?.sessionSurvivesDisconnect === true;
+    await step("prompt while running" /* PromptWhileRunning */, { requires: sessionCases }, async () => {
+      const id = requireSession();
+      const declared = declaredSteer();
+      const first = await sendPrompt(directive(ConformanceDirective.Wait, "800"));
+      await waitForText(id, first.from, "wait:started", "the running turn");
+      const steer = `steer-${nonce}`;
+      const second = await sendPrompt(directive(ConformanceDirective.Echo, steer)).catch(
+        (cause) => {
+          throw refused(cause);
+        }
+      );
+      await waitFor(
+        id,
+        (items2) => {
+          const after = afterEcho(id, first.from, second.messageId);
+          return after != null && textOfUpdates(items2.slice(first.from)).includes(steer) && textOfUpdates(items2.slice(first.from)).includes("wait:done") && items2.slice(first.from).filter(isIdle).length >= (declared === PromptWhileRunning.Queue ? 2 : 1) && after.some(isIdle);
+        },
+        "both prompts to settle"
+      );
+      const items = logFor(id).items.slice(first.from);
+      const secondEcho = items.findIndex(
+        (update) => echoOf(update)?.messageId === second.messageId
+      );
+      const firstIdle = items.findIndex(isIdle);
+      const observed = secondEcho < firstIdle ? PromptWhileRunning.Inject : PromptWhileRunning.Queue;
+      check(
+        observed === declared,
+        `declares promptWhileRunning: ${declared}, but the second prompt's echo came ${observed === PromptWhileRunning.Inject ? "before" : "after"} the running turn's idle (${observed})`
+      );
+      for (const idle of items.filter(isIdle)) {
+        check(
+          stopReasonOf(idle) === "end_turn",
+          `a turn ended ${stopReasonOf(idle) ?? "without a stopReason"}`
+        );
+      }
+      if (observed === PromptWhileRunning.Inject) {
+        check(
+          textOfUpdates(items.slice(0, firstIdle)).includes(steer),
+          "the injected prompt was not handled before the running turn ended"
+        );
+        return "inject: one idle ended both turns";
+      }
+      const nextIdle = items.slice(secondEcho).findIndex(isIdle);
+      check(
+        textOfUpdates(items.slice(secondEcho, secondEcho + nextIdle)).includes(steer),
+        "the queued prompt was not answered in its own turn"
+      );
+      return "queue: running, idle, running, idle";
+    });
+    await step("cancel reaching a prompt sent while running" /* CancelWhileRunning */, { requires: sessionCases }, async () => {
+      const id = requireSession();
+      const declared = declaredSteer();
+      const first = await sendPrompt(directive(ConformanceDirective.Slow));
+      await waitForText(id, first.from, "slow:started", "the slow turn");
+      const dropped = `cancelled-${nonce}`;
+      await sendPrompt(directive(ConformanceDirective.Echo, dropped)).catch((cause) => {
+        throw refused(cause);
+      });
+      await sleep(100);
+      await requireConnection().agent.notify(methods.agent.session.cancel, { sessionId: id });
+      await waitFor(id, (items2) => items2.slice(first.from).some(isIdle), "the cancelled turn");
+      await sleep(replayGraceMs);
+      const items = logFor(id).items.slice(first.from);
+      const idleAt = items.findIndex(isIdle);
+      check(
+        stopReasonOf(items[idleAt] ?? items[0] ?? { sessionUpdate: "state_update" }) === "cancelled",
+        `the turn ended ${stopReasonOf(items[idleAt] ?? { sessionUpdate: "state_update" }) ?? "without a stopReason"}, expected cancelled`
+      );
+      const after = items.slice(idleAt + 1);
+      check(
+        !after.some(isRunning) && textOfUpdates(after) === "",
+        "work went on after session/cancel: it must reach every accepted prompt"
+      );
+      if (declared === PromptWhileRunning.Queue) {
+        check(
+          !textOfUpdates(items).includes(dropped),
+          "a queued prompt ran although session/cancel arrived before it started"
+        );
+      }
+      return `${declared}: one cancelled idle, nothing after it`;
+    });
+    await step("unanswered prompt across a dropped connection" /* NoResend */, { requires: sessionCases }, async () => {
+      const token = `once-${nonce}`;
+      promptDrop.armed = true;
+      promptDrop.dropped = false;
+      const outcome = sendPrompt(directive(ConformanceDirective.Echo, token)).then(
+        () => "answered",
+        () => "unanswered"
+      );
+      const deadline = Date.now() + timeoutMs;
+      while (!promptDrop.dropped && Date.now() < deadline) await sleep(5);
+      promptDrop.armed = false;
+      check(promptDrop.dropped, "the harness never answered the session/prompt");
+      const { how, from } = await dropAndResume({ type: "start" });
+      check(await outcome === "unanswered", "the prompt response reached the client");
+      const id = requireSession();
+      await sleep(replayGraceMs);
+      const echoes = (items) => accumulateAgentMessages(
+        items.flatMap((update) => {
+          if (update.sessionUpdate === "user_message")
+            return [{ ...update, sessionUpdate: "agent_message" }];
+          if (update.sessionUpdate === "user_message_chunk")
+            return [{ ...update, sessionUpdate: "agent_message_chunk" }];
+          return [];
+        })
+      ).filter((message) => message.text.includes(token)).length;
+      const inserted = echoes(logFor(id).items.slice(from)) > 0;
+      if (!inserted) await turn(directive(ConformanceDirective.Echo, token));
+      else if (survives()) await waitForText(id, from, token, "the inserted prompt to be answered");
+      await sleep(replayGraceMs);
+      const count = echoes(logFor(id).items.slice(from));
+      check(count === 1, `the prompt was echoed ${count} times after the reconnect, expected once`);
+      return inserted ? `inserted before the drop (${how}); the replay showed it, so it was not resent` : `not inserted (${how}); sent once more`;
+    });
+    await step("disconnect mid-turn" /* DisconnectMidTurn */, { requires: sessionCases }, async () => {
+      const sent = await sendPrompt(directive(ConformanceDirective.Wait, "600"));
+      await waitForText(requireSession(), sent.from, "wait:started", "the running turn");
+      const { how, from } = await dropAndResume({ type: "start" });
+      const id = requireSession();
+      if (survives()) {
+        check(
+          how === "resumed",
+          "declares sessionSurvivesDisconnect but the session could not be resumed with replay"
+        );
+        await waitFor(
+          id,
+          () => {
+            const after2 = afterEcho(id, from, sent.messageId);
+            return after2 != null && textOfUpdates(after2).includes("wait:done") && after2.some(isIdle);
+          },
+          "the running turn to finish across the dropped connection"
+        );
+        const after = afterEcho(id, from, sent.messageId) ?? [];
+        const idle = after.find(isIdle);
+        check(
+          idle != null && stopReasonOf(idle) === "end_turn",
+          `the turn ended ${idle == null ? "never" : stopReasonOf(idle)} after the reconnect`
+        );
+        return "the turn kept running and was replayed";
+      }
+      const text = `after-drop-${nonce}`;
+      const result = await ownTurn(await sendPrompt(directive(ConformanceDirective.Echo, text)));
+      check(result.text.includes(text), `reply after the reconnect ${JSON.stringify(result.text)}`);
+      return `state not kept (${how}): the client ends the turn harness_state_lost`;
+    });
+    await step(
+      "disconnect mid-permission" /* DisconnectMidPermission */,
+      { requires: ["permission" /* Permission */] },
+      async () => {
+        holdPermissions = true;
+        const before = permissionIds.length;
+        const sent = await sendPrompt(directive(ConformanceDirective.Permission));
+        const deadline = Date.now() + timeoutMs;
+        while (permissionIds.length === before && Date.now() < deadline) await sleep(5);
+        holdPermissions = false;
+        const held = permissionIds[before];
+        check(held != null, "no session/request_permission was sent");
+        const { how, from } = await dropAndResume({ type: "start" });
+        const id = requireSession();
+        if (survives()) {
+          check(
+            how === "resumed",
+            "declares sessionSurvivesDisconnect but the session could not be resumed with replay"
+          );
+          const reraised = Date.now() + timeoutMs;
+          while (!permissionIds.some(
+            (entry) => entry.epoch === epoch && entry.requestId === held?.requestId
+          ) && Date.now() < reraised) {
+            await sleep(5);
+          }
+          check(
+            permissionIds.some(
+              (entry) => entry.epoch === epoch && entry.requestId === held?.requestId
+            ),
+            `the open permission request (id ${JSON.stringify(held?.requestId)}) was not re-raised with the same id after session/resume`
+          );
+          await waitFor(
+            id,
+            () => {
+              const after = afterEcho(id, from, sent.messageId);
+              return after != null && after.some(isIdle);
+            },
+            "the turn to finish after the re-raised request was answered"
+          );
+          check(
+            textOfUpdates(afterEcho(id, from, sent.messageId) ?? []).includes(
+              "permission:allow_once"
+            ),
+            "the answer to the re-raised request did not reach the turn"
+          );
+          return "re-raised with the same id and answered";
+        }
+        const text = `after-permission-drop-${nonce}`;
+        const result = await ownTurn(await sendPrompt(directive(ConformanceDirective.Echo, text)));
+        check(
+          result.text.includes(text),
+          `reply after the reconnect ${JSON.stringify(result.text)}`
+        );
+        return `state not kept (${how}): the request resolves cancelled, the turn harness_state_lost`;
+      }
+    );
+    await step(
+      "native session identity across resume" /* NativeIdPreservation */,
+      {
+        requires: sessionCases,
+        skip: args.nativeSessionId == null ? "driver has no independent native session identity probe" : described()?.supports.resumeReplay !== true ? "harness does not declare supports.resumeReplay" : null
+      },
+      async () => {
+        const id = requireSession();
+        const before = await args.nativeSessionId?.(id);
+        check(
+          before != null && before.length > 0,
+          "native session identity was unavailable before resume"
+        );
+        const marker = `native-resume-${nonce}`;
+        await turn(directive(ConformanceDirective.Echo, marker));
+        const { how } = await dropAndResume(null);
+        check(
+          how === "resumed" && requireSession() === id,
+          "ACP session identity changed across resume"
+        );
+        const history = await turn(directive(ConformanceDirective.History));
+        check(history.text.includes(marker), "native history was lost across resume");
+        check(
+          await args.nativeSessionId?.(id) === before,
+          "native session identity changed across resume"
+        );
+        return "independent native identity and conversation history retained across resume";
+      }
+    );
+    await step(
+      "native session id change" /* NativeIdChange */,
+      {
+        requires: sessionCases,
+        skip: args.nativeSessionId == null ? "driver has no independent native session identity probe" : args.nativeClearPrompt === null ? "harness has no public native session reset action" : null
+      },
+      async () => {
+        const id = requireSession();
+        const before = await args.nativeSessionId?.(id);
+        check(
+          before != null && before.length > 0,
+          "native session identity was unavailable before clear"
+        );
+        const foreign = foreignUpdates.length;
+        const cleared = await turn(args.nativeClearPrompt ?? directive(ConformanceDirective.Clear));
+        check(cleared.stopReason === "end_turn", `clear ended ${cleared.stopReason}`);
+        const after = await args.nativeSessionId?.(id);
+        check(
+          after != null && after.length > 0,
+          "native session identity was unavailable after clear"
+        );
+        check(after !== before, "clear did not change the native session identity");
+        const text = `after-clear-${nonce}`;
+        const result = await turn(directive(ConformanceDirective.Echo, text));
+        check(result.text === text, `reply after clear ${JSON.stringify(result.text)}`);
+        let detail = "one ACP session id across the native change";
+        if (described()?.supports.resumeReplay === true) {
+          const { how } = await dropAndResume(null);
+          check(
+            how === "resumed" && requireSession() === id,
+            "session/resume with the ACP session id failed after the native id changed"
+          );
+          const resumedText = `after-clear-resume-${nonce}`;
+          const resumed = await turn(directive(ConformanceDirective.Echo, resumedText));
+          check(resumed.text === resumedText, `reply after resume ${JSON.stringify(resumed.text)}`);
+          check(
+            await args.nativeSessionId?.(id) === after,
+            "resume did not retain the changed native session identity"
+          );
+          detail += ", and session/resume by it";
+        }
+        check(
+          foreignUpdates.length === foreign,
+          `updates arrived under ACP session ids the client never opened: ${foreignUpdates.slice(foreign).join(", ")}`
+        );
+        return detail;
+      }
+    );
+    await step(
+      "multi-megabyte tool result and image" /* OversizedFrame */,
+      {
+        requires: sessionCases,
+        skip: mcpServers.length === 0 ? "no client MCP fixture can be attached" : null
+      },
+      async () => {
+        const frames = inboundFrameBytes.length;
+        const result = await turn(directive(ConformanceDirective.Big, String(BIG_RESULT_BYTES)));
+        check(result.stopReason === "end_turn", `stopReason ${result.stopReason}`);
+        check(
+          result.text.includes("big:done"),
+          `reply ${JSON.stringify(result.text.slice(0, 200))}`
+        );
+        const largest = Math.max(0, ...inboundFrameBytes.slice(frames));
+        const blocks = toolBlocksOf(result.updates);
+        const links = blocks.flatMap((block) => {
+          const link = resourceLinkSchema.safeParse(block);
+          return link.success ? [link.data] : [];
+        });
+        const textLink = links.find((link) => link.size === BIG_RESULT_BYTES);
+        const imageLink = links.find((link) => link.mimeType?.startsWith("image/") === true);
+        if (!final) {
+          const inline = blocks.some(
+            (block) => inlineTextSchema.safeParse(block).data?.text.length === BIG_RESULT_BYTES
+          );
+          check(textLink != null || inline, "the tool result did not arrive whole");
+          return `largest frame ${largest} bytes${largest > MAX_ACP_FRAME_BYTES ? " (the session service backstop rewrites it)" : ""}`;
+        }
+        check(
+          largest <= MAX_ACP_FRAME_BYTES,
+          `a ${largest}-byte frame exceeded the ${MAX_ACP_FRAME_BYTES}-byte frame rule`
+        );
+        check(
+          textLink != null,
+          "the multi-megabyte tool result was not moved to a resource_link carrying its full size"
+        );
+        const description2 = textLink?.description ?? "";
+        check(
+          new TextEncoder().encode(description2).length <= RESOURCE_LINK_DESCRIPTION_BYTES && description2.length > 0,
+          "the resource_link description must be the first 4 KiB of the text"
+        );
+        check(
+          imageLink != null && (imageLink.size ?? 0) > MAX_INLINE_MEDIA_BYTES,
+          "the image above 256 KiB was not moved to a resource_link"
+        );
+        return `largest frame ${largest} bytes; text and image linked`;
+      }
+    );
+    await step(
+      "graceful close" /* GracefulClose */,
+      {
+        requires: ["initialize" /* Initialize */],
+        skip: initializeResponse()?.capabilities?.session == null ? "the agent advertises no session capabilities (no session/close)" : null
+      },
+      async () => {
+        const opened = await args.harness.open({
+          ...args.openArgs,
+          harnessSessionId: crypto.randomUUID()
+        });
+        const dialed = await args.dial(opened);
+        const closeIds = /* @__PURE__ */ new Map();
+        const idleSeen = /* @__PURE__ */ new Set();
+        const settledBeforeReply = /* @__PURE__ */ new Set();
+        const outgoing = dialed.writable.getWriter();
+        const watch = watchInitializeVersion({
+          writable: new WritableStream({
+            write: async (wire) => {
+              for (const message of isBatch(wire) ? wire : [wire]) {
+                const close = z.object({
+                  id: z.union([z.string(), z.number()]),
+                  method: z.literal("session/close"),
+                  params: z.object({ sessionId: z.string() })
+                }).safeParse(message);
+                if (close.success)
+                  closeIds.set(JSON.stringify(close.data.id), close.data.params.sessionId);
+              }
+              await outgoing.write(wire);
+            },
+            close: () => outgoing.close(),
+            abort: (reason) => outgoing.abort(reason)
+          }),
+          readable: dialed.readable.pipeThrough(
+            new TransformStream({
+              transform: (wire, controller) => {
+                for (const message of isBatch(wire) ? wire : [wire]) {
+                  const state = z.object({
+                    method: z.literal("session/update"),
+                    params: z.object({
+                      sessionId: z.string(),
+                      update: z.object({
+                        sessionUpdate: z.literal("state_update"),
+                        state: z.string()
+                      })
+                    })
+                  }).safeParse(message);
+                  if (state.success) {
+                    if (state.data.params.update.state === "idle")
+                      idleSeen.add(state.data.params.sessionId);
+                    else idleSeen.delete(state.data.params.sessionId);
+                  }
+                  const reply = z.object({ id: z.union([z.string(), z.number()]), result: z.unknown() }).safeParse(message);
+                  const sessionId2 = reply.success ? closeIds.get(JSON.stringify(reply.data.id)) : null;
+                  if (sessionId2 != null && idleSeen.has(sessionId2))
+                    settledBeforeReply.add(sessionId2);
+                }
+                controller.enqueue(wire);
+              }
+            })
+          )
+        });
+        const second = kitClient.connect(watch.stream);
+        try {
+          await initializeOver(second, watch);
+          const created = await second.agent.request(methods.agent.session.new, {
+            cwd,
+            mcpServers: []
+          });
+          const id = created.sessionId;
+          knownSessions.add(id);
+          await second.agent.request(methods.agent.session.prompt, {
+            sessionId: id,
+            prompt: [{ type: "text", text: directive(ConformanceDirective.Wait, "2000") }],
+            _meta: promptMeta
+          });
+          await waitForText(id, 0, "wait:started", "the running turn");
+          await second.agent.request(methods.agent.session.close, { sessionId: id });
+          check(
+            settledBeforeReply.has(id),
+            "session/close was answered while the turn was still running: close must settle the program state first"
+          );
+          await args.harness.close(opened.ref);
+          await args.harness.close(opened.ref, { force: true });
+          return "the turn settled before session/close answered; close then force close";
+        } finally {
+          second.close();
+          dialed.close?.();
+        }
+      }
+    );
+    await step("ACP v1 agent rejected" /* V1Rejected */, {}, async () => {
+      const v1 = createLegacyProtocolAgent();
+      const watch = watchInitializeVersion(v1.stream);
+      const probe = kitClient.connect(watch.stream);
+      try {
+        const cause = await initializeOver(probe, watch).then(
+          () => null,
+          (cause2) => cause2
+        );
+        check(
+          isUnsupportedProtocolVersionError(cause),
+          `a v1 initialize reply was not refused with unsupported_protocol_version (${String(cause)})`
+        );
+        check(
+          v1.received.join(",") === "initialize",
+          `the client sent ${v1.received.join(", ")} to a v1 agent`
+        );
+        return "refused with unsupported_protocol_version";
+      } finally {
+        probe.close();
+      }
+    });
+    await step(
+      "health" /* Health */,
+      { requires: ["open" /* Open */] },
+      async () => {
+        if (endpoint == null) throw failure("no endpoint");
+        const health = await args.harness.health(endpoint.ref, {
+          config: args.openArgs.config,
+          secrets: args.openArgs.secrets
+        });
+        check(health.ok, `health not ok: ${health.detail ?? ""}`);
+      }
+    );
+    await step(
+      "close" /* Close */,
+      { requires: ["open" /* Open */] },
+      async () => {
+        if (endpoint == null) throw failure("no endpoint");
+        if (connection != null && sessionId != null) {
+          await requireConnection().agent.request(methods.agent.session.close, { sessionId }).catch(() => void 0);
+        }
+        await disconnect();
+        await args.harness.close(endpoint.ref);
+      }
+    );
+  } finally {
+    await disconnect().catch(() => void 0);
+    for (const cleanup of cleanups) await cleanup().catch(() => void 0);
+  }
+  return {
+    profile,
+    passed: cases.every((entry) => entry.status !== "failed" /* Failed */),
+    description,
+    cases
+  };
+};
+const describeHarnessConformance = (api, args) => {
+  api.describe(args.name ?? `harness conformance (${args.profile})`, () => {
+    let report = null;
+    const budget = (args.timeoutMs ?? 15e3) * HARNESS_CONFORMANCE_CASES.length;
+    api.beforeAll(async () => {
+      report = await runHarnessConformance(args);
+    }, budget);
+    for (const name of HARNESS_CONFORMANCE_CASES) {
+      api.it(name, async () => {
+        const result = report?.cases.find((entry) => entry.name === name);
+        if (result == null) throw new Error(`case ${name} did not run`);
+        if (result.status === "failed" /* Failed */)
+          throw new Error(result.error ?? "failed");
+      });
+    }
+  });
+};
+export {
+  ConformanceCaseStatus,
+  ConformanceProfile,
+  HARNESS_CONFORMANCE_CASES,
+  HarnessConformanceCase,
+  conformanceOpenArgs,
+  describeHarnessConformance,
+  runHarnessConformance
+};
+//# sourceMappingURL=harness-kit.mjs.map