@agentknight/sdk 0.9.42 → 0.9.44

package/dist/chunks/claude-adapter-A5EFNV5S.js

@@ -0,0 +1,1040 @@
+import {
+  hasClaudeProviderConfiguration
+} from "./chunk-EIFNERXM.js";
+import {
+  latestPreviewItems
+} from "./chunk-AK3YVBEP.js";
+import {
+  UnsupportedAgentOperationError,
+  validateSessionName
+} from "./chunk-UNRPSTRM.js";
+import {
+  ConversationItemSchema,
+  InteractionRequestSchema,
+  InteractionResponseSchema,
+  SESSION_TIMELINE_PAGE_SIZE,
+  SessionSummarySchema
+} from "./chunk-W6TZVD7W.js";
+
+// src/claude-adapter.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { z as z4 } from "zod";
+
+// src/adapters/claude/input.ts
+var ClaudeInput = class {
+  #value;
+  #wake;
+  #closed = false;
+  push(value) {
+    if (this.#closed || this.#value !== void 0) throw new Error("Claude input is unavailable");
+    this.#value = value;
+    this.#wake?.();
+  }
+  close() {
+    this.#closed = true;
+    this.#value = void 0;
+    this.#wake?.();
+  }
+  async *[Symbol.asyncIterator]() {
+    while (!this.#closed) {
+      if (this.#value === void 0) await new Promise((resolve2) => {
+        this.#wake = resolve2;
+      });
+      this.#wake = void 0;
+      if (this.#closed) return;
+      const value = this.#value;
+      this.#value = void 0;
+      if (value !== void 0) yield value;
+    }
+  }
+};
+
+// src/adapters/claude/interactions.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var QuestionsSchema = z.object({
+  questions: z.array(z.object({
+    question: z.string().trim().min(1).max(1024),
+    header: z.string().optional(),
+    options: z.array(z.object({ label: z.string().max(1024), description: z.string().optional() })).max(100),
+    multiSelect: z.boolean().optional()
+  })).min(1).max(100)
+});
+var ClaudeInteractions = class {
+  constructor(callbacks, timeoutMs) {
+    this.callbacks = callbacks;
+    this.timeoutMs = timeoutMs;
+  }
+  callbacks;
+  timeoutMs;
+  #pending = /* @__PURE__ */ new Map();
+  get size() {
+    return this.#pending.size;
+  }
+  request(sessionId, tool, input, signal) {
+    if (signal.aborted) return Promise.resolve({ behavior: "deny", message: "Request cancelled" });
+    const questions = tool === "AskUserQuestion" ? QuestionsSchema.safeParse(input) : void 0;
+    if (questions && !questions.success) {
+      return Promise.resolve({ behavior: "deny", message: "Unsupported AskUserQuestion input" });
+    }
+    const questionList = questions?.success ? questions.data.questions : void 0;
+    const single = questionList?.length === 1 ? questionList[0] : void 0;
+    const request = InteractionRequestSchema.parse(single && !single.multiSelect ? {
+      kind: "user_input",
+      question: single.question,
+      choices: single.options.map((option) => option.label),
+      allowFreeform: true
+    } : questionList ? {
+      kind: "elicitation",
+      mode: "form",
+      message: "Claude needs your input",
+      source: "Claude",
+      fields: questionList.map((question, index) => ({
+        id: `q${index}`,
+        label: question.question,
+        inputType: question.multiSelect ? "multi-select" : "select",
+        required: true,
+        options: question.options.map((option) => option.label)
+      }))
+    } : {
+      kind: "permission",
+      permissionKind: tool,
+      title: `Allow ${tool}?`.slice(0, 256),
+      description: JSON.stringify(input).slice(0, 4096),
+      canApproveSession: false,
+      canApproveAlways: false
+    });
+    const id = randomUUID();
+    return new Promise((resolve2) => {
+      let settled = false;
+      const cancel = () => {
+        finish();
+      };
+      const timer = setTimeout(cancel, this.timeoutMs);
+      const finish = (response) => {
+        if (settled) return false;
+        let result = { behavior: "deny", message: "Request cancelled or denied" };
+        if (response !== void 0) {
+          if (response.kind !== request.kind) return false;
+          if (response.kind === "permission") {
+            if (response.decision !== "approve-once" && response.decision !== "reject") return false;
+            result = response.decision === "approve-once" ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: response.feedback ?? "User denied permission" };
+          } else if (response.kind === "user_input" && single) {
+            result = { behavior: "allow", updatedInput: { ...input, answers: { [single.question]: response.answer } } };
+          } else if (response.kind === "elicitation" && questionList) {
+            if (response.action === "accept") {
+              const answers = {};
+              for (const [index, question] of questionList.entries()) {
+                const answer = response.values[`q${index}`];
+                if (question.multiSelect) {
+                  if (!Array.isArray(answer) || !answer.length || answer.some((value) => !question.options.some((option) => option.label === value))) return false;
+                  answers[question.question] = answer.join(", ");
+                } else {
+                  if (typeof answer !== "string" || !answer.trim()) return false;
+                  answers[question.question] = answer;
+                }
+              }
+              result = { behavior: "allow", updatedInput: { ...input, answers } };
+            }
+          } else return false;
+        }
+        settled = true;
+        clearTimeout(timer);
+        signal.removeEventListener("abort", cancel);
+        this.#pending.delete(id);
+        this.callbacks()?.onInteractionDismissed?.(sessionId, id);
+        resolve2(result);
+        return true;
+      };
+      this.#pending.set(id, { sessionId, request, finish });
+      signal.addEventListener("abort", cancel, { once: true });
+      if (signal.aborted) cancel();
+      else this.#emit(id, this.#pending.get(id));
+    });
+  }
+  respond(id, response) {
+    const parsed = InteractionResponseSchema.safeParse(response);
+    return parsed.success ? this.#pending.get(id)?.finish(parsed.data) ?? false : false;
+  }
+  cancel(sessionId) {
+    for (const pending of [...this.#pending.values()]) if (pending.sessionId === sessionId) pending.finish();
+  }
+  replay() {
+    for (const [id, pending] of this.#pending) this.#emit(id, pending);
+  }
+  #emit(id, pending) {
+    if (!pending) return;
+    const callbacks = this.callbacks();
+    if (callbacks?.onInteractionRequest) callbacks.onInteractionRequest(pending.sessionId, id, pending.request);
+    else if (pending.request.kind === "permission" && callbacks) {
+      callbacks.onPermissionRequest(pending.sessionId, id, { kind: pending.request.permissionKind });
+    } else pending.finish();
+  }
+};
+
+// src/adapters/claude/timeline.ts
+import { createHash } from "node:crypto";
+import { z as z2 } from "zod";
+var identity = (value) => createHash("sha256").update(value).digest("hex");
+var ObjectSchema = z2.record(z2.string(), z2.unknown());
+var EnvelopeSchema = z2.object({
+  type: z2.string(),
+  uuid: z2.string().optional(),
+  parent_tool_use_id: z2.string().nullable().optional()
+}).passthrough();
+var BlockSchema = z2.object({
+  type: z2.string(),
+  text: z2.string().optional(),
+  id: z2.string().optional(),
+  name: z2.string().optional(),
+  tool_use_id: z2.string().optional(),
+  is_error: z2.boolean().optional()
+}).passthrough();
+var ClaudeTimeline = class {
+  constructor(sessionId, items, publish) {
+    this.sessionId = sessionId;
+    this.items = items;
+    this.publish = publish;
+  }
+  sessionId;
+  items;
+  publish;
+  #streams = /* @__PURE__ */ new Map();
+  #seen = /* @__PURE__ */ new Set();
+  upsert(value) {
+    const index = this.items.findIndex((item2) => item2.id === value.id);
+    const previous = this.items[index];
+    const item = ConversationItemSchema.parse({
+      ...value,
+      timestamp: previous?.timestamp ?? value.timestamp,
+      revision: previous?.revision ?? 1
+    });
+    if (previous && JSON.stringify(previous) === JSON.stringify(item)) return;
+    if (previous) item.revision++;
+    if (index < 0) this.items.push(item);
+    else this.items[index] = item;
+    this.publish(structuredClone(item));
+  }
+  base(id, turnId) {
+    return { id, turnId, revision: 1, timestamp: (/* @__PURE__ */ new Date()).toISOString(), sourceEventIds: [id] };
+  }
+  notice(turnId, content, severity = "error") {
+    const id = identity(`${turnId}:notice:${content}`);
+    this.upsert({
+      ...this.base(id, turnId),
+      kind: "notice",
+      actor: "system",
+      severity,
+      title: severity === "error" ? "Claude stopped" : "Claude interrupted",
+      content: content.slice(0, 4096)
+    });
+  }
+  finish() {
+    for (const item of [...this.items]) {
+      if (item.kind === "assistant-message" && !item.final) this.upsert({ ...item, final: true });
+      if (item.kind === "activity-group" && item.status === "running") {
+        this.upsert({
+          ...item,
+          status: "failed",
+          steps: item.steps.map((step) => step.status === "running" ? { ...step, status: "failed" } : step)
+        });
+      }
+    }
+    this.#streams.clear();
+  }
+  project(raw, turnId) {
+    const message = EnvelopeSchema.parse(raw);
+    if (message.uuid && this.#seen.has(message.uuid)) return;
+    if (message.uuid) this.#seen.add(message.uuid);
+    const source = message.uuid ?? turnId;
+    if (message.type === "assistant") {
+      const body = z2.object({ id: z2.string(), content: z2.array(BlockSchema) }).parse(message.message);
+      body.content.forEach((block, index) => {
+        if (block.type === "text" && block.text !== void 0) {
+          this.#text(body.id, index, block.text, true, turnId);
+        } else if (block.type === "tool_use" && block.id) {
+          this.#tool(block.id, block.name, "running", turnId);
+        }
+      });
+    } else if (message.type === "user") {
+      const detached = z2.object({ detachedToolCall: z2.literal(true) }).safeParse(message.tool_use_result);
+      if (detached.success) return;
+      const body = z2.object({ content: z2.unknown() }).parse(message.message);
+      if (!Array.isArray(body.content)) return;
+      for (const rawBlock of body.content) {
+        const block = BlockSchema.parse(rawBlock);
+        if (block.type === "tool_result" && block.tool_use_id) {
+          this.#tool(block.tool_use_id, void 0, block.is_error ? "failed" : "completed", turnId);
+        }
+      }
+    } else if (message.type === "tool_progress") {
+      const progress = z2.object({ tool_use_id: z2.string(), tool_name: z2.string() }).parse(message);
+      this.#tool(progress.tool_use_id, progress.tool_name, "running", turnId);
+    } else if (message.type === "stream_event") {
+      const event = z2.object({ type: z2.string() }).passthrough().parse(message.event);
+      const key = message.parent_tool_use_id ?? "main";
+      if (event.type === "message_start") {
+        const body = z2.object({ id: z2.string() }).parse(event.message);
+        this.#streams.set(key, { id: body.id, blocks: /* @__PURE__ */ new Map() });
+      }
+      const stream = this.#streams.get(key);
+      if (!stream) return;
+      if (event.type === "content_block_start") {
+        const index = z2.number().int().nonnegative().parse(event.index);
+        const block = BlockSchema.parse(event.content_block);
+        if (block.type === "text") {
+          stream.blocks.set(index, block.text ?? "");
+          this.#text(stream.id, index, block.text ?? "", false, turnId);
+        } else if (block.type === "tool_use" && block.id) {
+          this.#tool(block.id, block.name, "running", turnId);
+        }
+      } else if (event.type === "content_block_delta") {
+        const delta = ObjectSchema.parse(event.delta);
+        const index = z2.number().int().nonnegative().parse(event.index);
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+          const text = (stream.blocks.get(index) ?? "") + delta.text;
+          stream.blocks.set(index, text);
+          this.#text(stream.id, index, text, false, turnId);
+        }
+      } else if (event.type === "content_block_stop") {
+        const index = z2.number().int().nonnegative().parse(event.index);
+        const text = stream.blocks.get(index);
+        if (text !== void 0) this.#text(stream.id, index, text, true, turnId);
+      }
+    } else if (message.type === "system" && message.subtype === "status" && message.status === "compacting") {
+      const id = identity(`${this.sessionId}:status:${source}`);
+      this.upsert({
+        ...this.base(id, turnId),
+        kind: "notice",
+        actor: "system",
+        severity: "info",
+        title: "Compacting conversation",
+        content: ""
+      });
+    }
+  }
+  #text(messageId, index, content, final, turnId) {
+    const id = identity(`${this.sessionId}:message:${messageId}:${index}`);
+    const old = this.items.find((item) => item.id === id);
+    if (!final && old?.kind === "assistant-message" && old.final) return;
+    this.upsert({
+      ...this.base(id, old?.turnId ?? turnId),
+      sourceMessageIds: [messageId],
+      kind: "assistant-message",
+      actor: "assistant",
+      content,
+      final
+    });
+  }
+  #tool(toolId, name, status, turnId) {
+    const id = identity(`${this.sessionId}:tool:${toolId}`);
+    const previous = this.items.find((item) => item.id === id);
+    if (previous?.kind === "activity-group" && previous.status !== "running" && status === "running") return;
+    const base = this.base(id, previous?.turnId ?? turnId);
+    const oldStep = previous?.kind === "activity-group" ? previous.steps[0] : void 0;
+    this.upsert({
+      ...base,
+      kind: "activity-group",
+      actor: "assistant",
+      status,
+      sourceMessageIds: [toolId],
+      steps: [{ id, kind: "tool", name: (name ?? oldStep?.name ?? "Tool").slice(0, 256), status }]
+    });
+  }
+};
+
+// src/adapters/claude/auth.ts
+import { z as z3 } from "zod";
+var EnvironmentSchema = z3.record(z3.string(), z3.string().optional());
+function prepareClaudeEnvironment(value, configDirectory) {
+  const env = EnvironmentSchema.parse(value);
+  if (!hasClaudeProviderConfiguration(env)) {
+    throw new Error("Claude requires ANTHROPIC_API_KEY or a configured Bedrock/Vertex/Foundry provider (flag 1); CLI OAuth is not reused");
+  }
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("CLAUDE") && (/OAUTH|TOKEN|CREDS|CREDENTIAL|HOST_AUTH|FILE_DESCRIPTOR/.test(key) || key === "CLAUDE_SECURESTORAGE_CONFIG_DIR" || key === "CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST")) {
+      delete env[key];
+    }
+  }
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  env.CLAUDE_CONFIG_DIR = configDirectory;
+  return env;
+}
+
+// src/adapters/claude/process.ts
+import { spawn } from "node:child_process";
+var ClaudeProcessTerminationError = class extends Error {
+};
+var ClaudeProcess = class {
+  #child;
+  #exit;
+  #error;
+  spawn = (options) => {
+    if (this.#child) throw new Error("Claude query attempted to spawn more than one process");
+    const child = spawn(options.command, options.args, {
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+      env: options.env,
+      signal: options.signal,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      shell: false
+    });
+    this.#child = child;
+    this.#exit = new Promise((resolve2) => {
+      const onExit = () => {
+        resolve2();
+      };
+      const onError = (error) => {
+        this.#error = error;
+        if (child.pid === void 0) resolve2();
+      };
+      const onStderrError = (error) => {
+        this.#error = error;
+      };
+      child.once("exit", onExit);
+      child.on("error", onError);
+      child.stderr.on("error", onStderrError);
+      child.once("close", () => {
+        child.off("exit", onExit);
+        child.off("error", onError);
+        child.stderr.off("error", onStderrError);
+      });
+    });
+    child.stderr.resume();
+    return child;
+  };
+  async finish(timeoutMs) {
+    const child = this.#child;
+    const exit = this.#exit;
+    if (!child || !exit) return;
+    try {
+      if (await this.#wait(exit, timeoutMs)) return;
+      try {
+        child.kill("SIGKILL");
+      } catch (error) {
+        this.#error = error instanceof Error ? error : new Error(String(error));
+      }
+      if (await this.#wait(exit, timeoutMs)) return;
+      throw new ClaudeProcessTerminationError(
+        "Claude process termination timed out; native session reuse is blocked",
+        { cause: this.#error }
+      );
+    } finally {
+      child.stdin.destroy();
+      child.stdout.destroy();
+      child.stderr.destroy();
+    }
+  }
+  async #wait(exit, timeoutMs) {
+    let timer;
+    try {
+      return await Promise.race([
+        exit.then(() => true),
+        new Promise((resolve2) => {
+          timer = setTimeout(() => resolve2(false), timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/claude-adapter.ts
+var CLAUDE_DEFAULT_MODEL_ID = "claude:agent-default";
+var UuidSchema = z4.custom((value) => z4.uuid().safeParse(value).success);
+var ReceiptSchema = z4.object({
+  id: UuidSchema,
+  prompt: z4.string().min(1).max(1e5),
+  mode: z4.enum(["enqueue", "immediate"]),
+  submittedAt: z4.iso.datetime(),
+  operationId: z4.string().min(1).max(256).optional(),
+  state: z4.enum(["queued", "submitted", "confirmed", "completed", "cancelled", "failed"])
+});
+var StoredSchema = z4.object({
+  version: z4.literal(1),
+  summary: SessionSummarySchema,
+  nativeId: UuidSchema.optional(),
+  modelId: z4.string().min(1).max(256),
+  items: z4.array(ConversationItemSchema),
+  receipts: z4.array(ReceiptSchema),
+  unsafe: z4.boolean()
+});
+var MessageSchema = z4.object({
+  type: z4.string(),
+  subtype: z4.string().optional(),
+  uuid: z4.string().optional(),
+  session_id: z4.string().optional(),
+  state: z4.string().optional(),
+  user_message_uuid: z4.string().optional(),
+  user_message_uuids: z4.array(z4.string()).optional(),
+  parent_tool_use_id: z4.string().nullable().optional(),
+  is_error: z4.boolean().optional()
+}).passthrough();
+var ClaudeCodingAgentAdapter = class {
+  agentId = "claude";
+  sdkVersion = "0.3.289";
+  agentModes = ["interactive"];
+  supportsReasoningEffort = false;
+  supportsSessionListUpdates = true;
+  supportsAssistantPreview = true;
+  supportsSessionDelete = false;
+  supportsFileAttachments = false;
+  groupChatEnabled = false;
+  #options;
+  #directory;
+  #sessions = /* @__PURE__ */ new Map();
+  #interactions;
+  #callbacks;
+  #started = false;
+  #stopping = false;
+  #starting;
+  #stopPromise;
+  constructor(options) {
+    if (!options.dataDirectory.trim()) throw new Error("Claude requires a dataDirectory");
+    if (options.command !== void 0 && (!options.command.trim() || options.command.includes("\0"))) {
+      throw new Error("Invalid Claude executable");
+    }
+    const timeout = options.interactionTimeoutMs ?? 5 * 6e4;
+    if (!Number.isSafeInteger(timeout) || timeout < 1) throw new Error("Invalid Claude interaction timeout");
+    const exitTimeout = options.processExitTimeoutMs ?? 5e3;
+    if (!Number.isSafeInteger(exitTimeout) || exitTimeout < 1) throw new Error("Invalid Claude process exit timeout");
+    this.#options = options;
+    this.#directory = join(resolve(options.dataDirectory), "claude");
+    this.#interactions = new ClaudeInteractions(() => this.#callbacks, timeout);
+  }
+  setSessionCallbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  start() {
+    if (this.#stopping) return Promise.reject(new Error("Create a new Claude adapter after stopping"));
+    if (this.#started) return Promise.resolve();
+    return this.#starting ??= this.#start();
+  }
+  async #start() {
+    await mkdir(this.#directory, { recursive: true, mode: 448 });
+    await mkdir(join(this.#directory, "native"), { recursive: true, mode: 448 });
+    for (const file of await readdir(this.#directory)) {
+      if (!/^[a-f0-9]{64}\.json$/.test(file)) continue;
+      const raw = JSON.parse(await readFile(join(this.#directory, file), "utf8"));
+      const stored = StoredSchema.parse(raw);
+      if (!stored.summary.sessionId.startsWith("claude:") || `${identity(stored.summary.sessionId)}.json` !== file) {
+        throw new Error("Invalid Claude session ownership record");
+      }
+      const session = this.#newSession(stored);
+      this.#sessions.set(stored.summary.sessionId, session);
+      for (const receipt of stored.receipts) {
+        if (["queued", "submitted", "confirmed"].includes(receipt.state)) {
+          receipt.state = "failed";
+          session.timeline.notice(receipt.id, "Previous host stopped before this prompt settled; it was not retried.");
+          if (!stored.nativeId) stored.unsafe = true;
+        }
+      }
+      session.timeline.finish();
+      await this.#save(session);
+    }
+    if (this.#stopping) throw new Error("Claude stopped during startup");
+    this.#started = true;
+  }
+  #newSession(stored) {
+    const session = {
+      stored,
+      timeline: new ClaudeTimeline(stored.summary.sessionId, stored.items, (item) => {
+        stored.summary.modifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.#callbacks?.onConversationItem(stored.summary.sessionId, item);
+      }),
+      queue: [],
+      active: void 0,
+      input: void 0,
+      query: void 0,
+      controller: void 0,
+      work: void 0,
+      dispatch: void 0,
+      aborting: void 0,
+      cancellations: 0,
+      operations: 0,
+      lock: Promise.resolve(),
+      saving: Promise.resolve(),
+      saves: 0,
+      error: void 0,
+      epoch: 0,
+      busy: false,
+      background: false,
+      resultSeen: false
+    };
+    return session;
+  }
+  #ready() {
+    if (!this.#started || this.#stopping) throw new Error("Claude adapter is not running");
+  }
+  #known(id) {
+    this.#ready();
+    const session = this.#sessions.get(id);
+    if (!session) throw new Error(`Unknown host-owned Claude session: ${id}`);
+    return session;
+  }
+  isSessionVisible(id) {
+    return this.#started && !this.#stopping && this.#sessions.has(id);
+  }
+  sessionPublicationSource(id) {
+    this.#known(id);
+    return "claude:host-owned";
+  }
+  async canUpgrade() {
+    return this.#started && !this.#stopping && this.#interactions.size === 0 && [...this.#sessions.values()].every((s) => (!s.work || s.query !== void 0) && !s.dispatch && !s.active && !s.busy && !s.background && !s.cancellations && !s.operations && !s.aborting && !s.queue.length && !s.saves && !s.error);
+  }
+  async listSessions(userId, machineId) {
+    this.#ready();
+    return [...this.#sessions.values()].filter((s) => s.stored.summary.userId === userId && s.stored.summary.machineId === machineId).map((s) => structuredClone(s.stored.summary));
+  }
+  async listModels() {
+    this.#ready();
+    return [{ id: CLAUDE_DEFAULT_MODEL_ID, name: "Claude agent default", isDefault: true }];
+  }
+  getSessionCapabilities() {
+    return { agentModes: this.agentModes, supportsReasoningEffort: false, supportsFileAttachments: false, agentName: "Claude", supportsPlanRead: false };
+  }
+  async getSessionConfiguration(id) {
+    return { modelId: this.#known(id).stored.modelId, agentMode: "interactive", reasoningEffort: "default" };
+  }
+  async getSessionDirectoryMetadata(id) {
+    const workingDirectory = this.#known(id).stored.summary.workingDirectory;
+    return workingDirectory === void 0 ? {} : { workingDirectory };
+  }
+  async getSessionEnvironment(id) {
+    this.#known(id);
+    return { tools: [], skills: [], slashCommands: [] };
+  }
+  #unsupported(operation) {
+    throw new UnsupportedAgentOperationError("claude", operation);
+  }
+  async getSessionRemoteStatus(id) {
+    this.#known(id);
+    return this.#unsupported("vendor remote sessions");
+  }
+  async setSessionRemote(id, _enabled) {
+    return this.getSessionRemoteStatus(id);
+  }
+  async deleteSession(id) {
+    this.#known(id);
+    return this.#unsupported("native session deletion");
+  }
+  async readSessionPlan(id) {
+    this.#known(id);
+    return this.#unsupported("plan reading");
+  }
+  async setGroupChatEnabled(enabled) {
+    if (enabled) this.#unsupported("group chat");
+  }
+  async setPeerChatEnabled(enabled) {
+    if (enabled) this.#unsupported("peer chat");
+  }
+  async watchSession(id, _watched) {
+    this.#known(id);
+  }
+  #validate(options) {
+    if (options.agentMode !== void 0 && options.agentMode !== "interactive") this.#unsupported("agent modes");
+    if (options.reasoningEffort !== void 0 && options.reasoningEffort !== "default") this.#unsupported("reasoning controls");
+    if (options.configOption !== void 0) this.#unsupported("configuration options");
+    if (options.modelId !== void 0 && options.modelId !== CLAUDE_DEFAULT_MODEL_ID) this.#unsupported("model selection");
+  }
+  async createSession(options) {
+    this.#ready();
+    this.#validate(options);
+    if (!isAbsolute(options.workingDirectory)) throw new Error("Claude working directory must be absolute");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const summary = SessionSummarySchema.parse({
+      sessionId: `claude:${randomUUID2()}`,
+      userId: options.userId,
+      machineId: options.machineId,
+      workingDirectory: options.workingDirectory,
+      createdAt: now,
+      modifiedAt: now,
+      isRemote: false,
+      renameSupported: true
+    });
+    const session = this.#newSession({ version: 1, summary, modelId: options.modelId, items: [], receipts: [], unsafe: false });
+    this.#sessions.set(summary.sessionId, session);
+    await this.#save(session);
+    this.#callbacks?.onSessionInventoryChanged(summary.sessionId);
+    return structuredClone(summary);
+  }
+  async configureSession(id, options) {
+    this.#known(id);
+    this.#validate(options);
+    return this.getSessionConfiguration(id);
+  }
+  async renameSession(id, name, assertAccess) {
+    const session = this.#known(id);
+    const title = validateSessionName(name);
+    assertAccess?.();
+    session.stored.summary.summary = title;
+    await this.#save(session);
+    this.#callbacks?.onSessionInventoryChanged(id);
+    return title;
+  }
+  async readSessionTimelinePage(id, options = {}) {
+    const session = this.#known(id);
+    const size = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
+    if (!Number.isSafeInteger(size) || size < 1 || size > SESSION_TIMELINE_PAGE_SIZE) throw new Error("Invalid Claude page size");
+    const items = session.stored.items;
+    const boundary = options.cursor === void 0 ? items.length : items.findIndex((item) => `${identity(id)}:${item.id}` === options.cursor);
+    const end = boundary < 0 ? items.length : boundary;
+    const start = Math.max(0, end - size);
+    const selected = options.metadataOnly ? options.assistantPreview ? latestPreviewItems(items) : [] : items.slice(start, end);
+    return {
+      items: structuredClone(selected),
+      cursor: `${identity(id)}:${items[start]?.id ?? "empty"}`,
+      hasMore: options.metadataOnly ? false : start > 0,
+      cursorStatus: boundary < 0 ? "expired" : "ok"
+    };
+  }
+  async sendPrompt(id, prompt, mode, attachments = [], _persistInteractions = true, files = [], operationId, avatar) {
+    const session = this.#known(id);
+    if (attachments.length || files.length) this.#unsupported("attachments");
+    if (avatar !== void 0) this.#unsupported("avatar personas");
+    if (!prompt.trim() || prompt.length > 1e5) throw new Error("Invalid Claude prompt");
+    if (session.aborting) throw new Error("Claude cancellation is still settling");
+    session.operations++;
+    const epoch = session.epoch;
+    const run = session.lock.then(async () => {
+      this.#ready();
+      if (session.epoch !== epoch || session.aborting) throw new Error("Claude prompt cancelled before acceptance");
+      if (session.error instanceof ClaudeProcessTerminationError) throw session.error;
+      if (session.error) throw new Error("Claude session persistence failed", { cause: session.error });
+      if (session.stored.unsafe) throw new Error("Claude native session identity is uncertain; create a new session");
+      const duplicate = operationId === void 0 ? void 0 : session.stored.receipts.find((entry) => entry.operationId === operationId);
+      if (duplicate) {
+        if (duplicate.prompt !== prompt || duplicate.mode !== mode) throw new Error("Claude operation ID already has different content");
+        if (duplicate.state === "failed" || duplicate.state === "cancelled") throw new Error("Claude operation already ended; it was not retried");
+        return { messageId: duplicate.id, deliveryState: duplicate.state === "queued" ? "queued" : "processing", submittedAt: duplicate.submittedAt };
+      }
+      if (mode === "immediate" && session.busy) {
+        await this.#cancel(session, false);
+        if (session.aborting || this.#stopping || session.epoch !== epoch + 1) throw new Error("Claude prompt cancelled before acceptance");
+        if (session.stored.unsafe) throw new Error("Claude native session identity is uncertain; create a new session");
+      }
+      const acceptedEpoch = session.epoch;
+      const queued = session.busy || session.queue.length > 0;
+      const receipt = ReceiptSchema.parse({
+        id: randomUUID2(),
+        prompt,
+        mode,
+        submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        state: "queued",
+        ...operationId === void 0 ? {} : { operationId }
+      });
+      session.stored.receipts.push(receipt);
+      if (mode === "immediate") session.queue.unshift(receipt);
+      else session.queue.push(receipt);
+      await this.#save(session);
+      if (session.epoch !== acceptedEpoch || session.aborting || this.#stopping) throw new Error("Claude prompt cancelled before delivery");
+      this.#pump(session);
+      return { messageId: receipt.id, deliveryState: queued ? "queued" : "processing", submittedAt: receipt.submittedAt };
+    });
+    session.lock = run.then(() => void 0, () => void 0);
+    try {
+      return await run;
+    } finally {
+      session.operations--;
+    }
+  }
+  #pump(session) {
+    if (this.#stopping || session.aborting || session.busy || session.error || !session.queue.length) return;
+    if (session.work) {
+      session.busy = true;
+      const dispatch = this.#release(session, session.epoch);
+      session.dispatch = dispatch;
+      void dispatch.catch((error) => {
+        session.error = error;
+        session.query?.close();
+        this.#callbacks?.onSyncError(session.stored.summary.sessionId, error);
+      }).finally(() => {
+        if (session.dispatch === dispatch) session.dispatch = void 0;
+      });
+      return;
+    }
+    session.busy = true;
+    const work = this.#consume(session, session.epoch);
+    session.work = work;
+    void work.finally(() => {
+      if (session.work === work) session.work = void 0;
+    }).catch((error) => {
+      session.error = error;
+      this.#callbacks?.onSyncError(session.stored.summary.sessionId, error);
+    });
+  }
+  #environment() {
+    return prepareClaudeEnvironment(this.#options.env ?? process.env, join(this.#directory, "native"));
+  }
+  async #consume(session, epoch) {
+    const id = session.stored.summary.sessionId;
+    const input = new ClaudeInput();
+    const controller = new AbortController();
+    const ownedProcess = new ClaudeProcess();
+    session.input = input;
+    session.controller = controller;
+    const seen = /* @__PURE__ */ new Set();
+    try {
+      const env = this.#environment();
+      const sdk = this.#options.sdk ?? await import("@anthropic-ai/claude-agent-sdk");
+      if (epoch !== session.epoch || this.#stopping) return;
+      const query = sdk.query({
+        prompt: input,
+        options: {
+          ...session.stored.summary.workingDirectory ? { cwd: session.stored.summary.workingDirectory } : {},
+          env,
+          settingSources: [],
+          includePartialMessages: true,
+          persistSession: true,
+          permissionMode: "default",
+          abortController: controller,
+          spawnClaudeCodeProcess: ownedProcess.spawn,
+          ...session.stored.nativeId ? { resume: session.stored.nativeId } : {},
+          ...this.#options.command ? { pathToClaudeCodeExecutable: this.#options.command } : {},
+          canUseTool: (tool, args, context) => epoch !== session.epoch || controller.signal.aborted ? Promise.resolve({ behavior: "deny", message: "Stale Claude query" }) : this.#interactions.request(id, tool, args, context.signal)
+        }
+      });
+      session.query = query;
+      await this.#release(session, epoch);
+      for await (const raw of query) {
+        if (epoch !== session.epoch || this.#stopping) continue;
+        const message = MessageSchema.parse(raw);
+        if (message.uuid && seen.has(message.uuid)) continue;
+        if (message.uuid) seen.add(message.uuid);
+        if (message.type === "system" && message.subtype === "init") {
+          const nativeId = UuidSchema.parse(message.session_id);
+          if (session.stored.nativeId && session.stored.nativeId !== nativeId) throw new Error("Claude resumed a different native session");
+          session.stored.nativeId = nativeId;
+        } else if (message.session_id && session.stored.nativeId && message.session_id !== session.stored.nativeId) {
+          throw new Error("Claude emitted a foreign session");
+        }
+        if (!session.stored.nativeId && ["assistant", "stream_event", "user", "result"].includes(message.type)) {
+          throw new Error("Claude produced conversation output without a native session identity");
+        }
+        const turnId = session.active?.id ?? id;
+        const confirmations = message.user_message_uuids ?? (message.user_message_uuid ? [message.user_message_uuid] : []);
+        if (message.type === "user" && message.uuid) confirmations.push(message.uuid);
+        for (const receiptId of confirmations) this.#confirm(session, receiptId);
+        session.timeline.project(raw, turnId);
+        if (message.type === "result") {
+          const isError = z4.boolean().parse(message.is_error);
+          session.resultSeen = true;
+          if (session.active) session.active.state = isError ? "failed" : "completed";
+          if (isError) {
+            session.timeline.notice(turnId, "Claude returned an error result; this prompt was not retried.");
+            this.#callbacks?.onSyncError(id, new Error("Claude returned an error result"));
+          }
+        }
+        if (message.type === "system" && message.subtype === "background_tasks_changed") {
+          const background = z4.object({ tasks: z4.array(z4.unknown()) }).safeParse(message);
+          session.background = !background.success || background.data.tasks.length > 0;
+        }
+        if (message.type === "system" && message.subtype === "session_state_changed" && (message.state === "running" || message.state === "requires_action")) {
+          session.busy = true;
+          this.#callbacks?.onSessionActivity?.(id, "working", (/* @__PURE__ */ new Date()).toISOString());
+        }
+        if (message.type === "system" && message.subtype === "session_state_changed" && message.state === "idle" && session.resultSeen) {
+          session.timeline.finish();
+          session.active = void 0;
+          session.busy = false;
+          session.resultSeen = false;
+          this.#callbacks?.onSessionActivity?.(id, "idle", (/* @__PURE__ */ new Date()).toISOString());
+        }
+        await this.#save(session);
+        if (!session.busy && session.queue.length) await this.#release(session, epoch);
+      }
+      if (epoch === session.epoch && session.busy) throw new Error("Claude process ended before the turn settled");
+    } catch (error) {
+      controller.abort();
+      this.#interactions.cancel(id);
+      if (epoch === session.epoch && !this.#stopping) {
+        session.timeline.notice(session.active?.id ?? id, error instanceof Error ? error.message : String(error));
+        this.#callbacks?.onSyncError(id, error);
+      }
+    } finally {
+      controller.abort();
+      this.#interactions.cancel(id);
+      input.close();
+      session.query?.close();
+      session.query = void 0;
+      session.busy = true;
+      try {
+        await ownedProcess.finish(this.#options.processExitTimeoutMs ?? 5e3);
+      } catch (error) {
+        const failure = error instanceof ClaudeProcessTerminationError ? error : new ClaudeProcessTerminationError("Claude process termination failed; native session reuse is blocked", { cause: error });
+        session.error = failure;
+        session.stored.unsafe = true;
+        try {
+          await this.#save(session);
+        } catch (saveError) {
+          session.error = new ClaudeProcessTerminationError(
+            "Claude process termination failed and unsafe session state could not be persisted",
+            { cause: new AggregateError([failure, saveError]) }
+          );
+          throw session.error;
+        }
+        throw failure;
+      }
+      if (epoch === session.epoch) {
+        this.#retire(session, true);
+        session.timeline.finish();
+        await this.#save(session);
+      }
+      session.query = void 0;
+      session.input = void 0;
+      session.controller = void 0;
+      session.busy = false;
+      session.background = false;
+      if (epoch === session.epoch) this.#settled(session);
+    }
+  }
+  async #release(session, epoch) {
+    if (epoch !== session.epoch || this.#stopping) return;
+    const receipt = session.queue.shift();
+    if (!receipt || !session.input) return;
+    session.active = receipt;
+    session.busy = true;
+    session.resultSeen = false;
+    receipt.state = "submitted";
+    await this.#save(session);
+    if (epoch !== session.epoch || this.#stopping) return;
+    session.input.push({
+      type: "user",
+      uuid: receipt.id,
+      message: { role: "user", content: receipt.prompt },
+      parent_tool_use_id: null,
+      priority: receipt.mode === "enqueue" ? "later" : "next",
+      client_composed: true,
+      ...session.stored.nativeId ? { session_id: session.stored.nativeId } : {}
+    });
+    this.#callbacks?.onSessionActivity?.(session.stored.summary.sessionId, "working", (/* @__PURE__ */ new Date()).toISOString());
+  }
+  #confirm(session, id) {
+    const receipt = session.stored.receipts.find((entry) => entry.id === id);
+    if (!receipt || receipt.state !== "submitted" && receipt.state !== "confirmed") return;
+    receipt.state = "confirmed";
+    session.timeline.upsert({
+      ...session.timeline.base(receipt.id, receipt.id),
+      timestamp: receipt.submittedAt,
+      sourceMessageIds: [receipt.id],
+      kind: "human-message",
+      actor: "human",
+      content: receipt.prompt,
+      attachments: [],
+      ...receipt.operationId ? { operationId: receipt.operationId } : {}
+    });
+  }
+  #retire(session, clearQueue) {
+    if (session.active && !session.stored.nativeId) session.stored.unsafe = true;
+    if (session.active && !["completed", "failed"].includes(session.active.state)) {
+      session.active.state = "cancelled";
+      session.timeline.notice(session.active.id, "Prompt interrupted; it was not retried.", "warning");
+    }
+    session.active = void 0;
+    if (clearQueue) {
+      for (const receipt of session.queue) {
+        receipt.state = "cancelled";
+        session.timeline.notice(receipt.id, "Queued prompt cancelled before delivery.", "warning");
+      }
+      session.queue = [];
+    }
+  }
+  async abortSession(id) {
+    const session = this.#known(id);
+    if (session.aborting) return session.aborting;
+    const cancellation = this.#cancel(session, true);
+    const work = (async () => {
+      await cancellation;
+      await session.lock;
+      await session.saving;
+    })();
+    session.aborting = work;
+    try {
+      await work;
+    } finally {
+      session.aborting = void 0;
+    }
+  }
+  async #cancel(session, clearQueue) {
+    session.cancellations++;
+    try {
+      if (session.error instanceof ClaudeProcessTerminationError) throw session.error;
+      session.epoch++;
+      session.input?.close();
+      session.controller?.abort();
+      this.#interactions.cancel(session.stored.summary.sessionId);
+      session.query?.close();
+      await session.work;
+      await session.dispatch;
+      this.#retire(session, clearQueue);
+      session.timeline.finish();
+      session.busy = false;
+      await this.#save(session);
+      this.#settled(session);
+    } finally {
+      session.cancellations--;
+    }
+  }
+  #settled(session) {
+    const id = session.stored.summary.sessionId;
+    this.#callbacks?.onSessionActivity?.(id, "idle", (/* @__PURE__ */ new Date()).toISOString());
+    this.#callbacks?.onSessionInventoryChanged(id);
+  }
+  respondPermission(id, decision, feedback) {
+    return this.#interactions.respond(id, { kind: "permission", decision, ...feedback ? { feedback } : {} });
+  }
+  async respondInteraction(id, response) {
+    return this.#interactions.respond(id, response);
+  }
+  replayPendingInteractions() {
+    this.#interactions.replay();
+  }
+  #save(session) {
+    const data = JSON.stringify(StoredSchema.parse(session.stored));
+    const file = join(this.#directory, `${identity(session.stored.summary.sessionId)}.json`);
+    session.saves++;
+    const work = session.saving.then(async () => {
+      const temporary = `${file}.${randomUUID2()}.tmp`;
+      try {
+        await writeFile(temporary, data, { encoding: "utf8", mode: 384, flag: "wx" });
+        await rename(temporary, file);
+      } finally {
+        await rm(temporary, { force: true });
+      }
+    });
+    session.saving = work.catch((error) => {
+      session.error = error;
+      this.#callbacks?.onSyncError(session.stored.summary.sessionId, error);
+    }).finally(() => {
+      session.saves--;
+    });
+    return work;
+  }
+  stop() {
+    if (this.#stopPromise) return this.#stopPromise;
+    this.#stopping = true;
+    this.#stopPromise = this.#stop();
+    return this.#stopPromise;
+  }
+  async #stop() {
+    if (this.#starting && !this.#started) {
+      const [result] = await Promise.allSettled([this.#starting]);
+      if (result?.status === "rejected") {
+        this.#options.onDiagnostic?.(`Claude startup did not complete: ${String(result.reason)}`);
+      }
+    }
+    await Promise.all([...this.#sessions.values()].map(async (session) => {
+      await (session.aborting ?? this.#cancel(session, true));
+      await session.lock;
+      await session.saving;
+    }));
+    this.#started = false;
+  }
+};
+export {
+  CLAUDE_DEFAULT_MODEL_ID,
+  ClaudeCodingAgentAdapter
+};