@agentknight/sdk 0.9.35

package/dist/chunks/acp-adapter-4N2QCTAL.js

@@ -0,0 +1,936 @@
+import {
+  latestPreviewItems
+} from "./chunk-MVUOCZFL.js";
+import {
+  UnsupportedAgentOperationError
+} from "./chunk-SJHJER3B.js";
+import {
+  ConversationItemSchema,
+  PromptImageAttachmentSchema,
+  SESSION_TIMELINE_PAGE_SIZE,
+  SessionSummarySchema
+} from "./chunk-ZKAN2FO7.js";
+
+// src/acp-adapter.ts
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { Readable, Writable } from "node:stream";
+import {
+  client,
+  ndJsonStream,
+  PROTOCOL_VERSION,
+  RequestError
+} from "@agentclientprotocol/sdk";
+import { z } from "zod";
+var ACP_DEFAULT_MODEL_ID = "acp:agent-default";
+var STREAM_CHECKPOINT_MS = 1e3;
+var SelectValueSchema = z.object({
+  value: z.string().trim().min(1).max(256),
+  name: z.string().trim().min(1).max(260)
+});
+var CapabilitiesSchema = z.object({
+  loadSession: z.boolean().optional(),
+  promptCapabilities: z.object({ image: z.boolean().optional() }).optional(),
+  sessionCapabilities: z.object({
+    list: z.object({}).nullable().optional(),
+    resume: z.object({}).nullable().optional(),
+    close: z.object({}).nullable().optional(),
+    delete: z.object({}).nullable().optional()
+  }).optional()
+});
+var ConfigOptionSchema = z.intersection(
+  z.object({ id: z.string().min(1), name: z.string(), category: z.string().nullable().optional() }),
+  z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("select"),
+      currentValue: z.string(),
+      options: z.union([
+        z.array(SelectValueSchema),
+        z.array(z.object({ group: z.string(), name: z.string(), options: z.array(SelectValueSchema) }))
+      ])
+    }),
+    z.object({ type: z.literal("boolean"), currentValue: z.boolean() })
+  ])
+);
+var ConfigStateSchema = z.object({
+  configOptions: z.array(ConfigOptionSchema).nullable().optional()
+});
+var StoredSessionSchema = z.object({
+  version: z.literal(1),
+  summary: SessionSummarySchema,
+  configOptions: z.array(ConfigOptionSchema),
+  items: z.array(ConversationItemSchema),
+  pendingPromptIds: z.array(z.string().min(1)).default([])
+});
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function bounded(promise, timeout, operation) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`ACP ${operation} timed out`)), timeout);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var AcpCodingAgentAdapter = class {
+  agentId = "acp";
+  sdkVersion = "1.4.0";
+  agentModes = ["interactive"];
+  supportsReasoningEffort = false;
+  supportsSessionListUpdates = false;
+  supportsAssistantPreview = true;
+  supportsFileAttachments = false;
+  #options;
+  #directory;
+  #sessions = /* @__PURE__ */ new Map();
+  #permissions = /* @__PURE__ */ new Map();
+  #callbacks;
+  #child;
+  #connection;
+  #capabilities = {};
+  #started = false;
+  #stopping = false;
+  #startPromise;
+  #stopPromise;
+  #exit;
+  #fatalError;
+  #stderr = "";
+  constructor(options) {
+    if (!options.command.trim() || options.command.includes("\0")) {
+      throw new Error("ACP requires an installed executable");
+    }
+    for (const timeout of [
+      options.requestTimeoutMs,
+      options.promptTimeoutMs,
+      options.cancelTimeoutMs,
+      options.permissionTimeoutMs
+    ]) {
+      if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout < 1)) {
+        throw new RangeError("ACP timeouts must be positive integers");
+      }
+    }
+    this.#options = { ...options, args: [...options.args ?? []] };
+    this.#directory = join(
+      resolve(options.dataDirectory),
+      "acp",
+      hash(JSON.stringify([options.command, options.args ?? [], resolve(options.cwd ?? process.cwd())]))
+    );
+  }
+  get supportsSessionDelete() {
+    return this.#capabilities.sessionCapabilities?.delete != null;
+  }
+  async canUpgrade() {
+    return this.#started && !this.#stopping && this.#fatalError === void 0 && this.#permissions.size === 0 && [...this.#sessions.values()].every((session) => session.active === void 0 && session.queue.length === 0 && session.loading === void 0 && !session.writeInProgress && session.persistenceError === void 0 && !session.items.some((item) => item.kind === "activity-group" && item.status === "running"));
+  }
+  setSessionCallbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  start() {
+    if (this.#stopping) return Promise.reject(new Error("Create a new ACP adapter after stopping"));
+    if (this.#started) return Promise.resolve();
+    if (this.#startPromise) return this.#startPromise;
+    this.#startPromise = this.#start();
+    return this.#startPromise;
+  }
+  async #start() {
+    try {
+      await mkdir(this.#directory, { recursive: true, mode: 448 });
+      for (const file of await readdir(this.#directory)) {
+        if (!/^[a-f0-9]{64}\.json$/.test(file)) continue;
+        const stored = StoredSessionSchema.parse(JSON.parse(await readFile(join(this.#directory, file), "utf8")));
+        if (file !== `${hash(stored.summary.sessionId)}.json` || !isAbsolute(stored.summary.workingDirectory ?? "")) {
+          throw new Error("Invalid ACP session index");
+        }
+        const session = this.#newState(stored.summary, stored.configOptions);
+        session.items = stored.items;
+        this.#sessions.set(stored.summary.sessionId, session);
+        for (const id of stored.pendingPromptIds) {
+          this.#finalize(session, { id, prompt: [], cancelled: true }, false);
+          this.#notice(session, id, "warning", "Interrupted", "Agent process stopped before the prompt completed");
+        }
+        if (stored.pendingPromptIds.length) await this.#save(session);
+      }
+      if (this.#stopping) throw new Error("ACP startup was stopped");
+      const child = spawn(this.#options.command, [...this.#options.args ?? []], {
+        cwd: this.#options.cwd ?? process.cwd(),
+        env: this.#options.env ?? process.env,
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      this.#child = child;
+      this.#exit = new Promise((resolveExit) => {
+        child.once("close", () => resolveExit());
+      });
+      child.on("error", (error) => this.#fail(error));
+      child.stdin.on("error", (error) => this.#fail(error));
+      child.stdout.on("error", (error) => this.#fail(error));
+      child.stderr.on("error", (error) => this.#fail(error));
+      child.once("exit", (code, signal) => {
+        if (!this.#stopping) this.#fail(new Error(`ACP process exited (${signal ?? code})`));
+      });
+      child.stderr.setEncoding("utf8");
+      child.stderr.on("data", (chunk) => {
+        this.#stderr = (this.#stderr + chunk).slice(-8192);
+        this.#options.onDiagnostic?.(chunk.slice(-8192));
+      });
+      const connection = client({ name: "AgentKnight" }).onRequest("session/request_permission", ({ params, signal }) => this.#permission(params, signal)).onNotification("session/update", ({ params }) => this.#update(params)).connect(ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+      this.#connection = connection;
+      connection.signal.addEventListener("abort", () => {
+        if (!this.#stopping) this.#fail(new Error("ACP connection closed"));
+      }, { once: true });
+      const response = await this.#request("initialize", {
+        protocolVersion: PROTOCOL_VERSION,
+        clientInfo: { name: "agentknight", version: this.sdkVersion },
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }
+      });
+      if (!response || response.protocolVersion !== PROTOCOL_VERSION) {
+        throw new Error("ACP agent returned an unsupported protocol version");
+      }
+      this.#capabilities = CapabilitiesSchema.parse(response.agentCapabilities ?? {});
+      this.#started = true;
+    } catch (error) {
+      this.#fail(error);
+      await this.stop();
+      throw error;
+    }
+  }
+  async #request(method, params) {
+    if (!this.#connection || this.#fatalError) throw this.#fatalError ?? new Error("ACP is not connected");
+    try {
+      return await bounded(
+        this.#connection.agent.request(method, params),
+        this.#options.requestTimeoutMs ?? 3e4,
+        method
+      );
+    } catch (error) {
+      if (error instanceof RequestError && error.code === -32e3) {
+        throw new Error("ACP authentication required; authenticate the configured bridge outside AgentKnight", { cause: error });
+      }
+      if (error instanceof Error && error.message.endsWith("timed out")) this.#fail(error);
+      throw error;
+    }
+  }
+  #ready() {
+    if (!this.#started || this.#stopping || this.#fatalError) {
+      throw this.#fatalError ?? new Error("ACP adapter is not running");
+    }
+  }
+  #known(sessionId) {
+    this.#ready();
+    const session = this.#sessions.get(sessionId);
+    if (!session || session.deleted) throw new Error(`Unknown ACP session: ${sessionId}`);
+    if (session.persistenceError) throw session.persistenceError;
+    return session;
+  }
+  #newState(summary, configOptions = []) {
+    return {
+      summary,
+      configOptions,
+      items: [],
+      loaded: false,
+      replaying: false,
+      queue: [],
+      epoch: 0,
+      lock: Promise.resolve(),
+      saving: Promise.resolve(),
+      commands: [],
+      writeInProgress: false,
+      changeVersion: 0,
+      requestedVersion: 0,
+      persistedVersion: 0,
+      deleted: false
+    };
+  }
+  #save(session) {
+    session.changeVersion++;
+    this.#clearCheckpoint(session);
+    return this.#flush(session);
+  }
+  #clearCheckpoint(session) {
+    clearTimeout(session.checkpointTimer);
+    delete session.checkpointTimer;
+  }
+  #checkpoint(session) {
+    session.changeVersion++;
+    if (session.checkpointTimer || this.#stopping || session.deleted || session.persistenceError) return;
+    session.checkpointTimer = setTimeout(() => {
+      delete session.checkpointTimer;
+      void this.#flush(session);
+    }, STREAM_CHECKPOINT_MS);
+    session.checkpointTimer.unref();
+  }
+  #flush(session) {
+    if (session.persistenceError || session.deleted) return session.saving;
+    session.requestedVersion = session.changeVersion;
+    if (session.writeInProgress) return session.saving;
+    session.writeInProgress = true;
+    const destination = join(this.#directory, `${hash(session.summary.sessionId)}.json`);
+    session.saving = (async () => {
+      try {
+        while (session.persistedVersion < session.requestedVersion) {
+          const version = session.changeVersion;
+          const snapshot = JSON.stringify({
+            version: 1,
+            summary: session.summary,
+            configOptions: session.configOptions,
+            items: session.items,
+            pendingPromptIds: [...session.active ? [session.active.id] : [], ...session.queue.map((job) => job.id)]
+          });
+          const staging = `${destination}.${randomUUID()}.pending`;
+          try {
+            await writeFile(staging, snapshot, { mode: 384, flag: "wx" });
+            await rename(staging, destination);
+            session.persistedVersion = version;
+          } finally {
+            await rm(staging, { force: true });
+          }
+        }
+      } catch (error) {
+        session.persistenceError = error;
+        throw error;
+      } finally {
+        session.writeInProgress = false;
+      }
+    })();
+    void session.saving.catch((error) => {
+      this.#callbacks?.onSyncError(session.summary.sessionId, error);
+      this.#fail(error);
+    });
+    return session.saving;
+  }
+  async listModels() {
+    this.#ready();
+    const models = /* @__PURE__ */ new Map([
+      [ACP_DEFAULT_MODEL_ID, { id: ACP_DEFAULT_MODEL_ID, name: "Agent default", isDefault: true }]
+    ]);
+    for (const session of this.#sessions.values()) {
+      if (!session.loaded) continue;
+      const selector = this.#modelSelector(session);
+      if (!selector) continue;
+      for (const value of selector.options.flatMap((entry) => "group" in entry ? entry.options : [entry])) {
+        models.set(value.value, { id: value.value, name: value.name, isDefault: false });
+      }
+    }
+    return [...models.values()];
+  }
+  #modelSelector(session) {
+    return session.configOptions.find(
+      (option) => option.type === "select" && option.category === "model"
+    );
+  }
+  #configuration(session) {
+    return {
+      modelId: this.#modelSelector(session)?.currentValue ?? ACP_DEFAULT_MODEL_ID,
+      agentMode: "interactive",
+      reasoningEffort: "default"
+    };
+  }
+  #validateConfiguration(options) {
+    if (options.agentMode !== void 0 && options.agentMode !== "interactive") {
+      throw new UnsupportedAgentOperationError("acp", `agent mode ${options.agentMode}`);
+    }
+    if (options.reasoningEffort !== void 0 && options.reasoningEffort !== "default") {
+      throw new UnsupportedAgentOperationError("acp", "reasoning effort");
+    }
+  }
+  async createSession(options) {
+    this.#ready();
+    this.#validateConfiguration(options);
+    if (!isAbsolute(options.workingDirectory)) throw new Error("ACP working directory must be absolute");
+    if (options.modelId !== ACP_DEFAULT_MODEL_ID && !(await this.listModels()).some((model) => model.id === options.modelId)) {
+      throw new Error("ACP model has not been advertised by an agent session");
+    }
+    const response = await this.#request("session/new", { cwd: options.workingDirectory, mcpServers: [] });
+    const parsed = ConfigStateSchema.extend({ sessionId: z.string().min(1).max(256) }).parse(response);
+    if (this.#sessions.has(parsed.sessionId)) throw new Error("ACP agent reused an existing session ID");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = SessionSummarySchema.parse({
+      sessionId: parsed.sessionId,
+      userId: options.userId,
+      machineId: options.machineId,
+      workingDirectory: options.workingDirectory,
+      isRemote: false,
+      createdAt: now,
+      modifiedAt: now
+    });
+    const session = this.#newState(summary, parsed.configOptions ?? []);
+    session.loaded = true;
+    this.#sessions.set(summary.sessionId, session);
+    await this.#save(session);
+    if (options.modelId !== ACP_DEFAULT_MODEL_ID) {
+      await this.configureSession(summary.sessionId, { modelId: options.modelId });
+    }
+    this.#callbacks?.onSessionInventoryChanged(summary.sessionId);
+    return { ...summary };
+  }
+  async #load(session) {
+    if (session.loaded) return;
+    if (session.loading) return session.loading;
+    session.loading = (async () => {
+      const params = { sessionId: session.summary.sessionId, cwd: session.summary.workingDirectory, mcpServers: [] };
+      let response;
+      if (this.#capabilities.sessionCapabilities?.resume != null) {
+        response = await this.#request("session/resume", params);
+      } else if (this.#capabilities.loadSession === true) {
+        session.replaying = true;
+        try {
+          response = await this.#request("session/load", params);
+        } finally {
+          session.replaying = false;
+        }
+      } else {
+        throw new UnsupportedAgentOperationError("acp", "resuming persisted sessions");
+      }
+      const parsed = ConfigStateSchema.parse(response ?? {});
+      session.configOptions = parsed.configOptions ?? [];
+      session.loaded = true;
+      await this.#save(session);
+    })();
+    try {
+      await session.loading;
+    } finally {
+      delete session.loading;
+    }
+  }
+  async listSessions(userId, machineId) {
+    this.#ready();
+    if (this.#capabilities.sessionCapabilities?.list != null) {
+      let cursor;
+      const seen = /* @__PURE__ */ new Set();
+      do {
+        const response = await this.#request("session/list", cursor === void 0 ? {} : { cursor });
+        if (!Array.isArray(response?.sessions)) throw new Error("Malformed ACP session list");
+        for (const entry of response.sessions) {
+          const session = this.#sessions.get(entry.sessionId);
+          if (!session || session.summary.userId !== userId || session.summary.machineId !== machineId) continue;
+          this.#mergeSessionInfo(session, entry);
+          await this.#save(session);
+        }
+        cursor = response.nextCursor ?? void 0;
+        if (cursor !== void 0 && (seen.has(cursor) || seen.size >= 1e3)) {
+          throw new Error("ACP session list pagination did not terminate");
+        }
+        if (cursor !== void 0) seen.add(cursor);
+      } while (cursor !== void 0);
+    }
+    return [...this.#sessions.values()].filter((session) => session.summary.userId === userId && session.summary.machineId === machineId).map((session) => ({ ...session.summary })).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+  }
+  async getSessionConfiguration(sessionId) {
+    const session = this.#known(sessionId);
+    await this.#load(session);
+    return this.#configuration(session);
+  }
+  async configureSession(sessionId, options) {
+    if (options.configOption !== void 0) {
+      throw new UnsupportedAgentOperationError("acp", `configuration option ${options.configOption.id}`);
+    }
+    const session = this.#known(sessionId);
+    this.#validateConfiguration(options);
+    return this.#locked(session, async () => {
+      if (session.active || session.queue.length) throw new Error("ACP session is busy");
+      await this.#load(session);
+      if (options.modelId !== void 0 && options.modelId !== this.#configuration(session).modelId) {
+        const selector = this.#modelSelector(session);
+        if (options.modelId === ACP_DEFAULT_MODEL_ID) {
+          throw new UnsupportedAgentOperationError("acp", "resetting a session to an unadvertised default model");
+        }
+        if (!selector) throw new UnsupportedAgentOperationError("acp", "model selection");
+        const values = selector.options.flatMap((entry) => "group" in entry ? entry.options : [entry]);
+        if (!values.some((entry) => entry.value === options.modelId)) {
+          throw new Error("Model is not advertised for this ACP session");
+        }
+        const response = await this.#request("session/set_config_option", {
+          sessionId,
+          configId: selector.id,
+          value: options.modelId
+        });
+        session.configOptions = ConfigStateSchema.parse(response).configOptions ?? [];
+        if (this.#modelSelector(session)?.currentValue !== options.modelId) {
+          throw new Error("ACP agent did not confirm the requested model");
+        }
+        await this.#save(session);
+      }
+      return this.#configuration(session);
+    });
+  }
+  async getSessionEnvironment(sessionId) {
+    const session = this.#known(sessionId);
+    await this.#load(session);
+    return { tools: [], skills: [], slashCommands: [...session.commands] };
+  }
+  async getSessionRemoteStatus(sessionId) {
+    this.#known(sessionId);
+    throw new UnsupportedAgentOperationError("acp", "vendor remote sessions");
+  }
+  async setSessionRemote(sessionId, _enabled) {
+    return this.getSessionRemoteStatus(sessionId);
+  }
+  async deleteSession(sessionId) {
+    const session = this.#known(sessionId);
+    if (!this.supportsSessionDelete) throw new UnsupportedAgentOperationError("acp", "session deletion");
+    await this.abortSession(sessionId);
+    await this.#locked(session, async () => {
+      await this.#request("session/delete", { sessionId });
+      session.deleted = true;
+      this.#clearCheckpoint(session);
+      await session.saving;
+      await rm(join(this.#directory, `${hash(sessionId)}.json`));
+      this.#sessions.delete(sessionId);
+      this.#callbacks?.onSessionInventoryChanged(sessionId);
+    });
+  }
+  async watchSession(sessionId, watched) {
+    const session = this.#known(sessionId);
+    if (watched) await this.#load(session);
+  }
+  async readSessionPlan(sessionId) {
+    const session = this.#known(sessionId);
+    const plan = [...session.items].reverse().find((item) => item.kind === "plan-update");
+    if (plan) return structuredClone(plan);
+    return ConversationItemSchema.parse({
+      ...this.#base(hash(`${sessionId}:empty-plan`), sessionId),
+      timestamp: session.summary.createdAt,
+      kind: "plan-update",
+      actor: "assistant",
+      operation: "deleted",
+      content: "",
+      todos: []
+    });
+  }
+  async readSessionTimelinePage(sessionId, options = {}) {
+    const session = this.#known(sessionId);
+    const pageSize = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > SESSION_TIMELINE_PAGE_SIZE) {
+      throw new RangeError("Invalid ACP timeline page size");
+    }
+    let end = session.items.length;
+    let cursorStatus = "ok";
+    if (options.cursor !== void 0) {
+      const boundary = session.items.findIndex((item) => `${hash(sessionId)}:${item.id}` === options.cursor);
+      if (boundary < 0) cursorStatus = "expired";
+      else end = boundary;
+    }
+    const start = Math.max(0, end - pageSize);
+    return {
+      items: options.metadataOnly ? options.assistantPreview === true ? structuredClone(latestPreviewItems(session.items)) : [] : structuredClone(session.items.slice(start, end)),
+      cursor: `${hash(sessionId)}:${session.items[start]?.id ?? "empty"}`,
+      hasMore: options.metadataOnly && options.assistantPreview ? false : start > 0,
+      cursorStatus
+    };
+  }
+  #locked(session, operation) {
+    const result = session.lock.then(() => {
+      if (session.deleted) throw new Error(`Unknown ACP session: ${session.summary.sessionId}`);
+      return operation();
+    });
+    session.lock = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  async sendPrompt(sessionId, prompt, mode, attachments = [], _persistInteractions = true, fileAttachments = []) {
+    const session = this.#known(sessionId);
+    const epoch = session.epoch;
+    if (fileAttachments.length) throw new UnsupportedAgentOperationError("acp", "file attachments");
+    if (attachments.length && this.#capabilities.promptCapabilities?.image !== true) {
+      throw new UnsupportedAgentOperationError("acp", "image prompts");
+    }
+    for (const image of attachments) PromptImageAttachmentSchema.parse(image);
+    if (!prompt.trim() && !attachments.length) throw new Error("ACP prompt is empty");
+    if (prompt.length > 1e5) throw new Error("ACP prompt is too long");
+    return this.#locked(session, async () => {
+      await this.#load(session);
+      this.#ready();
+      if (session.epoch !== epoch) throw new Error("ACP prompt was cancelled before acceptance");
+      if (mode === "immediate" && (session.active || session.queue.length)) {
+        throw new Error("ACP session is busy; enqueue the prompt or abort first");
+      }
+      const id = randomUUID();
+      const job = {
+        id,
+        cancelled: false,
+        prompt: [
+          { type: "text", text: prompt },
+          ...attachments.map((image) => ({ type: "image", data: image.data, mimeType: image.mimeType }))
+        ]
+      };
+      const queued = Boolean(session.active || session.queue.length);
+      this.#upsert(session, {
+        ...this.#base(id, id),
+        kind: "human-message",
+        actor: "human",
+        content: prompt,
+        attachments: attachments.map((image) => ({ kind: "image", ...image }))
+      });
+      session.queue.push(job);
+      await this.#save(session);
+      if (session.epoch !== epoch) throw new Error("ACP prompt was cancelled before delivery");
+      this.#pump(session);
+      return { messageId: id, deliveryState: queued ? "queued" : "processing" };
+    });
+  }
+  #pump(session) {
+    if (session.active || this.#stopping || this.#fatalError) return;
+    const job = session.queue.shift();
+    if (!job) return;
+    session.active = job;
+    delete session.streamMessage;
+    job.done = Promise.resolve().then(() => this.#runPrompt(session, job));
+    this.#callbacks?.onSessionActivity?.(session.summary.sessionId, "working", (/* @__PURE__ */ new Date()).toISOString());
+    void job.done.catch((error) => this.#fail(error));
+  }
+  async #runPrompt(session, job) {
+    try {
+      if (job.cancelled || this.#stopping || this.#fatalError) {
+        throw new Error("ACP prompt cancelled before transmission");
+      }
+      const response = await bounded(this.#connection.agent.request("session/prompt", {
+        sessionId: session.summary.sessionId,
+        prompt: job.prompt
+      }), this.#options.promptTimeoutMs ?? 30 * 6e4, "prompt");
+      if (!response || typeof response.stopReason !== "string") throw new Error("Malformed ACP prompt response");
+      const reason = job.cancelled ? "cancelled" : response.stopReason;
+      this.#finalize(session, job, reason === "end_turn");
+      if (reason !== "end_turn") {
+        this.#notice(
+          session,
+          job.id,
+          reason === "cancelled" ? "warning" : "error",
+          reason === "cancelled" ? "Cancelled" : "Agent stopped",
+          reason
+        );
+        if (reason !== "cancelled") {
+          this.#callbacks?.onSyncError(session.summary.sessionId, new Error(`ACP prompt stopped: ${reason}`));
+        }
+      }
+    } catch (error) {
+      this.#finalize(session, job, false);
+      this.#notice(
+        session,
+        job.id,
+        job.cancelled ? "warning" : "error",
+        job.cancelled ? "Cancelled" : "Prompt failed",
+        errorMessage(error)
+      );
+      this.#callbacks?.onSyncError(session.summary.sessionId, error);
+      if (error instanceof Error && error.message.endsWith("timed out")) this.#fail(error);
+    } finally {
+      this.#cancelPermissions(session.summary.sessionId);
+      delete session.active;
+      delete session.streamMessage;
+      await this.#save(session);
+      this.#callbacks?.onSessionActivity?.(session.summary.sessionId, "idle", (/* @__PURE__ */ new Date()).toISOString());
+      this.#callbacks?.onSessionInventoryChanged(session.summary.sessionId);
+      this.#pump(session);
+    }
+  }
+  #base(id, turnId) {
+    return { id, turnId, revision: 1, timestamp: (/* @__PURE__ */ new Date()).toISOString(), sourceEventIds: [id] };
+  }
+  #upsert(session, item) {
+    const index = session.items.findIndex((old) => old.id === item.id);
+    const previous = session.items[index];
+    const next = ConversationItemSchema.parse({
+      ...item,
+      revision: (previous?.revision ?? 0) + 1,
+      timestamp: previous?.timestamp ?? item.timestamp
+    });
+    if (index < 0) session.items.push(next);
+    else session.items[index] = next;
+    session.summary.modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.#callbacks?.onConversationItem(session.summary.sessionId, structuredClone(next));
+  }
+  #notice(session, turnId, severity, title, content) {
+    this.#upsert(session, {
+      ...this.#base(randomUUID(), turnId),
+      kind: "notice",
+      actor: "system",
+      severity,
+      title,
+      content: content.slice(0, 4096)
+    });
+  }
+  #finalize(session, job, success) {
+    for (const item of [...session.items]) {
+      if (item.turnId !== job.id) continue;
+      if (item.kind === "assistant-message" && !item.final) this.#upsert(session, { ...item, final: true });
+      if (item.kind === "activity-group" && item.status === "running") {
+        this.#upsert(session, {
+          ...item,
+          status: "failed",
+          steps: item.steps.map((step) => step.status === "running" ? { ...step, status: "failed" } : step)
+        });
+        if (success) this.#callbacks?.onSyncError(session.summary.sessionId, new Error("ACP tool did not report completion"));
+      }
+    }
+  }
+  async #update(notification) {
+    const session = this.#sessions.get(notification.sessionId);
+    if (!session || session.deleted) {
+      this.#options.onDiagnostic?.("Ignored update for unknown ACP session");
+      return;
+    }
+    try {
+      const update = notification.update;
+      if (update.sessionUpdate === "config_option_update") {
+        session.configOptions = ConfigStateSchema.parse(update).configOptions ?? [];
+      } else if (update.sessionUpdate === "available_commands_update") {
+        session.commands = update.availableCommands.slice(0, 512).map((command) => ({
+          name: command.name.slice(0, 260),
+          kind: "client",
+          ...command.description ? { description: command.description.slice(0, 4096) } : {}
+        }));
+      } else if (update.sessionUpdate === "session_info_update") {
+        if (this.#mergeSessionInfo(session, update)) {
+          this.#callbacks?.onSessionInventoryChanged(notification.sessionId);
+        }
+      } else if (!session.replaying) {
+        this.#project(session, update);
+      }
+      if (!session.replaying) this.#checkpoint(session);
+    } catch (error) {
+      this.#callbacks?.onSyncError(notification.sessionId, error);
+      this.#fail(error);
+    }
+  }
+  #mergeSessionInfo(session, update) {
+    const beforeTitle = session.summary.summary;
+    const beforeTime = session.summary.modifiedAt;
+    if (update.title === null) delete session.summary.summary;
+    else if (update.title !== void 0) session.summary.summary = update.title.slice(0, 4096);
+    if (update.updatedAt === null) session.summary.modifiedAt = session.summary.createdAt;
+    else if (update.updatedAt !== void 0 && Number.isFinite(Date.parse(update.updatedAt))) {
+      session.summary.modifiedAt = new Date(update.updatedAt).toISOString();
+    }
+    return beforeTitle !== session.summary.summary || beforeTime !== session.summary.modifiedAt;
+  }
+  #project(session, update) {
+    const turnId = session.active?.id;
+    if (!turnId) return;
+    if (update.sessionUpdate === "agent_message_chunk") {
+      if (update.content.type !== "text") {
+        this.#notice(session, turnId, "warning", "Unsupported agent content", update.content.type);
+        return;
+      }
+      const key = update.messageId ?? "stream";
+      if (session.streamMessage?.key !== key) {
+        session.streamMessage = { key, id: hash(`${turnId}:message:${update.messageId ?? randomUUID()}`) };
+      }
+      const id = session.streamMessage.id;
+      const previous = session.items.find((item) => item.id === id);
+      const content = (previous?.kind === "assistant-message" ? previous.content : "") + update.content.text;
+      this.#upsert(session, {
+        ...this.#base(id, turnId),
+        kind: "assistant-message",
+        actor: "assistant",
+        content,
+        final: false
+      });
+    } else if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+      if (session.streamMessage?.key === "stream") delete session.streamMessage;
+      const id = hash(`${session.summary.sessionId}:tool:${update.toolCallId}`);
+      const previous = session.items.find((item) => item.id === id);
+      const step = previous?.kind === "activity-group" ? previous.steps[0] : void 0;
+      const status = update.status === "completed" ? "completed" : update.status === "failed" ? "failed" : update.status == null && step ? step.status : "running";
+      const base = this.#base(id, previous?.turnId ?? turnId);
+      this.#upsert(session, {
+        ...base,
+        kind: "activity-group",
+        actor: "assistant",
+        status,
+        steps: [{
+          id,
+          kind: "tool",
+          name: (update.title ?? step?.name ?? "Tool").slice(0, 256) || "Tool",
+          status,
+          timestamp: step?.timestamp ?? previous?.timestamp ?? base.timestamp
+        }]
+      });
+    } else if (update.sessionUpdate === "plan") {
+      const id = hash(`${session.summary.sessionId}:plan`);
+      const previous = session.items.find((item) => item.id === id);
+      this.#upsert(session, {
+        ...this.#base(id, turnId),
+        kind: "plan-update",
+        actor: "assistant",
+        operation: previous ? "updated" : "created",
+        content: "",
+        todos: update.entries.map((entry, index) => ({
+          id: hash(`${id}:${index}`),
+          title: entry.content.slice(0, 1024),
+          status: entry.status,
+          dependsOn: []
+        }))
+      });
+    }
+  }
+  #permission(request, signal) {
+    const session = this.#sessions.get(request.sessionId);
+    if (!session?.active || session.active.cancelled || this.#stopping || signal.aborted) {
+      return Promise.resolve({ outcome: { outcome: "cancelled" } });
+    }
+    const id = randomUUID();
+    return new Promise((resolvePermission) => {
+      const cancel = () => finish({ outcome: { outcome: "cancelled" } });
+      const timer = setTimeout(() => {
+        this.#callbacks?.onSyncError(request.sessionId, new Error("ACP permission request timed out"));
+        cancel();
+      }, this.#options.permissionTimeoutMs ?? 5 * 6e4);
+      const finish = (response) => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", cancel);
+        this.#permissions.delete(id);
+        resolvePermission(response);
+      };
+      this.#permissions.set(id, { sessionId: request.sessionId, request, finish });
+      signal.addEventListener("abort", cancel, { once: true });
+      if (!this.#callbacks) cancel();
+      else this.#callbacks.onPermissionRequest(request.sessionId, id, this.#permissionPayload(request));
+    });
+  }
+  #permissionPayload(request) {
+    return {
+      kind: request.toolCall.kind ?? "other",
+      title: request.toolCall.title ?? "Tool",
+      toolCall: request.toolCall,
+      options: request.options
+    };
+  }
+  respondPermission(permissionRequestId, decision, _feedback) {
+    const pending = this.#permissions.get(permissionRequestId);
+    if (!pending) return false;
+    const kind = decision === "approve-once" ? "allow_once" : "reject_once";
+    const option = pending.request.options.find((entry) => entry.kind === kind);
+    pending.finish({ outcome: option ? { outcome: "selected", optionId: option.optionId } : { outcome: "cancelled" } });
+    return true;
+  }
+  async respondInteraction(_interactionRequestId, _response) {
+    throw new UnsupportedAgentOperationError("acp", "elicitations");
+  }
+  replayPendingInteractions() {
+    for (const [id, pending] of this.#permissions) {
+      this.#callbacks?.onPermissionRequest(pending.sessionId, id, this.#permissionPayload(pending.request));
+    }
+  }
+  #cancelPermissions(sessionId) {
+    for (const pending of [...this.#permissions.values()]) {
+      if (sessionId === void 0 || pending.sessionId === sessionId) {
+        pending.finish({ outcome: { outcome: "cancelled" } });
+      }
+    }
+  }
+  async abortSession(sessionId) {
+    const session = this.#known(sessionId);
+    session.epoch++;
+    for (const job of session.queue.splice(0)) {
+      this.#notice(session, job.id, "warning", "Cancelled", "Queued prompt cancelled");
+    }
+    const active = session.active;
+    if (active) active.cancelled = true;
+    this.#cancelPermissions(sessionId);
+    if (active) {
+      try {
+        await bounded((async () => {
+          await this.#connection.agent.notify("session/cancel", { sessionId });
+          await active.done;
+        })(), this.#options.cancelTimeoutMs ?? 5e3, "cancellation");
+      } catch (error) {
+        this.#fail(error);
+        await this.stop();
+        throw error;
+      }
+    }
+    await this.#save(session);
+  }
+  #fail(error) {
+    if (this.#fatalError || this.#stopping) return;
+    this.#fatalError = error instanceof Error ? error : new Error(String(error));
+    this.#options.onDiagnostic?.(`ACP failure: ${this.#fatalError.message}${this.#stderr ? `
+${this.#stderr}` : ""}`);
+    for (const session of this.#sessions.values()) {
+      this.#clearCheckpoint(session);
+      session.epoch++;
+      for (const job of session.queue.splice(0)) {
+        this.#notice(session, job.id, "error", "Prompt failed", this.#fatalError.message);
+      }
+      this.#callbacks?.onSyncError(session.summary.sessionId, this.#fatalError);
+    }
+    this.#cancelPermissions();
+    this.#connection?.close(this.#fatalError);
+    this.#child?.kill("SIGTERM");
+    void this.stop().catch((stopError) => {
+      this.#options.onDiagnostic?.(`ACP cleanup failed: ${errorMessage(stopError)}`);
+    });
+  }
+  stop() {
+    if (!this.#stopPromise) this.#stopPromise = this.#stop();
+    return this.#stopPromise;
+  }
+  async #stop() {
+    this.#stopping = true;
+    this.#started = false;
+    this.#cancelPermissions();
+    const active = [];
+    for (const session of this.#sessions.values()) {
+      this.#clearCheckpoint(session);
+      session.epoch++;
+      for (const job of session.queue.splice(0)) {
+        this.#notice(session, job.id, "warning", "Cancelled", "Agent stopped");
+      }
+      if (session.active) {
+        if (!this.#fatalError) session.active.cancelled = true;
+        if (session.active.done) active.push(session.active.done);
+      }
+    }
+    if (this.#connection && !this.#fatalError) {
+      try {
+        await bounded((async () => {
+          await Promise.all([...this.#sessions.values()].filter((session) => session.active).map((session) => this.#connection.agent.notify("session/cancel", {
+            sessionId: session.summary.sessionId
+          })));
+          await Promise.all(active);
+          if (this.#capabilities.sessionCapabilities?.close != null) {
+            await Promise.all([...this.#sessions.values()].filter((session) => session.loaded).map((session) => this.#connection.agent.request("session/close", {
+              sessionId: session.summary.sessionId
+            })));
+          }
+        })(), this.#options.cancelTimeoutMs ?? 5e3, "graceful shutdown");
+      } catch (error) {
+        this.#options.onDiagnostic?.(errorMessage(error));
+      }
+    }
+    this.#connection?.close(new Error("ACP adapter stopped"));
+    const child = this.#child;
+    if (child && child.exitCode === null && child.signalCode === null) {
+      child.kill("SIGTERM");
+      try {
+        await bounded(this.#exit, this.#options.cancelTimeoutMs ?? 5e3, "process exit");
+      } catch (error) {
+        this.#options.onDiagnostic?.(errorMessage(error));
+        child.kill("SIGKILL");
+        await bounded(this.#exit, this.#options.cancelTimeoutMs ?? 5e3, "process termination");
+      }
+    }
+    child?.stdin.destroy();
+    child?.stdout.destroy();
+    child?.stderr.destroy();
+    const completed = await Promise.allSettled(active);
+    const saved = await Promise.allSettled([...this.#sessions.values()].filter((session) => !session.deleted).map((session) => this.#save(session)));
+    const failures = [...completed, ...saved].filter((result) => result.status === "rejected");
+    if (failures.length) throw failures[0].reason;
+  }
+};
+export {
+  ACP_DEFAULT_MODEL_ID,
+  AcpCodingAgentAdapter
+};