@anureo/adapter-acp 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,852 +0,0 @@
-// packages/acp/src/file-changes.ts
-function acpFileChanges(content) {
-  if (!Array.isArray(content))
-    return [];
-  return content.flatMap((value) => {
-    if (!value || typeof value !== "object")
-      return [];
-    const part = value;
-    if (part.type !== "diff" || typeof part.path !== "string" || !(part.oldText === undefined || part.oldText === null || typeof part.oldText === "string") || typeof part.newText !== "string")
-      return [];
-    const oldText = part.oldText ?? null;
-    return [{ path: part.path, operation: oldText === null ? "add" : "modify", materials: [{ format: "text", scope: "file", oldText, newText: part.newText }], completeness: "complete" }];
-  });
-}
-
-// packages/acp/src/index.ts
-import * as acp from "@agentclientprotocol/sdk";
-import {
-  spawnHarnessProcess,
-  HarnessSdkError as HarnessSdkError2,
-  waitForRequest
-} from "@anureo/sdk";
-import {
-  negotiateVersion,
-  assertResult,
-  assertDefinition
-} from "@anureo/protocol";
-
-// packages/acp/src/mapping.ts
-import { publicValue } from "@anureo/protocol";
-import { HarnessSdkError } from "@anureo/sdk";
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function safe(value) {
-  return publicValue(JSON.parse(JSON.stringify(value ?? null)));
-}
-function text(value) {
-  if (typeof value === "string")
-    return value;
-  if (Array.isArray(value))
-    return value.map(text).join(`
-`);
-  const object = record(value);
-  if (object.type === "text" && typeof object.text === "string")
-    return object.text;
-  if (object.type === "content")
-    return text(object.content);
-  if (object.type === "diff")
-    return `${typeof object.oldText === "string" ? object.oldText : ""}
-${typeof object.newText === "string" ? object.newText : ""}`;
-  if (object.type === "resource")
-    return text(object.resource);
-  return "";
-}
-function input(blocks) {
-  return blocks.map((block) => {
-    if (block.type === "text")
-      return { type: "text", text: block.text };
-    if (block.type === "file")
-      return { type: "resource_link", uri: block.uri, name: block.name ?? block.uri, ...block.mimeType ? { mimeType: block.mimeType } : {} };
-    if (!block.data || !block.mimeType)
-      throw new HarnessSdkError("INVALID_PARAMS", "ACP images require inline data and mimeType");
-    return { type: "image", data: block.data, mimeType: block.mimeType, ...block.url ? { uri: block.url } : {} };
-  });
-}
-function mcp(servers = []) {
-  return servers.map((server) => server.type === "http" ? { type: "http", name: server.name, url: server.url, headers: Object.entries(server.headers ?? {}).map(([name, value]) => ({ name, value })) } : { name: server.name, command: server.command, args: server.args ?? [], env: Object.entries(server.env ?? {}).map(([name, value]) => ({ name, value })) });
-}
-function selectValues(value) {
-  return Array.isArray(value) ? value.flatMap((entry) => {
-    const option = record(entry);
-    return typeof option.value === "string" ? [option.value] : selectValues(option.options);
-  }) : [];
-}
-function configuration(data) {
-  const options = [], values = {}, keys = new Map;
-  for (const item of Array.isArray(data.configOptions) ? data.configOptions : []) {
-    const option = record(item);
-    if (typeof option.id !== "string")
-      continue;
-    const id = option.id;
-    const current = option.currentValue;
-    if (option.type !== "boolean" && option.type !== "select")
-      continue;
-    const schema = option.type === "boolean" ? { type: "boolean" } : { type: "string", enum: selectValues(option.options) };
-    const descriptor = { id, title: typeof option.name === "string" ? option.name : id, scope: "session", schema, ...typeof current === "string" || typeof current === "boolean" ? { value: current } : {} };
-    options.push(descriptor);
-    keys.set(id, option);
-    if (descriptor.value !== undefined)
-      values[id] = descriptor.value;
-    if (option.category === "model" && id !== "model") {
-      options.push({ ...descriptor, id: "model" });
-      keys.set("model", option);
-      if (descriptor.value !== undefined)
-        values.model = descriptor.value;
-    }
-  }
-  const modes = record(data.modes);
-  if (Array.isArray(modes.availableModes)) {
-    const modeIds = modes.availableModes.map((mode) => record(mode).id).filter((id) => typeof id === "string");
-    options.push({ id: "mode", title: "ACP mode", scope: "session", schema: { type: "string", enum: modeIds } });
-    keys.set("mode", { id: "mode", type: "mode", options: modeIds });
-    if (typeof modes.currentModeId === "string")
-      values.mode = modes.currentModeId;
-  }
-  return { options, values, keys };
-}
-
-class AcpUpdateMapper {
-  sink;
-  getTurn;
-  state;
-  setState;
-  subagents;
-  items = new Map;
-  ended = new Set;
-  serial = 0;
-  compaction = new Map;
-  constructor(sink, getTurn, state, setState, subagents) {
-    this.sink = sink;
-    this.getTurn = getTurn;
-    this.state = state;
-    this.setState = setState;
-    this.subagents = subagents;
-  }
-  reset() {
-    this.items.clear();
-    this.ended.clear();
-    this.compaction.clear();
-    this.serial = 0;
-  }
-  async upsert(item, terminal = false) {
-    const turnId = this.getTurn();
-    if (!turnId)
-      return;
-    const old = this.items.get(item.id);
-    this.items.set(item.id, item);
-    if (this.ended.has(item.id))
-      return;
-    if (!old)
-      await this.sink.emit({ type: "item/started", payload: { item } }, { turnId });
-    else if (!terminal)
-      await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "patch", value: safe(item) } }, { turnId });
-    if (terminal) {
-      this.ended.add(item.id);
-      await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId });
-    }
-  }
-  async complete() {
-    for (const item of this.items.values())
-      if (!this.ended.has(item.id))
-        await this.upsert({ ...item, status: item.status === "running" ? "completed" : item.status }, true);
-  }
-  async update(update) {
-    const kind = update.sessionUpdate;
-    const turnId = this.getTurn();
-    if (kind === "config_option_update" || kind === "current_mode_update") {
-      this.setState(update);
-      await this.sink.emit({ type: "session/state", payload: this.state() });
-      return;
-    }
-    if (kind === "usage_update") {
-      await this.sink.emit({ type: "usage/updated", payload: { provider: "acp", scope: "session", source: "native", ...typeof update.used === "number" ? { contextUsed: update.used } : {}, ...typeof update.size === "number" ? { contextWindow: update.size } : {} } }, { ...turnId ? { turnId } : {} });
-      return;
-    }
-    if (kind === "session_info_update") {
-      if (Object.hasOwn(update, "title") && (typeof update.title === "string" || update.title === null)) {
-        const title = update.title;
-        if (this.state().metadata?.title !== title) {
-          this.setState({ sessionTitle: title });
-          await this.sink.emit({ type: "session/metadata", payload: { title } });
-        }
-      }
-      return;
-    }
-    if (!turnId || kind === "available_commands_update") {
-      await this.sink.emit({ type: "notice", payload: { severity: "info", code: `ACP_${String(kind ?? "UPDATE").toUpperCase()}`, message: "ACP session metadata update", raw: safe(update) } });
-      return;
-    }
-    if (["agent_message_chunk", "agent_thought_chunk", "user_message_chunk"].includes(String(kind))) {
-      const nativeId = typeof update.messageId === "string" ? update.messageId : String(kind);
-      const id = `${String(kind)}:${nativeId}`;
-      const chunk = text(update.content);
-      if (!chunk && record(update.content).type !== "text")
-        await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_NON_TEXT_CONTENT", message: "ACP non-text content retained", raw: safe(update.content) } }, { turnId });
-      let item = this.items.get(id);
-      if (!item) {
-        item = kind === "agent_thought_chunk" ? { id, type: "reasoning", text: "" } : kind === "user_message_chunk" ? { id, type: "userMessage", content: [] } : { id, type: "agentMessage", text: "", phase: "final" };
-        this.items.set(id, item);
-        await this.sink.emit({ type: "item/started", payload: { item } }, { turnId });
-      }
-      if (item.type === "userMessage") {
-        const content = record(update.content);
-        if (content.type === "text")
-          item.content.push({ type: "text", text: chunk });
-        else if (content.type === "image" && typeof content.data === "string")
-          item.content.push({ type: "image", data: content.data, mimeType: typeof content.mimeType === "string" ? content.mimeType : undefined });
-        else if (content.type === "resource_link" && typeof content.uri === "string")
-          item.content.push({ type: "file", uri: content.uri });
-        else
-          await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_CONTENT", message: "ACP user content", raw: safe(update.content) } }, { turnId });
-        await this.sink.emit({ type: "item/delta", payload: { itemId: id, kind: "patch", value: safe(item) } }, { turnId });
-      } else if (item.type === "agentMessage" || item.type === "reasoning") {
-        item.text = (item.text ?? "") + chunk;
-        await this.sink.emit({ type: "item/delta", payload: { itemId: id, kind: "text", text: chunk } }, { turnId });
-      }
-      return;
-    }
-    if (kind === "tool_call" || kind === "tool_call_update") {
-      const id = String(update.toolCallId);
-      const old = this.items.get(id);
-      const kindMap = { execute: "command", edit: "fileChange", delete: "fileChange", move: "fileChange", fetch: "web" };
-      const status = update.status === "failed" ? "failed" : update.status === "completed" ? "completed" : update.status === undefined && old?.type === "toolCall" ? old.status ?? "running" : "running";
-      const item = {
-        ...old?.type === "toolCall" ? old : { id, type: "toolCall", kind: "other", title: "ACP tool" },
-        ...typeof update.title === "string" ? { title: update.title } : {},
-        ...typeof update.kind === "string" ? { kind: kindMap[update.kind] ?? "other", nativeType: update.kind } : {},
-        status,
-        ...update.content !== undefined ? { fileChanges: acpFileChanges(update.content) } : {},
-        ...update.rawInput !== undefined ? { input: safe(update.rawInput) } : {},
-        ...update.rawOutput !== undefined ? { output: safe(update.rawOutput) } : update.content !== undefined ? { output: safe(update.content) } : {},
-        ...Array.isArray(update.locations) ? { locations: update.locations.flatMap((location) => {
-          const value = record(location);
-          return typeof value.path === "string" ? [{ path: value.path, ...typeof value.line === "number" ? { line: value.line } : {} }] : [];
-        }) } : {}
-      };
-      await this.upsert(item, status !== "running");
-      return;
-    }
-    if (kind === "plan") {
-      const entries = Array.isArray(update.entries) ? update.entries : [];
-      await this.upsert({ id: "acp-plan", type: "plan", steps: entries.map((entry, index) => {
-        const value = record(entry);
-        return { id: String(index), text: String(value.content ?? ""), status: value.status === "completed" ? "completed" : value.status === "in_progress" ? "inProgress" : "pending" };
-      }) });
-      return;
-    }
-    if (kind === "plan_update" || kind === "plan_removed") {
-      const plan = record(update.plan);
-      const id = `plan:${String(update.planId ?? plan.planId ?? ++this.serial)}`;
-      await this.upsert({ id, type: "plan", steps: kind === "plan_removed" ? [] : [{ id: "content", text: text(plan.content ?? record(plan).markdown ?? plan), status: "pending" }], extensions: { "x-acp/native-plan": safe(update) } }, kind === "plan_removed");
-      return;
-    }
-    if (kind === "compaction_update" || kind === "compaction_summary_chunk") {
-      const id = `compaction:${String(update.compactionId)}`;
-      let summary = this.compaction.get(id) ?? "";
-      if (kind === "compaction_summary_chunk")
-        summary += text(update.content);
-      else if ("summary" in update)
-        summary = text(update.summary);
-      this.compaction.set(id, summary);
-      const terminal = update.status === "completed" || update.status === "failed" || update.status === "cancelled";
-      await this.upsert({ id, type: "compaction", summary, status: update.status === "failed" ? "failed" : update.status === "cancelled" ? "interrupted" : terminal ? "completed" : "running" }, terminal);
-      return;
-    }
-    if ((kind === "subagent_spawned" || kind === "subagent_state_update") && this.subagents) {
-      const id = `subagent:${String(update.subagentSessionId)}`;
-      const old = this.items.get(id);
-      const state = update.state === "completed" ? "completed" : ["cancelled", "disconnected"].includes(String(update.state)) ? "interrupted" : update.state === "failed" ? "failed" : "running";
-      await this.upsert({ ...old?.type === "subagent" ? old : { id, type: "subagent", subagentId: String(update.subagentSessionId) }, state, ...typeof update.name === "string" ? { name: update.name } : {}, ...typeof update.task === "string" ? { task: update.task } : {} }, state !== "running");
-      return;
-    }
-    await this.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_UPDATE", message: "Unmapped ACP update retained", raw: safe(update) } }, { turnId });
-  }
-}
-
-// packages/acp/src/index.ts
-function deferred() {
-  let resolve, reject;
-  const promise = new Promise((yes, no) => {
-    resolve = yes;
-    reject = no;
-  });
-  promise.catch(() => {});
-  return { promise, resolve, reject };
-}
-function errorFromNative(error, fallback = "ACP_REQUEST_FAILED") {
-  if (error instanceof HarnessSdkError2)
-    return error;
-  if (error instanceof acp.RequestError) {
-    const code = error.code === -32601 ? "CAPABILITY_UNSUPPORTED" : error.code === -32602 ? "INVALID_PARAMS" : error.code === -32000 ? "AUTH_REQUIRED" : error.code === -32002 ? "RESOURCE_NOT_FOUND" : fallback;
-    return new HarnessSdkError2(code, code, false, false, { nativeCode: error.code });
-  }
-  return new HarnessSdkError2("ACP_CONNECTION_CLOSED", "ACP connection closed", false, true);
-}
-function extensions(response) {
-  const extension = record(record(record(response)._meta).ahp);
-  const methods = {};
-  const result = { methods, fork: [], revert: [], subagents: false, instructions: false, userInput: false, dynamicTool: false };
-  if (extension.version !== 1)
-    return result;
-  const names = record(extension.methods);
-  for (const key of ["fork", "revert", "steer", "history", "goalSet", "goalClear", "compact", "review"]) {
-    const name = names[key];
-    if (typeof name === "string" && /^_[a-zA-Z0-9/_.-]+$/.test(name))
-      methods[key] = name;
-  }
-  if (methods.fork && Array.isArray(extension.fork))
-    result.fork = extension.fork.filter((value) => value === "before" || value === "through");
-  if (methods.revert && Array.isArray(extension.revert))
-    result.revert = extension.revert.filter((value) => ["conversation", "files", "both"].includes(String(value)));
-  result.subagents = extension.subagents === true;
-  result.instructions = extension.instructions === true;
-  const requests = record(extension.clientRequests);
-  result.userInput = requests.userInput === "_ahp/user_input";
-  result.dynamicTool = requests.dynamicTool === "_ahp/dynamic_tool";
-  return result;
-}
-async function processStream(options) {
-  if (!options.command)
-    throw new HarnessSdkError2("HARNESS_UNAVAILABLE", "An ACP executable or stream factory is required");
-  const child = await spawnHarnessProcess({ command: options.command, args: options.args, cwd: options.cwd, env: options.env });
-  const iterator = child.stdout[Symbol.asyncIterator]();
-  let lineBytes = 0;
-  const incoming = new ReadableStream({
-    async pull(controller) {
-      try {
-        const value = await iterator.next();
-        if (value.done) {
-          controller.close();
-          return;
-        }
-        for (const byte of value.value) {
-          if (byte === 10)
-            lineBytes = 0;
-          else if (++lineBytes > (options.maxFrameBytes ?? 8 * 1024 * 1024))
-            throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP frame exceeds its limit");
-        }
-        controller.enqueue(value.value);
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    async cancel() {
-      await iterator.return?.();
-    }
-  });
-  let outgoingLineBytes = 0;
-  const outgoing = new WritableStream({ write: (chunk) => {
-    for (const byte of chunk) {
-      if (byte === 10)
-        outgoingLineBytes = 0;
-      else if (++outgoingLineBytes > (options.maxFrameBytes ?? 8 * 1024 * 1024))
-        throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP outgoing frame exceeds its limit");
-    }
-    return child.write(chunk);
-  }, close: () => child.closeInput() });
-  (async () => {
-    try {
-      for await (const _chunk of child.stderr) {}
-    } catch {}
-  })();
-  return { stream: acp.ndJsonStream(outgoing, incoming), dispose: () => child.dispose() };
-}
-
-class AcpAdapter {
-  options;
-  connection;
-  channel;
-  info;
-  sessions = new Map;
-  nativeSessions = new Map;
-  opening;
-  openTail = Promise.resolve();
-  deliveries = new Map;
-  closing = false;
-  extension = { methods: {}, fork: [], revert: [], subagents: false, instructions: false, userInput: false, dynamicTool: false };
-  capabilities = {};
-  constructor(options) {
-    this.options = options;
-  }
-  get nativeCapabilities() {
-    return this.info?.agentCapabilities ?? {};
-  }
-  get agent() {
-    if (!this.connection)
-      throw new HarnessSdkError2("ACP_CONNECTION_CLOSED");
-    return this.connection.agent;
-  }
-  backend(nativeId, allowOpening = false) {
-    const existing = this.nativeSessions.get(nativeId);
-    if (existing)
-      return existing;
-    if (allowOpening && this.opening && (!this.opening.nativeId || this.opening.nativeId === nativeId)) {
-      this.opening.nativeId = nativeId;
-      this.nativeSessions.set(nativeId, this.opening);
-      return this.opening;
-    }
-    throw new acp.RequestError(-32602, "Unknown ACP session");
-  }
-  async interaction(session, requestId, request, transform) {
-    const delivery = deferred();
-    this.deliveries.set(requestId, delivery);
-    return new Promise((resolve, reject) => {
-      let answered = false;
-      session.sink.requestInteraction(request, async (response) => {
-        answered = true;
-        resolve(transform(response));
-        await delivery.promise;
-      }).catch(() => {
-        if (!answered)
-          reject(new acp.RequestError(-32603, "Interaction could not be completed"));
-      });
-    });
-  }
-  async initialize(params) {
-    negotiateVersion(params.protocolVersions);
-    if (this.info)
-      return { protocolVersion: 1, runtime: this.runtime(), capabilities: structuredClone(this.capabilities) };
-    this.channel = this.options.connect ? await this.options.connect() : await processStream(this.options);
-    const rawReader = this.channel.stream.readable.getReader();
-    const rawWriter = this.channel.stream.writable.getWriter();
-    const wrapped = {
-      writable: new WritableStream({ write: async (frame) => {
-        try {
-          await rawWriter.write(frame);
-          if ("id" in frame && !("method" in frame)) {
-            this.deliveries.get(frame.id)?.resolve();
-            this.deliveries.delete(frame.id);
-          }
-        } catch (error) {
-          for (const delivery of this.deliveries.values())
-            delivery.reject(error);
-          throw error;
-        }
-      }, close: () => rawWriter.close(), abort: (reason) => rawWriter.abort(reason) }),
-      readable: new ReadableStream({ pull: async (controller) => {
-        try {
-          for (;; ) {
-            const next = await rawReader.read();
-            if (next.done) {
-              controller.close();
-              return;
-            }
-            const frame = next.value;
-            if ("method" in frame && !("id" in frame) && frame.method === "session/update") {
-              const value = record(frame.params);
-              const session = this.backend(String(value.sessionId), true);
-              await session.update(record(value.update));
-              continue;
-            }
-            if ("method" in frame && !("id" in frame) && frame.method === "_ahp/event" && Object.keys(this.extension.methods).length) {
-              const value = record(frame.params);
-              const session = this.backend(String(value.sessionId));
-              const event = value.event;
-              assertDefinition("AhpEventPayload", event);
-              if (event.type === "turn/started")
-                session.activeTurn = event.payload.turnId;
-              await session.sink.emit(event, { ...typeof value.turnId === "string" ? { turnId: value.turnId } : {} });
-              if (event.type === "turn/completed" && session.activeTurn === event.payload.turnId)
-                session.activeTurn = undefined;
-              continue;
-            }
-            if ("method" in frame && !("id" in frame) && frame.method !== "elicitation/complete") {
-              const scope = record(frame.params).sessionId;
-              const recipients = typeof scope === "string" ? [this.backend(scope)] : [...this.sessions.values()];
-              for (const session of recipients)
-                await session.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_UNKNOWN_NOTIFICATION", message: "Unknown ACP notification retained", raw: safe({ method: frame.method, params: frame.params }) } });
-              continue;
-            }
-            controller.enqueue(frame);
-            return;
-          }
-        } catch (error) {
-          controller.error(error);
-        }
-      }, cancel: (reason) => rawReader.cancel(reason) })
-    };
-    const app = acp.client({ name: "anureo-harness-sdk-acp" }).onRequest("session/request_permission", (context) => {
-      const session = this.backend(context.params.sessionId);
-      return this.interaction(session, context.requestId, {
-        kind: "approval",
-        interactionId: `acp-permission:${String(context.requestId)}`,
-        turnId: session.activeTurn,
-        itemId: context.params.toolCall.toolCallId,
-        options: context.params.options.map((option) => ({ id: option.optionId, label: option.name, semantic: option.kind === "allow_once" ? "allowOnce" : option.kind === "allow_always" ? "allowSession" : "deny" })),
-        ...context.params.toolCall.rawInput !== undefined ? { input: safe(context.params.toolCall.rawInput) } : {}
-      }, (response) => response?.kind === "approval" ? { outcome: { outcome: "selected", optionId: response.optionId } } : { outcome: { outcome: "cancelled" } });
-    }).onRequest("elicitation/create", (context) => {
-      const native = record(context.params);
-      if (typeof native.sessionId !== "string" || !["form", "url"].includes(String(native.mode)))
-        return { action: "cancel" };
-      const session = this.backend(native.sessionId);
-      const request = { kind: "elicitation", interactionId: `acp-elicitation:${String(context.requestId)}`, turnId: session.activeTurn, mode: native.mode, message: String(native.message ?? ""), ...native.mode === "form" ? { schema: safe(native.requestedSchema) } : { privatePayload: { url: String(native.url ?? ""), elicitationId: String(native.elicitationId ?? "") } } };
-      return this.interaction(session, context.requestId, request, (response) => response?.kind === "elicitation" ? { action: response.action, ...response.content ? { content: response.content } : {} } : { action: "cancel" });
-    }).onNotification("elicitation/complete", async (context) => {
-      for (const session of this.sessions.values())
-        await session.sink.emit({ type: "notice", payload: { severity: "info", code: "ACP_ELICITATION_COMPLETE", message: "External authorization completed", raw: safe(context.params) } });
-    }).onRequest("_ahp/user_input", (value) => record(value), (context) => this.extensionInteraction("userInput", context.requestId, context.params)).onRequest("_ahp/dynamic_tool", (value) => record(value), (context) => this.extensionInteraction("dynamicTool", context.requestId, context.params));
-    if (this.options.fs?.readTextFile)
-      app.onRequest("fs/read_text_file", (ctx) => {
-        this.backend(ctx.params.sessionId);
-        return this.options.fs.readTextFile(ctx.params);
-      });
-    if (this.options.fs?.writeTextFile)
-      app.onRequest("fs/write_text_file", (ctx) => {
-        this.backend(ctx.params.sessionId);
-        return this.options.fs.writeTextFile(ctx.params);
-      });
-    const terminal = this.options.terminal;
-    if (terminal) {
-      app.onRequest("terminal/create", async (ctx) => {
-        const session = this.backend(ctx.params.sessionId);
-        const result = await terminal.createTerminal(ctx.params);
-        session.terminals.add(result.terminalId);
-        return result;
-      });
-      app.onRequest("terminal/output", (ctx) => {
-        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
-        return terminal.terminalOutput(ctx.params);
-      });
-      app.onRequest("terminal/wait_for_exit", (ctx) => {
-        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
-        return terminal.waitForTerminalExit(ctx.params);
-      });
-      app.onRequest("terminal/kill", (ctx) => {
-        this.backend(ctx.params.sessionId).requireTerminal(ctx.params.terminalId);
-        return terminal.killTerminal(ctx.params);
-      });
-      app.onRequest("terminal/release", async (ctx) => {
-        const session = this.backend(ctx.params.sessionId);
-        session.requireTerminal(ctx.params.terminalId);
-        const result = await terminal.releaseTerminal(ctx.params);
-        session.terminals.delete(ctx.params.terminalId);
-        return result;
-      });
-    }
-    this.connection = app.connect(wrapped);
-    this.connection.closed.then(async () => {
-      const error = new HarnessSdkError2("ACP_CONNECTION_CLOSED", "ACP source connection closed", false, true);
-      for (const delivery of this.deliveries.values())
-        delivery.reject(error);
-      this.deliveries.clear();
-      if (!this.closing)
-        await Promise.all([...this.sessions.values()].map((session) => session.sink.fail(error).catch(() => {})));
-    });
-    this.info = await this.call("initialize", { protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: "anureo-harness-sdk", version: "0.1.0" }, clientCapabilities: {
-      fs: { readTextFile: !!this.options.fs?.readTextFile, writeTextFile: !!this.options.fs?.writeTextFile },
-      terminal: !!terminal,
-      session: { configOptions: { boolean: {} }, compaction: {} },
-      plan: {},
-      elicitation: params.clientCapabilities?.interactions?.includes("elicitation") ? { form: {}, url: {} } : undefined,
-      _meta: { ahp: { version: 1, clientRequests: ["_ahp/user_input", "_ahp/dynamic_tool"] } }
-    } });
-    if (this.info.protocolVersion !== acp.PROTOCOL_VERSION) {
-      await this.dispose();
-      throw new HarnessSdkError2("PROTOCOL_VERSION_UNSUPPORTED");
-    }
-    this.extension = extensions(this.info);
-    const native = this.nativeCapabilities;
-    this.capabilities = {
-      session: { resume: native.loadSession === true || native.sessionCapabilities?.resume != null, fork: this.extension.fork, revert: this.extension.revert, history: !!this.extension.methods.history },
-      turn: { interrupt: true, steer: !!this.extension.methods.steer, inputModalities: ["text", ...native.promptCapabilities?.image ? ["image"] : [], ...native.promptCapabilities?.embeddedContext ? ["file"] : []] },
-      interactions: ["approval", "elicitation", ...this.extension.userInput ? ["userInput"] : [], ...this.extension.dynamicTool ? ["dynamicTool"] : []],
-      goal: { actions: [...this.extension.methods.goalSet ? ["set"] : [], ...this.extension.methods.goalClear ? ["clear"] : []] },
-      compact: !!this.extension.methods.compact,
-      review: !!this.extension.methods.review,
-      subagents: { events: this.extension.subagents ? "nested" : "none" },
-      mcp: { stdio: true, http: native.mcpCapabilities?.http === true, elicitation: ["form", "url"] },
-      config: { options: [] },
-      extensions: Object.keys(this.extension.methods).length || this.extension.subagents || this.extension.userInput || this.extension.dynamicTool ? [{ name: "x-acp/ahp", version: "1" }] : []
-    };
-    return { protocolVersion: 1, runtime: this.runtime(), capabilities: structuredClone(this.capabilities) };
-  }
-  runtime() {
-    return { name: this.info?.agentInfo?.name ?? "acp", version: this.info?.agentInfo?.version ?? "unknown", adapter: "acp/0.1.0" };
-  }
-  async call(method, params) {
-    try {
-      return await waitForRequest(() => this.agent.request(method, params), {}, this.options.requestTimeoutMs ?? 30000);
-    } catch (error) {
-      throw errorFromNative(error);
-    }
-  }
-  async extensionInteraction(kind, id, params) {
-    if (!this.extension[kind])
-      throw new acp.RequestError(-32601, "Extension was not negotiated");
-    const session = this.backend(String(params.sessionId));
-    const request = { ...record(params.request), kind, interactionId: `acp-${kind}:${String(id)}`, turnId: session.activeTurn };
-    assertDefinition("InteractionRequested", request);
-    return this.interaction(session, id, request, (response) => response ?? { cancelled: true });
-  }
-  async openSession(params, sink) {
-    const old = this.openTail;
-    let release;
-    this.openTail = new Promise((resolve) => {
-      release = resolve;
-    });
-    await old;
-    const session = new AcpBackendSession(this, params, sink);
-    this.opening = session;
-    try {
-      if (params.instructions && !this.extension.instructions)
-        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "ACP peer did not negotiate instructions");
-      const common = { cwd: params.cwd, mcpServers: mcp(params.mcpServers), ...params.instructions ? { _meta: { ahp: { version: 1, instructions: params.instructions } } } : {} };
-      let response;
-      if (params.mode === "new")
-        response = record(await this.call("session/new", common));
-      else if (params.mode === "resume") {
-        if (!params.binding.nativeRef || params.binding.nativeRef.provider !== "acp")
-          throw new HarnessSdkError2("SESSION_BINDING_MISMATCH");
-        session.nativeId = params.binding.nativeRef.value;
-        this.nativeSessions.set(session.nativeId, session);
-        session.hydrating = true;
-        response = record(await this.call(this.nativeCapabilities.sessionCapabilities?.resume != null ? "session/resume" : "session/load", { ...common, sessionId: session.nativeId }));
-      } else {
-        const nativeRef = params.fork?.nativeRef ?? this.sessions.get(params.fork.sourceSessionId)?.binding.nativeRef;
-        if (!nativeRef || !this.extension.methods.fork)
-          throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
-        response = record(await this.call(this.extension.methods.fork, { ...common, sessionId: nativeRef.value, boundary: params.fork.boundary }));
-      }
-      if (typeof response.sessionId === "string") {
-        if (session.nativeId && response.sessionId !== session.nativeId)
-          throw new HarnessSdkError2("ACP_PROTOCOL_ERROR", "ACP session identity changed while opening");
-        session.nativeId = response.sessionId;
-      }
-      if (!session.nativeId)
-        throw new HarnessSdkError2("ACP_PROTOCOL_ERROR", "ACP session response lacked an identity");
-      this.nativeSessions.set(session.nativeId, session);
-      this.sessions.set(params.binding.sessionId, session);
-      session.configure(response);
-      session.hydrating = false;
-      if (session.loadedSnapshot.length)
-        this.options.onLoadSnapshot?.(session.binding, session.loadedSnapshot);
-      const patch = { ...params.config, ...params.model ? { model: params.model } : {}, ...params.permissionMode ? { permissionMode: params.permissionMode } : {} };
-      if (Object.keys(patch).length)
-        await session.setConfiguration(patch);
-      if (session.state().metadata)
-        await sink.emit({ type: "session/metadata", payload: session.state().metadata });
-      return session;
-    } catch (error) {
-      for (const [id, value] of this.nativeSessions)
-        if (value === session)
-          this.nativeSessions.delete(id);
-      this.sessions.delete(params.binding.sessionId);
-      throw error;
-    } finally {
-      this.opening = undefined;
-      release();
-    }
-  }
-  async dispose() {
-    if (this.closing)
-      return;
-    this.closing = true;
-    for (const session of this.sessions.values())
-      await session.dispose().catch(() => {});
-    this.connection?.close();
-    await this.channel?.dispose();
-    this.sessions.clear();
-    this.nativeSessions.clear();
-  }
-}
-
-class AcpBackendSession {
-  adapter;
-  params;
-  sink;
-  nativeId = "";
-  activeTurn;
-  hydrating = false;
-  loadedSnapshot = [];
-  terminals = new Set;
-  capabilities;
-  config = {};
-  configKeys = new Map;
-  configurationData = {};
-  capabilityRevision = 1;
-  sessionTitle;
-  closed = false;
-  mapper;
-  snapshotBytes = 0;
-  constructor(adapter, params, sink) {
-    this.adapter = adapter;
-    this.params = params;
-    this.sink = sink;
-    this.capabilities = structuredClone(adapter.capabilities);
-    this.mapper = new AcpUpdateMapper(sink, () => this.activeTurn, () => this.state(), (data) => this.configure(data), adapter.extension.subagents);
-  }
-  get binding() {
-    return { ...this.params.binding, nativeRef: { provider: "acp", value: this.nativeId } };
-  }
-  state() {
-    return { ...this.sessionTitle !== undefined ? { metadata: { title: this.sessionTitle } } : {}, binding: this.binding, config: this.config, capabilities: this.capabilities, capabilityRevision: this.capabilityRevision, status: this.activeTurn ? "running" : "ready", ...this.activeTurn ? { activeTurnId: this.activeTurn } : {} };
-  }
-  configure(data) {
-    if (Object.hasOwn(data, "sessionTitle")) {
-      this.sessionTitle = data.sessionTitle;
-      return;
-    }
-    this.configurationData = { ...this.configurationData, ...data };
-    if (typeof data.currentModeId === "string")
-      this.configurationData.modes = { ...record(this.configurationData.modes), currentModeId: data.currentModeId };
-    const descriptor = configuration(this.configurationData);
-    this.configKeys = descriptor.keys;
-    this.capabilities.config = { options: descriptor.options };
-    this.config = { ...this.config, ...descriptor.values };
-    if (typeof data.currentModeId === "string")
-      this.config.mode = data.currentModeId;
-    this.capabilityRevision++;
-  }
-  async update(data) {
-    if (this.hydrating && data.sessionUpdate === "session_info_update") {
-      if (typeof data.title === "string" || data.title === null)
-        this.sessionTitle = data.title;
-      return;
-    }
-    if (this.hydrating) {
-      this.snapshotBytes += JSON.stringify(data).length * 3;
-      if (this.loadedSnapshot.length >= 2048 || this.snapshotBytes > 16 * 1024 * 1024)
-        throw new HarnessSdkError2("BACKPRESSURE_EXCEEDED", "ACP load snapshot exceeds its limit");
-      this.loadedSnapshot.push(safe(data));
-      return;
-    }
-    await this.mapper.update(data);
-  }
-  requireTerminal(id) {
-    if (!this.terminals.has(id))
-      throw new acp.RequestError(-32602, "Terminal does not belong to this session");
-  }
-  async setConfiguration(patch) {
-    for (const key of Object.keys(patch))
-      if (!this.configKeys.has(key))
-        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
-    for (const [key, value] of Object.entries(patch)) {
-      const option = this.configKeys.get(key);
-      if (option.type === "mode")
-        await this.adapter.call("session/set_mode", { sessionId: this.nativeId, modeId: String(value) });
-      else {
-        const response = await this.adapter.call("session/set_config_option", { sessionId: this.nativeId, configId: String(option.id), type: option.type === "boolean" ? "boolean" : "select", value });
-        this.configure(record(response));
-      }
-      this.config[key] = value;
-    }
-    return this.state();
-  }
-  async extension(key, method, params) {
-    const nativeMethod = this.adapter.extension.methods[key];
-    if (!nativeMethod)
-      throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
-    try {
-      let result = await this.adapter.call(nativeMethod, { ...params, sessionId: this.nativeId });
-      if (key === "history" && result && typeof result === "object" && Array.isArray(record(result).items)) {
-        const page = record(result);
-        result = { ...page, items: page.items.map((entry) => {
-          const row = record(entry), item = record(row.item);
-          return item.type === "toolCall" && item.fileChanges === undefined && Array.isArray(item.output) ? { ...row, item: { ...item, fileChanges: acpFileChanges(item.output) } } : entry;
-        }) };
-      }
-      assertResult(method, result);
-      return result;
-    } catch (error) {
-      if (error instanceof HarnessSdkError2 && error.code === "CAPABILITY_UNSUPPORTED") {
-        delete this.adapter.extension.methods[key];
-        if (key === "steer")
-          this.capabilities.turn.steer = false;
-        if (key === "history")
-          this.capabilities.session.history = false;
-        if (key === "revert")
-          this.capabilities.session.revert = [];
-        if (key === "compact")
-          this.capabilities.compact = false;
-        if (key === "review")
-          this.capabilities.review = false;
-        if (key === "goalSet" || key === "goalClear")
-          this.capabilities.goal.actions = this.capabilities.goal.actions?.filter((action) => action !== (key === "goalSet" ? "set" : "clear"));
-        await this.sink.emit({ type: "session/state", payload: this.state() });
-      }
-      throw error;
-    }
-  }
-  async execute(method, params) {
-    let result;
-    switch (method) {
-      case "turn/start": {
-        const turn = params;
-        const prompt = input(turn.input);
-        this.activeTurn = turn.turnId;
-        this.mapper.reset();
-        await this.sink.emit({ type: "turn/started", payload: { turnId: turn.turnId } });
-        (async () => {
-          try {
-            const completed = await this.adapter.agent.request("session/prompt", { sessionId: this.nativeId, prompt, ...this.capabilities.extensions?.some((extension) => extension.name === "x-acp/ahp") ? { _meta: { ahp: { version: 1, turnId: turn.turnId } } } : {} });
-            await this.mapper.complete();
-            await this.sink.emit({ type: "turn/completed", payload: { turnId: turn.turnId, status: completed.stopReason === "cancelled" ? "interrupted" : "completed" } });
-          } catch (error) {
-            const failure = errorFromNative(error, "ACP_TURN_FAILED");
-            if (failure.outcomeUnknown)
-              await this.sink.fail(failure);
-            else
-              await this.sink.emit({ type: "turn/completed", payload: { turnId: turn.turnId, status: "failed", error: { code: failure.code, message: failure.message, retryable: false, outcomeUnknown: false } } });
-          } finally {
-            if (this.activeTurn === turn.turnId)
-              this.activeTurn = undefined;
-          }
-        })().catch(() => {});
-        result = { turnId: turn.turnId, accepted: true };
-        break;
-      }
-      case "turn/interrupt":
-        await this.adapter.agent.notify("session/cancel", { sessionId: this.nativeId });
-        result = { accepted: true, turnId: params.turnId };
-        break;
-      case "session/config/set":
-        result = await this.setConfiguration(params.patch);
-        break;
-      case "session/close":
-        await this.dispose();
-        result = { closed: true };
-        break;
-      case "turn/steer":
-        return this.extension("steer", method, params);
-      case "session/revert":
-        return this.extension("revert", method, params);
-      case "history/read":
-        return this.extension("history", method, params);
-      case "goal/set":
-        return this.extension("goalSet", method, params);
-      case "goal/clear":
-        return this.extension("goalClear", method, params);
-      case "compact/start":
-        return this.extension("compact", method, params);
-      case "review/start":
-        return this.extension("review", method, params);
-      case "interaction/respond":
-      case "interaction/cancel":
-        throw new HarnessSdkError2("INTERACTION_EXPIRED");
-    }
-    return result;
-  }
-  async dispose() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    if (this.activeTurn)
-      await this.adapter.agent.notify("session/cancel", { sessionId: this.nativeId }).catch(() => {});
-    for (const terminalId of this.terminals)
-      await this.adapter.options.terminal?.releaseTerminal({ sessionId: this.nativeId, terminalId }).catch(() => {});
-    this.terminals.clear();
-    if (this.adapter.nativeCapabilities.sessionCapabilities?.close != null)
-      await this.adapter.call("session/close", { sessionId: this.nativeId }).catch(() => {});
-  }
-}
-function createAcpAdapter(options) {
-  return new AcpAdapter(options);
-}
-export {
-  AcpAdapter,
-  AcpBackendSession,
-  createAcpAdapter
-};