@anureo/adapter-ahp 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,406 +0,0 @@
-// packages/ahp/src/index.ts
-import { HarnessSdkError as HarnessSdkError3 } from "@anureo/sdk";
-import { assertDefinition, assertEvent, assertResult, negotiateVersion, supportsExtension, publicValue } from "@anureo/protocol";
-
-// packages/ahp/src/wire.ts
-import { HarnessSdkError } from "@anureo/sdk";
-import { spawnHarnessProcess } from "@anureo/sdk/process";
-
-class AhpWire {
-  transport;
-  options;
-  nextId = 1;
-  pending = new Map;
-  closing = false;
-  tail = Promise.resolve();
-  backlog = 0;
-  loop;
-  onNotification;
-  onClose;
-  constructor(transport, options = {}) {
-    this.transport = transport;
-    this.options = options;
-    this.loop = this.read();
-  }
-  request(method, params) {
-    if (this.closing)
-      return Promise.reject(new HarnessSdkError("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true));
-    if (this.pending.size >= (this.options.maxPending ?? 256))
-      return Promise.reject(new HarnessSdkError("BACKPRESSURE_EXCEEDED"));
-    const id = this.nextId++, message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
-    if (new TextEncoder().encode(message).byteLength > (this.options.maxFrameBytes ?? 8 * 1024 * 1024))
-      return Promise.reject(new HarnessSdkError("FRAME_TOO_LARGE"));
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(new HarnessSdkError("RPC_TIMEOUT", "RPC_TIMEOUT", false, true, { method }));
-      }, this.options.timeoutMs ?? 30000);
-      this.pending.set(id, { resolve, reject, timer });
-      this.transport.send(message).catch(() => {
-        const p = this.pending.get(id);
-        if (p) {
-          clearTimeout(p.timer);
-          this.pending.delete(id);
-          p.reject(new HarnessSdkError("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true));
-        }
-      });
-    });
-  }
-  notify(method, params) {
-    return this.transport.send(JSON.stringify({ jsonrpc: "2.0", method, ...params === undefined ? {} : { params } }));
-  }
-  async read() {
-    let failure = new HarnessSdkError("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true);
-    try {
-      for await (const frame of this.transport.messages) {
-        if (this.closing)
-          break;
-        if (new TextEncoder().encode(frame).byteLength > (this.options.maxFrameBytes ?? 8 * 1024 * 1024))
-          throw new HarnessSdkError("FRAME_TOO_LARGE");
-        let value;
-        try {
-          value = JSON.parse(frame);
-        } catch {
-          throw new HarnessSdkError("PROTOCOL_ERROR");
-        }
-        if (!value || typeof value !== "object" || Array.isArray(value))
-          throw new HarnessSdkError("PROTOCOL_ERROR");
-        const message = value;
-        if (message.jsonrpc !== "2.0")
-          throw new HarnessSdkError("PROTOCOL_ERROR");
-        if (typeof message.method === "string") {
-          if (message.id !== undefined) {
-            await this.transport.send(JSON.stringify({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: "Method not found" } }));
-            continue;
-          }
-          if (++this.backlog > (this.options.maxNotifications ?? 2048))
-            throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
-          this.tail = this.tail.then(() => this.onNotification?.(message.method, message.params)).catch(async (cause) => {
-            await this.fail(cause);
-          }).finally(() => this.backlog--);
-        } else {
-          const pending = this.pending.get(message.id);
-          if (!pending)
-            continue;
-          clearTimeout(pending.timer);
-          this.pending.delete(message.id);
-          if (message.error && typeof message.error === "object") {
-            const error = message.error, data = error.data && typeof error.data === "object" ? error.data : {};
-            pending.reject(new HarnessSdkError(typeof data.code === "string" ? data.code : error.code === -32601 ? "CAPABILITY_UNSUPPORTED" : "AHP_RPC_ERROR", "AHP_RPC_ERROR", data.retryable === true, data.outcomeUnknown === true));
-          } else if (Object.hasOwn(message, "result"))
-            pending.resolve(message.result);
-          else
-            pending.reject(new HarnessSdkError("PROTOCOL_ERROR"));
-        }
-      }
-    } catch (cause) {
-      failure = cause;
-    }
-    if (!this.closing)
-      await this.fail(failure);
-  }
-  async fail(cause) {
-    if (this.closing)
-      return;
-    this.closing = true;
-    for (const pending of this.pending.values()) {
-      clearTimeout(pending.timer);
-      pending.reject(new HarnessSdkError("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true));
-    }
-    this.pending.clear();
-    this.options.diagnostic?.(cause instanceof HarnessSdkError ? cause.code : "PROTOCOL_ERROR");
-    await this.onClose?.(cause);
-    await this.transport.close();
-  }
-  async close() {
-    if (!this.closing)
-      await this.fail(new HarnessSdkError("RUNTIME_DISPOSED"));
-  }
-}
-async function createStdioTransport(options) {
-  const process = await (options.processFactory ?? spawnHarnessProcess)(options);
-  const max = options.maxFrameBytes ?? 8 * 1024 * 1024;
-  (async () => {
-    for await (const _ of process.stderr) {}
-  })().catch(() => {});
-  async function* messages() {
-    const decoder = new TextDecoder;
-    let buffer = "";
-    for await (const chunk of process.stdout) {
-      buffer += decoder.decode(chunk, { stream: true });
-      for (;; ) {
-        const index = buffer.indexOf(`
-`);
-        if (index < 0)
-          break;
-        const line = buffer.slice(0, index).replace(/\r$/, "");
-        buffer = buffer.slice(index + 1);
-        if (new TextEncoder().encode(line).byteLength > max)
-          throw new HarnessSdkError("FRAME_TOO_LARGE");
-        if (line)
-          yield line;
-      }
-      if (new TextEncoder().encode(buffer).byteLength > max)
-        throw new HarnessSdkError("FRAME_TOO_LARGE");
-    }
-    buffer += decoder.decode();
-    if (buffer.trim())
-      throw new HarnessSdkError("PROTOCOL_ERROR", "Unterminated AHP frame");
-  }
-  return { messages: messages(), send: (message) => process.write(message + `
-`), close: () => process.dispose() };
-}
-// packages/ahp/src/websocket.ts
-import { BoundedEventQueue, HarnessSdkError as HarnessSdkError2 } from "@anureo/sdk";
-async function createWebSocketTransport(url, options = {}) {
-  const address = new URL(url);
-  if (!["ws:", "wss:"].includes(address.protocol) || address.username || address.password || address.search || address.hash || address.protocol === "ws:" && !["127.0.0.1", "localhost", "[::1]"].includes(address.hostname))
-    throw new HarnessSdkError2("INVALID_PARAMS", "Invalid AHP WebSocket address");
-  if (!options.factory && typeof WebSocket === "undefined")
-    throw new HarnessSdkError2("WEBSOCKET_FACTORY_REQUIRED");
-  const socket = options.factory ? options.factory(url) : new WebSocket(url);
-  const queue = new BoundedEventQueue({ maxFrameBytes: options.maxFrameBytes, maxBytes: options.maxBufferedBytes ?? 16 * 1024 * 1024, maxEvents: 2048 }, (v) => new TextEncoder().encode(v).byteLength);
-  let closed = false;
-  const fail = () => {
-    queue.end(new HarnessSdkError2("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true));
-  };
-  socket.addEventListener("message", (event) => {
-    try {
-      if (typeof event.data !== "string")
-        throw new HarnessSdkError2("PROTOCOL_ERROR");
-      queue.push(event.data);
-    } catch (cause) {
-      queue.end(cause);
-      socket.close();
-    }
-  });
-  socket.addEventListener("close", () => {
-    closed = true;
-    fail();
-  });
-  socket.addEventListener("error", fail);
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      socket.close();
-      reject(new HarnessSdkError2("RPC_TIMEOUT"));
-    }, options.timeoutMs ?? 30000);
-    const finish = () => {
-      clearTimeout(timeout);
-      socket.removeEventListener("open", opened);
-      socket.removeEventListener("error", failed);
-      socket.removeEventListener("close", failed);
-    };
-    const opened = () => {
-      finish();
-      resolve();
-    }, failed = () => {
-      finish();
-      reject(new HarnessSdkError2("RPC_CONNECTION_FAILED"));
-    };
-    socket.addEventListener("open", opened);
-    socket.addEventListener("error", failed);
-    socket.addEventListener("close", failed);
-    if (socket.readyState === 1)
-      opened();
-  });
-  return { messages: queue, async send(message) {
-    if (closed || socket.readyState !== 1)
-      throw new HarnessSdkError2("RPC_CONNECTION_CLOSED", "RPC_CONNECTION_CLOSED", false, true);
-    if (socket.bufferedAmount > (options.maxBufferedBytes ?? 16 * 1024 * 1024))
-      throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED");
-    socket.send(message);
-  }, async close() {
-    if (closed)
-      return;
-    closed = true;
-    socket.close();
-    queue.end();
-  } };
-}
-
-// packages/ahp/src/index.ts
-var METADATA_EXTENSION = { name: "x-anureo/session-metadata", version: "1" };
-
-class AhpAdapter {
-  options;
-  wire;
-  initialized;
-  result;
-  sessions = new Map;
-  responding = new Map;
-  disposed = false;
-  constructor(options) {
-    this.options = options;
-  }
-  initialize(params) {
-    negotiateVersion(params.protocolVersions);
-    return this.initialized ??= (async () => {
-      let transport;
-      if (this.options.transport)
-        transport = typeof this.options.transport === "function" ? await this.options.transport() : this.options.transport;
-      else if (this.options.url) {
-        if (!this.options.connect)
-          throw new HarnessSdkError3("WEBSOCKET_FACTORY_REQUIRED");
-        transport = await this.options.connect(this.options.url);
-      } else {
-        if (!this.options.command)
-          throw new HarnessSdkError3("HARNESS_UNAVAILABLE");
-        transport = await createStdioTransport({ ...this.options, command: this.options.command });
-      }
-      const wire = this.wire = new AhpWire(transport, this.options);
-      wire.onNotification = (method, event) => this.notification(method, event);
-      wire.onClose = async (cause) => {
-        for (const session of this.sessions.values())
-          await session.sink.fail(cause);
-        for (const pending of this.responding.values())
-          pending.reject(cause);
-        this.responding.clear();
-      };
-      const clientCapabilities = { ...params.clientCapabilities, extensions: [...(params.clientCapabilities?.extensions ?? []).filter((e) => e.name !== METADATA_EXTENSION.name), METADATA_EXTENSION] };
-      const result = await wire.request("initialize", { ...params, clientCapabilities });
-      assertResult("initialize", result);
-      negotiateVersion([result.protocolVersion]);
-      this.result = result;
-      await wire.notify("initialized");
-      return result;
-    })();
-  }
-  async notification(method, value) {
-    const known = ["session/metadata", "session/state", "turn/started", "turn/completed", "item/started", "item/delta", "item/completed", "usage/updated", "interaction/requested", "interaction/resolved", "notice", "extension"];
-    if (!known.includes(method)) {
-      const raw = publicValue(JSON.parse(JSON.stringify(value ?? null)));
-      for (const session of this.sessions.values())
-        await session.sink.emit({ type: "notice", payload: { severity: "info", code: "UNKNOWN_NOTIFICATION", message: "Unknown AHP notification", raw } });
-      return;
-    }
-    assertEvent(value);
-    if (value.type !== method)
-      throw new HarnessSdkError3("PROTOCOL_ERROR");
-    const session = this.sessions.get(value.sessionId);
-    if (!session)
-      throw new HarnessSdkError3("SOURCE_SESSION_MISMATCH");
-    const last = session.lastByStream.get(value.streamId) ?? 0;
-    if (value.seq <= last)
-      return;
-    if (session.streamId && session.streamId !== value.streamId)
-      throw new HarnessSdkError3("SOURCE_STREAM_UNAVAILABLE");
-    session.streamId = value.streamId;
-    if (value.seq !== last + 1) {
-      if (!this.result || !supportsExtension(this.result.capabilities, "x-anureo/event-replay", "1"))
-        throw new HarnessSdkError3("SOURCE_SEQUENCE_GAP");
-      const raw = await this.wire.request("x-anureo/events/read", { sessionId: value.sessionId, streamId: value.streamId, afterSeq: last, throughSeq: value.seq - 1 });
-      if (!raw || typeof raw !== "object" || !("events" in raw) || !Array.isArray(raw.events))
-        throw new HarnessSdkError3("SOURCE_STREAM_UNAVAILABLE");
-      for (const event of raw.events) {
-        assertEvent(event);
-        if (event.sessionId !== value.sessionId || event.streamId !== value.streamId || event.seq !== (session.lastByStream.get(value.streamId) ?? 0) + 1 || event.seq >= value.seq)
-          throw new HarnessSdkError3("SOURCE_SEQUENCE_GAP");
-        await this.deliver(session, event);
-      }
-      if ((session.lastByStream.get(value.streamId) ?? 0) + 1 !== value.seq)
-        throw new HarnessSdkError3("SOURCE_SEQUENCE_GAP");
-    }
-    await this.deliver(session, value);
-  }
-  async deliver(session, event) {
-    session.lastByStream.set(event.streamId, event.seq);
-    const scope = { turnId: event.turnId, itemId: event.itemId };
-    if (event.type === "session/metadata" || event.type === "extension" && event.payload.name === METADATA_EXTENSION.name) {
-      if (!this.result || !supportsExtension(this.result.capabilities, METADATA_EXTENSION.name, METADATA_EXTENSION.version))
-        throw new HarnessSdkError3("CAPABILITY_UNSUPPORTED");
-      if (event.type === "extension" && event.payload.version !== METADATA_EXTENSION.version)
-        throw new HarnessSdkError3("CAPABILITY_UNSUPPORTED");
-      const metadata = event.type === "session/metadata" ? event.payload : event.payload.data;
-      assertDefinition("SessionMetadata", metadata);
-      if (Object.hasOwn(metadata, "title"))
-        session.metadataObserved = true;
-      await session.sink.emit({ type: "session/metadata", payload: metadata });
-      return;
-    }
-    if (event.type === "interaction/requested") {
-      const request = event.payload, key = `${event.sessionId}:${request.interactionId}`;
-      session.pending.add(request.interactionId);
-      session.sink.requestInteraction(request, async (response, reason) => {
-        let resolve, reject;
-        const confirmation = new Promise((yes, no) => {
-          resolve = yes;
-          reject = no;
-        });
-        this.responding.set(key, { resolve, reject });
-        try {
-          const method = response ? "interaction/respond" : "interaction/cancel";
-          const call = this.wire.request(method, { requestId: `ahp:${event.streamId}:${event.seq}`, sessionId: event.sessionId, interactionId: request.interactionId, ...response ? { response } : { reason } });
-          const result = await Promise.race([call, confirmation]);
-          assertResult(method, result);
-          if (result.outcome === "unknown")
-            throw new HarnessSdkError3("RESULT_UNKNOWN", "RESULT_UNKNOWN", false, true);
-        } finally {
-          this.responding.delete(key);
-          session.pending.delete(request.interactionId);
-        }
-      }).catch(() => {});
-      return;
-    }
-    if (event.type === "interaction/resolved") {
-      const key = `${event.sessionId}:${event.payload.interactionId}`, responding = this.responding.get(key);
-      if (responding) {
-        responding.resolve(event.payload);
-        return;
-      }
-      if (session.pending.has(event.payload.interactionId)) {
-        session.pending.delete(event.payload.interactionId);
-        await session.sink.resolveInteraction(event.payload);
-        return;
-      }
-      return;
-    }
-    if (event.type === "session/state" && event.payload.metadata && Object.hasOwn(event.payload.metadata, "title"))
-      session.metadataObserved = true;
-    await session.sink.emit({ type: event.type, payload: event.payload }, scope);
-  }
-  async openSession(params, sink) {
-    if (!this.wire || this.disposed)
-      throw new HarnessSdkError3("NOT_INITIALIZED");
-    if (this.sessions.has(params.binding.sessionId))
-      throw new HarnessSdkError3("SESSION_ALREADY_OPEN");
-    const record = { sink, lastByStream: new Map, pending: new Set };
-    this.sessions.set(params.binding.sessionId, record);
-    try {
-      const opened = await this.wire.request("session/open", params);
-      assertResult("session/open", opened);
-      if (opened.binding.sessionId !== params.binding.sessionId || opened.binding.adapterId !== params.binding.adapterId || opened.binding.runtimeConfigId !== params.binding.runtimeConfigId)
-        throw new HarnessSdkError3("SESSION_BINDING_MISMATCH");
-      record.streamId = opened.streamId;
-      if (!record.metadataObserved && opened.state?.metadata)
-        await sink.emit({ type: "session/metadata", payload: opened.state.metadata });
-      const adapter = this;
-      return { binding: opened.binding, capabilities: opened.capabilities, async execute(method, p) {
-        const result = await adapter.wire.request(method, p);
-        assertResult(method, result);
-        return result;
-      }, async dispose() {
-        adapter.sessions.delete(params.binding.sessionId);
-      } };
-    } catch (cause) {
-      this.sessions.delete(params.binding.sessionId);
-      throw cause;
-    }
-  }
-  async dispose() {
-    if (this.disposed)
-      return;
-    this.disposed = true;
-    await this.wire?.close();
-    this.sessions.clear();
-  }
-}
-function createAhpAdapter(options) {
-  return new AhpAdapter(options);
-}
-export {
-  AhpAdapter,
-  AhpWire,
-  createAhpAdapter,
-  createStdioTransport,
-  createWebSocketTransport
-};

package/dist/websocket.d.ts

@@ -1,7 +0,0 @@
-import type { AhpTransport } from "./wire.js";
-export declare function createWebSocketTransport(url: string, options?: {
-    factory?: (url: string) => WebSocket;
-    timeoutMs?: number;
-    maxFrameBytes?: number;
-    maxBufferedBytes?: number;
-}): Promise<AhpTransport>;

package/dist/wire.d.ts

@@ -1,35 +0,0 @@
-import { type HarnessProcess, type HarnessProcessOptions } from "@anureo/sdk/process";
-export interface AhpTransport {
-    messages: AsyncIterable<string>;
-    send: (message: string) => Promise<void>;
-    close: () => Promise<void>;
-}
-export interface WireOptions {
-    timeoutMs?: number;
-    maxFrameBytes?: number;
-    maxPending?: number;
-    maxNotifications?: number;
-    diagnostic?: (code: string) => void;
-}
-export declare class AhpWire {
-    private readonly transport;
-    private readonly options;
-    private nextId;
-    private readonly pending;
-    private closing;
-    private tail;
-    private backlog;
-    private readonly loop;
-    onNotification?: (method: string, params: unknown) => Promise<void> | void;
-    onClose?: (cause: unknown) => Promise<void> | void;
-    constructor(transport: AhpTransport, options?: WireOptions);
-    request(method: string, params: unknown): Promise<unknown>;
-    notify(method: string, params?: unknown): Promise<void>;
-    private read;
-    private fail;
-    close(): Promise<void>;
-}
-export declare function createStdioTransport(options: HarnessProcessOptions & {
-    processFactory?: (p: HarnessProcessOptions) => Promise<HarnessProcess>;
-    maxFrameBytes?: number;
-}): Promise<AhpTransport>;

package/examples/reference.mjs

@@ -1,171 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// packages/ahp/examples/reference.ts
-import { createInterface } from "node:readline";
-import { createHarnessRuntime, HarnessSdkError } from "@anureo/sdk";
-import { assertRequest, negotiateVersion, supportsExtension } from "@anureo/protocol";
-var capabilities = { turn: { interrupt: true, inputModalities: ["text"] }, interactions: ["approval"], extensions: [{ name: "x-anureo/event-replay", version: "1" }, { name: "x-anureo/session-metadata", version: "1" }] };
-
-class ReferenceAdapter {
-  metadataEnabled = false;
-  async initialize(p) {
-    negotiateVersion(p.protocolVersions);
-    this.metadataEnabled = supportsExtension(p.clientCapabilities ?? {}, "x-anureo/session-metadata", "1");
-    return { protocolVersion: 1, runtime: { name: "reference", version: "1.0.0", adapter: "reference/1" }, capabilities };
-  }
-  async openSession(p, sink) {
-    const binding = { ...p.binding, nativeRef: { provider: "reference", value: p.binding.sessionId } };
-    let active, closed = false;
-    const metadataEnabled = this.metadataEnabled;
-    return { binding, capabilities, async execute(method, params) {
-      if (method === "session/close")
-        return { closed: true };
-      if (method === "turn/interrupt") {
-        const turnId = params.turnId;
-        if (active === turnId) {
-          active = undefined;
-          await sink.emit({ type: "turn/completed", payload: { turnId, status: "interrupted" } });
-        }
-        return { accepted: true, turnId };
-      }
-      if (method !== "turn/start")
-        throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-      const request = params;
-      active = request.turnId;
-      await sink.emit({ type: "turn/started", payload: { turnId: request.turnId, nativeTurnId: request.turnId } });
-      const text = request.input.filter((x) => x.type === "text").map((x) => x.text).join(`
-`);
-      if (metadataEnabled && text.startsWith("/title "))
-        await sink.emit({ type: "session/metadata", payload: { title: text.slice(7) || null } });
-      if (text !== "/wait")
-        (async () => {
-          if (text === "/approval")
-            await sink.requestInteraction({ kind: "approval", interactionId: `approval:${request.turnId}`, turnId: request.turnId, options: [{ id: "allow", label: "Allow once", semantic: "allowOnce" }, { id: "deny", label: "Deny", semantic: "deny" }] }, async () => {});
-          if (closed || active !== request.turnId)
-            return;
-          const item = { id: "message", type: "agentMessage", text, phase: "final" };
-          await sink.emit({ type: "item/started", payload: { item: { ...item, text: "" } } }, { turnId: request.turnId });
-          await sink.emit({ type: "item/completed", payload: { item } }, { turnId: request.turnId });
-          active = undefined;
-          await sink.emit({ type: "turn/completed", payload: { turnId: request.turnId, status: "completed" } });
-        })().catch(async () => {
-          if (!closed && active === request.turnId) {
-            active = undefined;
-            await sink.emit({ type: "turn/completed", payload: { turnId: request.turnId, status: "interrupted" } });
-          }
-        });
-      return { turnId: request.turnId, accepted: true };
-    }, async dispose() {
-      closed = true;
-      active = undefined;
-    } };
-  }
-  async dispose() {}
-}
-function createReferenceHarness(send) {
-  const runtime = createHarnessRuntime(new ReferenceAdapter), sessions = new Map, logs = new Map;
-  const publish = async (event) => {
-    if (event.type === "session/metadata")
-      event = { ...event, type: "extension", payload: { name: "x-anureo/session-metadata", version: "1", data: event.payload } };
-    const log = logs.get(event.sessionId) ?? [];
-    log.push(event);
-    if (log.length > 2048)
-      log.shift();
-    logs.set(event.sessionId, log);
-    await send(JSON.stringify({ jsonrpc: "2.0", method: event.type, params: event }));
-  };
-  const invoke = async (method, params) => {
-    if (method === "initialize") {
-      assertRequest("initialize", params);
-      return runtime.initialize(params);
-    }
-    if (method === "session/open") {
-      assertRequest("session/open", params);
-      const session = await runtime.openSession(params);
-      sessions.set(session.binding.sessionId, session);
-      const reader = session.events()[Symbol.asyncIterator](), first = await reader.next();
-      if (first.done || first.value.type !== "session/state")
-        throw new HarnessSdkError("PROTOCOL_ERROR");
-      await publish(first.value);
-      (async () => {
-        for (;; ) {
-          const entry = await reader.next();
-          if (entry.done)
-            return;
-          await publish(entry.value);
-        }
-      })().catch(() => {});
-      return { binding: session.binding, streamId: first.value.streamId, state: first.value.payload, capabilities: session.capabilities };
-    }
-    if (!params || typeof params !== "object" || !("sessionId" in params) || typeof params.sessionId !== "string")
-      throw new HarnessSdkError("INVALID_PARAMS");
-    if (method === "x-anureo/events/read") {
-      const p = params, log = logs.get(p.sessionId) ?? [];
-      const events = log.filter((e) => e.streamId === p.streamId && e.seq > p.afterSeq && e.seq <= p.throughSeq);
-      if (events[0]?.seq !== p.afterSeq + 1 && p.afterSeq < p.throughSeq)
-        throw new HarnessSdkError("SOURCE_STREAM_UNAVAILABLE");
-      return { events };
-    }
-    const session = sessions.get(params.sessionId);
-    if (!session)
-      throw new HarnessSdkError("SESSION_NOT_FOUND");
-    switch (method) {
-      case "turn/start":
-        assertRequest(method, params);
-        return session.startTurn(params);
-      case "turn/interrupt":
-        assertRequest(method, params);
-        return session.interrupt(params);
-      case "interaction/respond":
-        assertRequest(method, params);
-        return session.respond(params);
-      case "interaction/cancel":
-        assertRequest(method, params);
-        return session.cancelInteraction(params);
-      case "session/close":
-        assertRequest(method, params);
-        await session.close();
-        sessions.delete(params.sessionId);
-        return { closed: true };
-      default:
-        throw new HarnessSdkError("CAPABILITY_UNSUPPORTED");
-    }
-  };
-  return { async receive(frame) {
-    let message;
-    try {
-      message = JSON.parse(frame);
-    } catch {
-      await send(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }));
-      return;
-    }
-    if (message.method === "initialized" && message.id === undefined)
-      return;
-    if (message.jsonrpc !== "2.0" || typeof message.method !== "string" || message.id === undefined) {
-      await send(JSON.stringify({ jsonrpc: "2.0", id: message.id ?? null, error: { code: -32600, message: "Invalid request" } }));
-      return;
-    }
-    try {
-      const result = await invoke(message.method, message.params);
-      await send(JSON.stringify({ jsonrpc: "2.0", id: message.id, result }));
-    } catch (cause) {
-      const code = cause && typeof cause === "object" && "code" in cause ? String(cause.code) : "HARNESS_ERROR";
-      await send(JSON.stringify({ jsonrpc: "2.0", id: message.id, error: { code: -32070, message: code, data: { code, retryable: false, outcomeUnknown: false } } }));
-    }
-  }, close: () => runtime.dispose() };
-}
-if (__require.main == __require.module) {
-  const harness = createReferenceHarness((message) => {
-    process.stdout.write(message + `
-`);
-  });
-  const input = createInterface({ input: process.stdin });
-  for await (const line of input) {
-    harness.receive(line);
-  }
-  await harness.close();
-}
-export {
-  createReferenceHarness
-};