@anureo/adapter-claude 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1000 @@
+// packages/claude/src/file-changes.ts
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+function claudeFileChanges(name, input, result) {
+  if (!["Edit", "MultiEdit", "Write"].includes(name))
+    return;
+  const data = record(input), output = record(result);
+  const path = typeof output.filePath === "string" ? output.filePath : typeof data.file_path === "string" ? data.file_path : undefined;
+  if (path === undefined)
+    return [];
+  if (typeof output.patch === "string")
+    return [{ path, operation: "modify", materials: [{ format: "unified", patch: output.patch }], completeness: "complete" }];
+  if ((output.oldText === null || typeof output.oldText === "string") && typeof output.newText === "string")
+    return [{ path, operation: output.oldText === null ? "add" : "modify", materials: [{ format: "text", scope: "file", oldText: output.oldText, newText: output.newText }], completeness: "complete" }];
+  if (Array.isArray(output.structuredPatch) && output.structuredPatch.length) {
+    const hunks = output.structuredPatch.map(record);
+    const valid = hunks.every((hunk) => ["oldStart", "oldLines", "newStart", "newLines"].every((key) => Number.isInteger(hunk[key]) && hunk[key] >= 0) && Array.isArray(hunk.lines) && hunk.lines.every((line) => typeof line === "string" && /^[ +\\-]/.test(line)));
+    if (valid) {
+      const patch = hunks.map((hunk) => `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@
+${hunk.lines.join(`
+`)}
+`).join("");
+      return [{ path, operation: output.type === "create" ? "add" : "modify", materials: [{ format: "unified", patch }], completeness: "complete" }];
+    }
+  }
+  if (name === "Write" && typeof output.content === "string" && (typeof output.originalFile === "string" || output.type === "create" && output.originalFile === null)) {
+    return [{ path, operation: output.type === "create" ? "add" : "modify", materials: [{ format: "text", scope: "file", oldText: output.originalFile, newText: output.content }], completeness: "complete" }];
+  }
+  if (name === "Write")
+    return [{ path, operation: "unknown", materials: [{ format: "unavailable", reason: "notProvided" }], completeness: "partial" }];
+  const edits = name === "MultiEdit" && Array.isArray(data.edits) ? data.edits : [data];
+  const materials = edits.flatMap((value) => {
+    const edit = record(value);
+    return typeof edit.old_string === "string" && typeof edit.new_string === "string" ? [{ format: "text", scope: "fragment", oldText: edit.old_string, newText: edit.new_string }] : [];
+  });
+  const partial = name === "MultiEdit" || edits.some((value) => record(value).replace_all === true) || materials.length !== edits.length;
+  return [{ path, operation: "modify", materials: materials.length ? materials : [{ format: "unavailable", reason: "notProvided" }], completeness: partial || !materials.length ? "partial" : "complete" }];
+}
+function completeClaudeTool(previous, block) {
+  const fileChanges = claudeFileChanges(previous.nativeType ?? previous.title, previous.input, block.structuredContent ?? block.content);
+  return { ...previous, status: previous.status === "declined" || previous.status === "interrupted" ? previous.status : block.is_error ? "failed" : "completed", output: block.content, ...fileChanges !== undefined ? { fileChanges } : {} };
+}
+
+// packages/claude/src/index.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { spawn } from "node:child_process";
+import { join as join2 } from "node:path";
+import {
+  query,
+  getSessionMessages,
+  getSessionInfo,
+  forkSession
+} from "@anthropic-ai/claude-agent-sdk";
+import {
+  BoundedEventQueue,
+  HarnessSdkError as HarnessSdkError2,
+  sdkError
+} from "@anureo/sdk";
+import {
+  negotiateVersion,
+  publicValue,
+  validateJsonSchema
+} from "@anureo/protocol";
+
+// packages/claude/src/store.ts
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { HarnessSdkError } from "@anureo/sdk";
+
+class FileSessionStore {
+  directory;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  file(key) {
+    return join(this.directory, `${createHash("sha256").update(JSON.stringify([key.projectKey, key.sessionId, key.subpath ?? null])).digest("hex")}.json`);
+  }
+  async read(file) {
+    try {
+      const value = JSON.parse(await readFile(file, "utf8"));
+      if (!value || !value.key || !Array.isArray(value.entries))
+        throw new HarnessSdkError("SESSION_STORE_INVALID");
+      return value;
+    } catch (cause) {
+      if (cause.code === "ENOENT")
+        return null;
+      throw cause;
+    }
+  }
+  async append(key, entries) {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const file = this.file(key);
+    const lockPath = `${file}.lock`;
+    const expires = Date.now() + 1e4;
+    let lock;
+    while (!lock) {
+      try {
+        lock = await open(lockPath, "wx", 384);
+        await lock.writeFile(String(process.pid));
+      } catch (cause) {
+        if (cause.code !== "EEXIST")
+          throw cause;
+        const pid = Number(await readFile(lockPath, "utf8").catch(() => ""));
+        let alive = true;
+        if (Number.isSafeInteger(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+          } catch (error) {
+            alive = error.code !== "ESRCH";
+          }
+        }
+        if (!alive) {
+          await rm(lockPath, { force: true });
+          continue;
+        }
+        if (Date.now() >= expires)
+          throw new HarnessSdkError("SESSION_STORE_BUSY");
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+    }
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+      const stored = await this.read(file) ?? { key: structuredClone(key), entries: [], mtime: 0 };
+      const byId = new Map(stored.entries.flatMap((entry, index) => entry.uuid ? [[entry.uuid, index]] : []));
+      for (const entry of entries) {
+        const previous = entry.uuid ? byId.get(entry.uuid) : undefined;
+        if (previous !== undefined)
+          stored.entries[previous] = structuredClone(entry);
+        else {
+          if (entry.uuid)
+            byId.set(entry.uuid, stored.entries.length);
+          stored.entries.push(structuredClone(entry));
+        }
+      }
+      stored.mtime = Math.max(Date.now(), stored.mtime + 1);
+      const target = await open(temporary, "wx", 384);
+      try {
+        await target.writeFile(JSON.stringify(stored));
+        await target.sync();
+      } finally {
+        await target.close();
+      }
+      await rename(temporary, file);
+    } finally {
+      await rm(temporary, { force: true });
+      await lock.close();
+      await rm(lockPath, { force: true });
+    }
+  }
+  async load(key) {
+    const value = await this.read(this.file(key));
+    return value ? structuredClone(value.entries) : null;
+  }
+  async all() {
+    const names = await readdir(this.directory).catch((cause) => {
+      if (cause.code === "ENOENT")
+        return [];
+      throw cause;
+    });
+    const entries = await Promise.all(names.filter((name) => /^[a-f0-9]{64}\.json$/.test(name)).map((name) => this.read(join(this.directory, name))));
+    return entries.filter((entry) => entry !== null);
+  }
+  async listSessions(projectKey) {
+    return (await this.all()).filter((entry) => entry.key.projectKey === projectKey && !entry.key.subpath).map(({ key, mtime }) => ({ sessionId: key.sessionId, mtime }));
+  }
+  async listSubkeys(key) {
+    return (await this.all()).filter((entry) => entry.key.projectKey === key.projectKey && entry.key.sessionId === key.sessionId && entry.key.subpath).map((entry) => entry.key.subpath);
+  }
+  async delete(key) {
+    await rm(this.file(key), { force: true });
+  }
+  turnMapPath(sessionId) {
+    return join(this.directory, `${createHash("sha256").update(`turns:${sessionId}`).digest("hex")}.turns.json`);
+  }
+  async loadTurnMap(sessionId) {
+    try {
+      return JSON.parse(await readFile(this.turnMapPath(sessionId), "utf8"));
+    } catch (cause) {
+      if (cause.code === "ENOENT")
+        return {};
+      throw cause;
+    }
+  }
+  async saveTurnMap(sessionId, turns) {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const path = this.turnMapPath(sessionId);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+      const file = await open(temporary, "wx", 384);
+      try {
+        await file.writeFile(JSON.stringify(turns));
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      await rename(temporary, path);
+    } finally {
+      await rm(temporary, { force: true });
+    }
+  }
+}
+
+// packages/claude/src/index.ts
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function str(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function json(value) {
+  try {
+    return JSON.parse(JSON.stringify(value ?? null));
+  } catch {
+    return null;
+  }
+}
+function safe(value) {
+  return publicValue(json(value));
+}
+function elicitationContent(value) {
+  const content = {};
+  for (const [key, field] of Object.entries(value)) {
+    if (typeof field === "string" || typeof field === "number" || typeof field === "boolean" || Array.isArray(field) && field.every((entry) => typeof entry === "string"))
+      content[key] = field;
+    else
+      throw new HarnessSdkError2("INVALID_PARAMS", "Elicitation response cannot be represented by MCP");
+  }
+  return content;
+}
+var PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var isEffort = (value) => typeof value === "string" && EFFORT_LEVELS.includes(value);
+function permission(value) {
+  if (typeof value !== "string" || !PERMISSION_MODES.includes(value))
+    throw new HarnessSdkError2("INVALID_PARAMS", "Unsupported permission mode");
+  return value;
+}
+function capabilities(store, checkpoints) {
+  return {
+    session: { resume: store, fork: store ? ["before", "through"] : [], revert: [...store ? ["conversation"] : [], ...checkpoints ? ["files"] : [], ...store && checkpoints ? ["both"] : []], history: store },
+    turn: { steer: false, interrupt: true, outputSchema: false, overrides: [], inputModalities: ["text", "image"] },
+    interactions: ["approval", "userInput", "elicitation"],
+    subagents: { events: "nested" },
+    mcp: { stdio: true, http: true, elicitation: ["form", "url"] },
+    config: { options: [{ id: "model", scope: "session", schema: { type: "string", minLength: 1 } }, { id: "permissionMode", title: "Permissions", scope: "session", schema: { type: "string", enum: PERMISSION_MODES, default: "default" } }, { id: "effort", title: "Effort", scope: "session", schema: { type: "string", enum: [...EFFORT_LEVELS], default: "high" } }, { id: "fastMode", title: "Fast mode", scope: "session", schema: { type: "boolean", default: false } }, { id: "maxThinkingTokens", scope: "session", schema: { type: ["integer", "null"], minimum: 0 } }] }
+  };
+}
+function basicEnvironment() {
+  const env = {};
+  for (const key of ["PATH", "Path", "SystemRoot", "WINDIR", "COMSPEC", "PATHEXT", "TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE", "USER", "LOGNAME", "LANG", "LC_ALL"])
+    if (process.env[key] !== undefined)
+      env[key] = process.env[key];
+  return env;
+}
+function content(input) {
+  return input.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    if (block.type === "image" && block.data && block.mimeType && ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(block.mimeType))
+      return { type: "image", source: { type: "base64", data: block.data, media_type: block.mimeType } };
+    if (block.type === "image" && block.url)
+      return { type: "image", source: { type: "url", url: block.url } };
+    throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "Input cannot be represented by the Claude SDK");
+  });
+}
+function isPrompt(message) {
+  if (message.type !== "user")
+    return false;
+  const body = record2(message.message).content;
+  return typeof body === "string" || Array.isArray(body) && body.some((part) => record2(part).type !== "tool_result");
+}
+
+class ClaudeNativeAdapter {
+  options;
+  sessionStore;
+  defaultStore;
+  sessions = new Set;
+  turnMaps = new Map;
+  disposed = false;
+  env;
+  constructor(options = {}) {
+    this.options = options;
+    const stateDir = options.stateDir ?? options.env?.CLAUDE_CONFIG_DIR;
+    this.env = { ...basicEnvironment(), ...options.env, ...stateDir && !options.defaultHome ? { CLAUDE_CONFIG_DIR: stateDir } : {} };
+    if (!options.sessionStore && stateDir)
+      this.defaultStore = new FileSessionStore(join2(stateDir, "ahp-session-store"));
+    this.sessionStore = options.sessionStore ?? this.defaultStore;
+  }
+  get capabilities() {
+    return capabilities(!!this.sessionStore, !!this.options.enableFileCheckpointing);
+  }
+  async initialize(params) {
+    negotiateVersion(params.protocolVersions);
+    if (this.disposed)
+      throw new HarnessSdkError2("RUNTIME_DISPOSED");
+    if (!this.env.CLAUDE_CONFIG_DIR && !this.options.defaultHome && !this.options.queryFactory)
+      throw new HarnessSdkError2("HARNESS_CONFIG_INVALID", "Claude requires an explicit isolated CLAUDE_CONFIG_DIR");
+    return { protocolVersion: 1, runtime: { name: "claude", version: "0.3.257", adapter: "claude-native/0.1.0" }, capabilities: this.capabilities };
+  }
+  async openSession(params, sink) {
+    if (this.disposed)
+      throw new HarnessSdkError2("RUNTIME_DISPOSED");
+    if (params.binding.adapterId !== "claude" && params.binding.adapterId !== "claude-native")
+      throw new HarnessSdkError2("SESSION_BINDING_MISMATCH");
+    const session = new ClaudeBackendSession(this, params, sink, this.defaultStore);
+    await session.open();
+    this.sessions.add(session);
+    return session;
+  }
+  async listModels(cwd = process.cwd()) {
+    const input = new BoundedEventQueue;
+    const stream = (this.options.queryFactory ?? query)({ prompt: input, options: this.queryOptions(cwd) });
+    try {
+      return await stream.supportedModels();
+    } finally {
+      input.end();
+      stream.close();
+    }
+  }
+  queryOptions(cwd) {
+    return {
+      cwd,
+      env: this.env,
+      settingSources: [],
+      persistSession: true,
+      includePartialMessages: true,
+      includeHookEvents: true,
+      ...this.options.command ?? this.options.executable ? { pathToClaudeCodeExecutable: this.options.command ?? this.options.executable } : {},
+      ...this.options.executableRuntime ? { executable: this.options.executableRuntime } : {},
+      ...this.options.args?.length ? { spawnClaudeCodeProcess: (options) => spawn(options.command, [...options.args, ...this.options.args], { cwd: options.cwd, env: options.env, signal: options.signal, stdio: ["pipe", "pipe", "pipe"], shell: false, windowsHide: true }) } : {},
+      ...this.sessionStore ? { sessionStore: this.sessionStore, sessionStoreFlush: "eager" } : {},
+      enableFileCheckpointing: this.options.enableFileCheckpointing ?? false
+    };
+  }
+  async dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    await Promise.allSettled([...this.sessions].map((session) => session.dispose()));
+    this.sessions.clear();
+  }
+}
+
+class ClaudeBackendSession {
+  adapter;
+  params;
+  sink;
+  fileStore;
+  binding;
+  capabilities;
+  query;
+  input;
+  active;
+  generation = 0;
+  closed = false;
+  config;
+  capabilityRevision = 1;
+  model;
+  turns = {};
+  historySnapshots = new Map;
+  fastMode;
+  storeKeys = new Map;
+  sessionTitle;
+  metadataTail = Promise.resolve();
+  metadataPending;
+  observedStore(store, generation) {
+    return {
+      append: async (key, entries) => {
+        await store.append(key, entries);
+        if (!key.subpath && key.sessionId === this.nativeId && generation === this.generation && !this.closed)
+          this.refreshMetadata();
+      },
+      load: store.load.bind(store),
+      ...store.listSessions ? { listSessions: store.listSessions.bind(store) } : {},
+      ...store.listSubkeys ? { listSubkeys: store.listSubkeys.bind(store) } : {},
+      ...store.delete ? { delete: store.delete.bind(store) } : {},
+      ...store.listSessionSummaries ? { listSessionSummaries: store.listSessionSummaries.bind(store) } : {}
+    };
+  }
+  refreshMetadata() {
+    const generation = this.generation, nativeId = this.nativeId;
+    if (this.metadataPending?.generation === generation) {
+      this.metadataPending.dirty = true;
+      return this.metadataPending.promise;
+    }
+    const pending = { generation, dirty: true, promise: Promise.resolve() };
+    pending.promise = this.metadataTail.then(async () => {
+      try {
+        while (pending.dirty && !this.closed && generation === this.generation && nativeId === this.nativeId) {
+          pending.dirty = false;
+          try {
+            const info = await (this.adapter.options.getSessionInfo ?? getSessionInfo)(nativeId, { dir: this.params.cwd, sessionStore: this.adapter.sessionStore });
+            if (!info || this.closed || generation !== this.generation || nativeId !== this.nativeId)
+              continue;
+            const title = info.summary.trim() || null;
+            if (this.sessionTitle === title)
+              continue;
+            this.sessionTitle = title;
+            await this.sink.emit({ type: "session/metadata", payload: { title } });
+          } catch {
+            if (!this.closed && generation === this.generation)
+              await this.sink.emit({ type: "notice", payload: { severity: "warning", code: "SESSION_METADATA_UNAVAILABLE", message: "Session title could not be refreshed" } }).catch(() => {});
+          }
+        }
+      } finally {
+        if (this.metadataPending === pending)
+          this.metadataPending = undefined;
+      }
+    });
+    this.metadataPending = pending;
+    this.metadataTail = pending.promise;
+    return pending.promise;
+  }
+  constructor(adapter, params, sink, fileStore) {
+    this.adapter = adapter;
+    this.params = params;
+    this.sink = sink;
+    this.fileStore = fileStore;
+    this.binding = { ...params.binding, nativeRef: params.binding.nativeRef ?? { provider: "claude", value: randomUUID2() } };
+    this.capabilities = adapter.capabilities;
+    this.config = structuredClone(params.config ?? {});
+    this.model = params.model ?? str(this.config.model);
+    for (const [key, value] of Object.entries(this.config)) {
+      const option = this.capabilities.config?.options.find((entry) => entry.id === key);
+      if (!option)
+        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "Unknown Claude config option");
+      if (!validateJsonSchema(option.schema, value))
+        throw new HarnessSdkError2("INVALID_PARAMS", "Invalid Claude config value");
+    }
+  }
+  get nativeId() {
+    return this.binding.nativeRef.value;
+  }
+  async open() {
+    if (this.params.mode === "resume" && !this.params.binding.nativeRef)
+      throw new HarnessSdkError2("SESSION_NOT_FOUND");
+    if (this.params.mode === "fork") {
+      if (!this.params.fork?.nativeRef)
+        throw new HarnessSdkError2("SESSION_NOT_FOUND");
+      const source = this.params.fork.nativeRef.value;
+      const point = await this.boundaryPoint(source, this.params.fork.boundary);
+      const forked = point.uuid ? await (this.adapter.options.forkSession ?? forkSession)(source, { dir: this.params.cwd, sessionStore: this.adapter.sessionStore, upToMessageId: point.uuid }) : { sessionId: randomUUID2() };
+      this.binding = { ...this.binding, nativeRef: { provider: "claude", value: forked.sessionId } };
+      this.turns = this.fileStore ? await this.fileStore.loadTurnMap(source) : structuredClone(this.adapter.turnMaps.get(source) ?? {});
+    } else
+      this.turns = this.fileStore ? await this.fileStore.loadTurnMap(this.nativeId) : this.adapter.turnMaps.get(this.nativeId) ?? {};
+    this.adapter.turnMaps.set(this.nativeId, this.turns);
+    await this.fileStore?.saveTurnMap(this.nativeId, this.turns);
+    await this.startQuery(this.params.mode === "new" || this.params.mode === "fork" && !await this.hasHistory(this.nativeId));
+  }
+  async hasHistory(id) {
+    return (await this.messages(id)).length > 0;
+  }
+  trackFastMode(value) {
+    const state = str(value.fast_mode_state);
+    if (state !== "off" && state !== "cooldown" && state !== "on")
+      return false;
+    const reason = str(value.fast_mode_disabled_reason);
+    const next = { state, ...reason ? { reason } : {} };
+    const changed = JSON.stringify(next) !== JSON.stringify(this.fastMode);
+    this.fastMode = next;
+    return changed;
+  }
+  snapshot() {
+    return { ...this.sessionTitle !== undefined ? { metadata: { title: this.sessionTitle } } : {}, binding: structuredClone(this.binding), status: this.active ? "running" : "ready", config: structuredClone(this.config), capabilities: this.capabilities, capabilityRevision: this.capabilityRevision, ...this.model ? { model: this.model } : {}, ...this.fastMode ? { fastMode: this.fastMode } : {}, ...this.active ? { activeTurnId: this.active.id } : {} };
+  }
+  async startQuery(fresh, resumeAt) {
+    const generation = ++this.generation;
+    this.input = new BoundedEventQueue({ maxEvents: 1 });
+    const mcpServers = {};
+    for (const server of this.params.mcpServers ?? [])
+      mcpServers[server.name] = server.type === "stdio" ? { type: "stdio", command: server.command, args: server.args, env: server.env } : { type: "http", url: server.url, headers: server.headers };
+    const options = {
+      ...this.adapter.queryOptions(this.params.cwd),
+      ...this.adapter.sessionStore ? { sessionStore: this.observedStore(this.adapter.sessionStore, generation) } : {},
+      ...fresh ? { sessionId: this.nativeId } : { resume: this.nativeId },
+      ...resumeAt ? { resumeSessionAt: resumeAt } : {},
+      ...this.model ? { model: this.model } : {},
+      ...this.params.instructions ? { systemPrompt: this.params.instructions } : {},
+      ...this.config.permissionMode !== undefined || this.params.permissionMode ? { permissionMode: permission(this.config.permissionMode ?? this.params.permissionMode) } : {},
+      allowDangerouslySkipPermissions: true,
+      ...typeof this.config.maxThinkingTokens === "number" ? { maxThinkingTokens: this.config.maxThinkingTokens } : {},
+      ...isEffort(this.config.effort) ? { effort: this.config.effort } : {},
+      ...this.config.fastMode === true ? { settings: { fastMode: true } } : {},
+      mcpServers,
+      canUseTool: async (toolName, input, details) => this.permissionRequest(toolName, input, details),
+      onElicitation: async (request, details) => this.elicitationRequest(request, details)
+    };
+    this.query = (this.adapter.options.queryFactory ?? query)({ prompt: this.input, options });
+    this.pump(this.query, generation);
+    if (!fresh)
+      await this.refreshMetadata();
+  }
+  async pump(stream, generation) {
+    try {
+      for await (const message of stream) {
+        if (this.closed || generation !== this.generation)
+          return;
+        await this.mapMessage(message);
+      }
+      if (!this.closed && generation === this.generation && this.active)
+        await this.sink.fail(new HarnessSdkError2("CONNECTION_CLOSED", "Claude query ended before a result", false, true));
+    } catch (cause) {
+      if (!this.closed && generation === this.generation)
+        await this.sink.fail(sdkError(cause, "CLAUDE_QUERY_FAILED", true));
+    }
+  }
+  async mapMessage(message) {
+    const value = record2(message);
+    const active = this.active;
+    if (message.type === "system" && message.subtype === "init") {
+      this.trackFastMode(value);
+      if (message.session_id !== this.nativeId) {
+        this.binding = { ...this.binding, nativeRef: { provider: "claude", value: message.session_id } };
+        this.adapter.turnMaps.set(this.nativeId, this.turns);
+        await this.fileStore?.saveTurnMap(this.nativeId, this.turns);
+      }
+      await this.sink.emit({ type: "session/state", payload: this.snapshot() });
+      return;
+    }
+    if (!active) {
+      await this.notice(value);
+      return;
+    }
+    if (value.user_message_uuid && value.user_message_uuid !== active.userUuid && !value.parent_tool_use_id)
+      throw new HarnessSdkError2("TURN_MISMATCH", "Claude replied to a different input UUID");
+    if (message.type === "assistant") {
+      for (const block of message.message.content)
+        await this.completeBlock(record2(block), message.message.id, message.parent_tool_use_id !== null);
+      return;
+    }
+    if (message.type === "stream_event") {
+      await this.streamEvent(record2(message.event));
+      return;
+    }
+    if (message.type === "user") {
+      const body = record2(message.message).content;
+      if (Array.isArray(body))
+        for (const part of body) {
+          const block = record2(part);
+          if (block.type !== "tool_result")
+            continue;
+          const toolId = str(block.tool_use_id);
+          if (!toolId)
+            continue;
+          const previous = active.output.get(toolId);
+          if (previous?.type === "toolCall") {
+            const item = completeClaudeTool(previous, { ...block, content: safe(block.content), ...value.tool_use_result !== undefined ? { structuredContent: safe(value.tool_use_result) } : {} });
+            active.output.set(toolId, item);
+            await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId: active.id });
+          }
+        }
+      return;
+    }
+    if (message.type === "result") {
+      const resultText = message.subtype === "success" ? message.result : undefined;
+      const textItems = [...active.output.values()].filter((item) => item.type === "agentMessage" && item.status !== "completed");
+      for (let index = 0;index < textItems.length; index++) {
+        const item = textItems[index];
+        if (item.type !== "agentMessage")
+          continue;
+        const completed = { ...item, text: index === textItems.length - 1 && resultText !== undefined ? resultText : item.text, phase: index === textItems.length - 1 ? "final" : "commentary", status: "completed" };
+        active.output.set(item.id, completed);
+        await this.sink.emit({ type: "item/completed", payload: { item: completed } }, { turnId: active.id });
+      }
+      if (!textItems.length && resultText) {
+        const item = { id: `${active.userUuid}:final`, type: "agentMessage", phase: "final", text: resultText, status: "completed" };
+        await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId: active.id });
+      }
+      const nativeUsage = record2(message.usage);
+      const usage = { provider: "claude", scope: "turn", source: "native", ...typeof nativeUsage.input_tokens === "number" ? { input: nativeUsage.input_tokens } : {}, ...typeof nativeUsage.output_tokens === "number" ? { output: nativeUsage.output_tokens } : {}, ...typeof nativeUsage.cache_read_input_tokens === "number" ? { cacheRead: nativeUsage.cache_read_input_tokens } : {}, ...typeof nativeUsage.cache_creation_input_tokens === "number" ? { cacheWrite: nativeUsage.cache_creation_input_tokens } : {} };
+      await this.sink.emit({ type: "usage/updated", payload: usage }, { turnId: active.id });
+      const interrupted = active.interrupted || str(message.stop_reason) === "interrupted" || str(value.terminal_reason) === "interrupted";
+      const failed = message.subtype !== "success" || message.is_error;
+      for (const pending of active.output.values()) {
+        if (pending.type !== "toolCall" || pending.kind !== "fileChange" || pending.status === "completed" || pending.status === "failed")
+          continue;
+        const item = { ...pending, status: active.stoppedTools.get(pending.id) ?? (interrupted ? "interrupted" : failed ? "failed" : undefined) };
+        active.output.set(item.id, item);
+        await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId: active.id });
+      }
+      this.active = undefined;
+      this.trackFastMode(value);
+      await this.sink.emit({ type: "turn/completed", payload: { turnId: active.id, status: interrupted ? "interrupted" : failed ? "failed" : "completed", usage, ...failed && !interrupted ? { error: { code: "CLAUDE_TURN_FAILED", message: "Claude turn failed", retryable: false, outcomeUnknown: false } } : {} } });
+      this.refreshMetadata();
+      await this.sink.emit({ type: "session/state", payload: this.snapshot() });
+      return;
+    }
+    if (message.type === "system" && typeof value.subtype === "string") {
+      const subtype = value.subtype;
+      if (subtype.startsWith("task_")) {
+        const id = str(value.task_id);
+        if (!id)
+          return this.notice(value);
+        const previous = active.output.get(`task:${id}`);
+        const patch = record2(value.patch);
+        const status = str(value.status) ?? str(patch.status) ?? (subtype === "task_started" ? "running" : "running");
+        const final = ["completed", "failed", "stopped", "killed"].includes(status);
+        const item = { id: `task:${id}`, type: "subagent", subagentId: id, state: status === "completed" ? "completed" : status === "failed" ? "failed" : final ? "interrupted" : "running", status: final ? status === "completed" ? "completed" : "failed" : "running", task: str(value.description) ?? str(patch.description) ?? str(value.summary), ...str(value.tool_use_id) ? { parentItemId: str(value.tool_use_id) } : {} };
+        active.output.set(item.id, item);
+        if (final)
+          await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId: active.id });
+        else if (!previous)
+          await this.sink.emit({ type: "item/started", payload: { item } }, { turnId: active.id });
+        else
+          await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "patch", value: safe(item) } }, { turnId: active.id });
+        return;
+      }
+      if (subtype.startsWith("hook_")) {
+        const id = str(value.hook_id);
+        if (!id)
+          return this.notice(value);
+        const previous = active.output.get(`hook:${id}`);
+        const item = { id: `hook:${id}`, type: "hook", name: str(value.hook_name) ?? "hook", status: subtype === "hook_response" ? value.outcome === "success" ? "completed" : "failed" : "running", ...value.output !== undefined ? { output: safe(value.output) } : {} };
+        active.output.set(item.id, item);
+        if (subtype === "hook_progress") {
+          if (!previous)
+            await this.sink.emit({ type: "item/started", payload: { item } }, { turnId: active.id });
+          await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "output", text: str(value.output) ?? "" } }, { turnId: active.id });
+        } else
+          await this.sink.emit({ type: previous || subtype === "hook_response" ? "item/completed" : "item/started", payload: { item } }, { turnId: active.id });
+        return;
+      }
+      if (subtype === "compact_boundary") {
+        await this.sink.emit({ type: "item/completed", payload: { item: { id: str(value.uuid) ?? randomUUID2(), type: "compaction", status: "completed", summary: str(value.summary), trigger: str(record2(value.compact_metadata).trigger) } } }, { turnId: active.id });
+        return;
+      }
+    }
+    await this.notice(value);
+  }
+  async streamEvent(event) {
+    const active = this.active;
+    const type = event.type;
+    if (type === "message_start") {
+      active.streamMessageId = str(record2(event.message).id);
+      return;
+    }
+    const index = typeof event.index === "number" ? event.index : 0;
+    const id = `${active.streamMessageId ?? active.userUuid}:${index}`;
+    if (type === "content_block_start") {
+      const block = record2(event.content_block);
+      const item = this.blockItem(block, str(block.id) ?? id, true);
+      active.output.set(item.id, item);
+      await this.sink.emit({ type: "item/started", payload: { item } }, { turnId: active.id });
+    } else if (type === "content_block_delta") {
+      const delta = record2(event.delta);
+      const previous = active.output.get(id);
+      if (!previous || previous.type !== "agentMessage" && previous.type !== "reasoning")
+        return;
+      const text = str(delta.text) ?? str(delta.thinking) ?? "";
+      if (previous.type === "agentMessage")
+        previous.text += text;
+      else
+        previous.text = (previous.text ?? "") + text;
+      await this.sink.emit({ type: "item/delta", payload: { itemId: id, kind: previous.type === "reasoning" ? "reasoningSummary" : "text", text } }, { turnId: active.id });
+    }
+  }
+  blockItem(block, id, running) {
+    const status = this.active?.stoppedTools.get(id) ?? (running ? "running" : "completed");
+    if (block.type === "text")
+      return { id, type: "agentMessage", text: str(block.text) ?? "", phase: "commentary", status };
+    if (block.type === "thinking")
+      return { id, type: "reasoning", text: str(block.thinking) ?? "", status };
+    if (block.type === "tool_use") {
+      const name = str(block.name) ?? "unknown";
+      return { id, type: "toolCall", kind: name === "Bash" ? "command" : ["Write", "Edit", "MultiEdit"].includes(name) ? "fileChange" : name.startsWith("mcp__") ? "mcp" : "other", title: name, input: safe(block.input), status, nativeType: name, ...claudeFileChanges(name, block.input) !== undefined ? { fileChanges: claudeFileChanges(name, block.input) } : {} };
+    }
+    return { id, type: "toolCall", kind: "other", title: "Unknown Claude content", nativeType: str(block.type) ?? "unknown", raw: safe(block), status };
+  }
+  async completeBlock(block, messageId, subagent) {
+    const active = this.active;
+    let id = str(block.id);
+    if (!id)
+      id = [...active.output.values()].find((item) => item.id.startsWith(`${messageId}:`) && item.status !== "completed" && (block.type === "text" ? item.type === "agentMessage" : block.type === "thinking" ? item.type === "reasoning" : false))?.id ?? `${messageId}:${active.blockIndex++}`;
+    const previous = active.output.get(id);
+    const item = this.blockItem(block, id, block.type === "text" || block.type === "tool_use");
+    if (subagent)
+      item.extensions = { ...item.extensions ?? {}, nativeParentTool: "subagent" };
+    active.output.set(id, item);
+    if (!previous)
+      await this.sink.emit({ type: "item/started", payload: { item: { ...item, status: "running" } } }, { turnId: active.id });
+    else if (block.type === "tool_use")
+      await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "patch", value: safe(item) } }, { turnId: active.id });
+    if (item.type !== "agentMessage" && block.type !== "tool_use")
+      await this.sink.emit({ type: "item/completed", payload: { item } }, { turnId: active.id });
+  }
+  async notice(value) {
+    const subtype = str(value.subtype) ?? str(value.type) ?? "unknown";
+    await this.sink.emit({ type: "notice", payload: { severity: /error|denied|retry|rate_limit/.test(subtype) ? "warning" : "info", code: `CLAUDE_${subtype.toUpperCase().replace(/[^A-Z0-9_]/g, "_")}`, message: str(value.content) ?? str(value.message) ?? subtype, raw: safe(value) } }, this.active ? { turnId: this.active.id } : {});
+  }
+  async permissionRequest(toolName, input, details) {
+    const turnId = this.active?.id;
+    if (!turnId)
+      return { behavior: "deny", message: "No active AHP turn" };
+    const interactionId = details.toolUseID;
+    const rawQuestions = Array.isArray(input.questions) ? input.questions.map(record2) : [];
+    const questionMode = toolName === "AskUserQuestion" && rawQuestions.length > 0 && rawQuestions.every((question) => typeof question.question === "string");
+    const request = questionMode ? { interactionId, kind: "userInput", turnId, itemId: details.toolUseID, questions: rawQuestions.map((question, index) => ({ id: `q${index}`, prompt: str(question.question), ...Array.isArray(question.options) ? { options: question.options.map((option) => ({ id: str(record2(option).label) ?? String(option), label: str(record2(option).label) ?? String(option) })) } : {}, ...question.secret === true ? { secret: true } : {} })) } : { interactionId, kind: "approval", turnId, itemId: details.toolUseID, title: details.title ?? toolName, input: safe(input), options: [{ id: "allow-once", label: "Allow once", semantic: "allowOnce" }, ...details.suggestions?.some((entry) => entry.destination === "session") ? [{ id: "allow-session", label: "Allow for this session", semantic: "allowSession" }] : [], { id: "deny", label: "Deny", semantic: "deny" }] };
+    return new Promise((resolve) => {
+      let answered = false;
+      const finish = (result) => {
+        if (!answered) {
+          answered = true;
+          details.signal.removeEventListener("abort", abort);
+          resolve(result);
+        }
+      };
+      const abort = () => {
+        this.sink.resolveInteraction({ interactionId, outcome: "expired", reason: "native_cancelled" });
+        finish({ behavior: "deny", message: "Request cancelled" });
+      };
+      details.signal.addEventListener("abort", abort, { once: true });
+      this.sink.requestInteraction(request, async (answer) => {
+        const stopped = !answer ? "interrupted" : answer.kind === "approval" && answer.optionId === "deny" ? "declined" : undefined;
+        if (stopped && this.active?.id === turnId) {
+          this.active.stoppedTools.set(details.toolUseID, stopped);
+          const previous = this.active.output.get(details.toolUseID);
+          if (previous?.type === "toolCall") {
+            const item = { ...previous, status: stopped };
+            this.active.output.set(item.id, item);
+            await this.sink.emit({ type: "item/delta", payload: { itemId: item.id, kind: "patch", value: safe(item) } }, { turnId });
+          }
+        }
+        if (!answer)
+          finish({ behavior: "deny", message: "Request cancelled" });
+        else if (answer.kind === "approval")
+          finish(answer.optionId === "deny" ? { behavior: "deny", message: "User denied tool execution" } : { behavior: "allow", updatedInput: input, ...answer.optionId === "allow-session" ? { updatedPermissions: details.suggestions?.filter((entry) => entry.destination === "session") } : {} });
+        else if (answer.kind === "userInput")
+          finish({ behavior: "allow", updatedInput: { ...input, answers: Object.fromEntries(rawQuestions.map((question, index) => [str(question.question), answer.answers[`q${index}`]])) } });
+        else
+          finish({ behavior: "deny", message: "Invalid response" });
+      }).catch(() => finish({ behavior: "deny", message: "Interaction unavailable" }));
+    });
+  }
+  async elicitationRequest(request, details) {
+    const interactionId = details.requestId;
+    const ahp = { interactionId, kind: "elicitation", mode: request.mode ?? "form", ...this.active ? { turnId: this.active.id } : {}, message: request.message, ...request.requestedSchema ? { schema: json(request.requestedSchema) } : {}, ...request.url ? { privatePayload: { url: request.url }, privatePayloadAvailable: true } : {} };
+    return new Promise((resolve) => {
+      let answered = false;
+      const finish = (value) => {
+        if (!answered) {
+          answered = true;
+          details.signal.removeEventListener("abort", abort);
+          resolve(value);
+        }
+      };
+      const abort = () => {
+        this.sink.resolveInteraction({ interactionId, outcome: "expired", reason: "native_cancelled" });
+        finish({ action: "cancel" });
+      };
+      details.signal.addEventListener("abort", abort, { once: true });
+      this.sink.requestInteraction(ahp, async (answer) => finish(answer?.kind === "elicitation" ? { action: answer.action, ...answer.content ? { content: elicitationContent(answer.content) } : {} } : { action: "cancel" })).catch(() => finish({ action: "cancel" }));
+    });
+  }
+  async messages(nativeId = this.nativeId) {
+    const store = this.adapter.sessionStore;
+    if (!store)
+      throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+    const scoped = {
+      append: store.append.bind(store),
+      load: async (key) => {
+        if (key.sessionId === nativeId && !key.subpath)
+          this.storeKeys.set(nativeId, key);
+        return store.load(key);
+      },
+      ...store.listSessions ? { listSessions: store.listSessions.bind(store) } : {},
+      ...store.listSubkeys ? { listSubkeys: store.listSubkeys.bind(store) } : {}
+    };
+    return (this.adapter.options.getSessionMessages ?? getSessionMessages)(nativeId, { dir: this.params.cwd, sessionStore: scoped, includeSystemMessages: true });
+  }
+  async boundaryPoint(nativeId, boundary) {
+    if (!this.adapter.sessionStore) {
+      const promptUuid = boundary.nativeTurnId ?? Object.entries(this.turns).find(([, turn]) => turn === boundary.turnId)?.[0];
+      if (!promptUuid)
+        throw new HarnessSdkError2("TURN_NOT_FOUND");
+      const prompts = Object.keys(this.turns);
+      const index = prompts.indexOf(promptUuid);
+      return { promptUuid, ...index >= 0 && prompts[index + 1] ? { nextPromptUuid: prompts[index + 1] } : {} };
+    }
+    const messages = await this.messages(nativeId);
+    const turns = this.fileStore ? await this.fileStore.loadTurnMap(nativeId) : this.adapter.turnMaps.get(nativeId) ?? this.turns;
+    const promptUuid = boundary.nativeTurnId ?? Object.entries(turns).find(([, id]) => id === boundary.turnId)?.[0];
+    if (!promptUuid)
+      throw new HarnessSdkError2("TURN_NOT_FOUND", "No verified native turn boundary");
+    const index = messages.findIndex((message) => message.uuid === promptUuid && isPrompt(message));
+    if (index < 0)
+      throw new HarnessSdkError2("TURN_NOT_FOUND");
+    const next = messages.findIndex((message, position) => position > index && isPrompt(message));
+    let uuid = boundary.relation === "before" ? index > 0 ? messages[index - 1].uuid : undefined : messages[(next >= 0 ? next : messages.length) - 1].uuid;
+    const key = this.storeKeys.get(nativeId);
+    if (boundary.relation === "through" && key) {
+      const entries = await this.adapter.sessionStore.load(key);
+      if (entries) {
+        const start = entries.findIndex((entry) => entry.uuid === promptUuid);
+        const end = next >= 0 ? entries.findIndex((entry) => entry.uuid === messages[next].uuid) : entries.length;
+        if (start < 0 || end < start)
+          throw new HarnessSdkError2("TURN_NOT_FOUND");
+        const last = entries.slice(start, end).reverse().find((entry) => typeof entry.uuid === "string");
+        if (last?.uuid)
+          uuid = last.uuid;
+      }
+    }
+    return { promptUuid, ...next >= 0 ? { nextPromptUuid: messages[next].uuid } : {}, ...uuid ? { uuid } : {} };
+  }
+  async execute(method, params) {
+    if (this.closed || !this.query)
+      throw new HarnessSdkError2("SESSION_CLOSED");
+    let result;
+    switch (method) {
+      case "turn/start": {
+        const start = params;
+        if (this.active)
+          throw new HarnessSdkError2("SESSION_BUSY");
+        const userUuid = randomUUID2();
+        const message = { type: "user", uuid: userUuid, session_id: this.nativeId, message: { role: "user", content: content(start.input) }, parent_tool_use_id: null };
+        this.active = { id: start.turnId, userUuid, interrupted: false, output: new Map, stoppedTools: new Map, blockIndex: 0 };
+        this.turns[userUuid] = start.turnId;
+        this.adapter.turnMaps.set(this.nativeId, this.turns);
+        await this.fileStore?.saveTurnMap(this.nativeId, this.turns);
+        await this.sink.emit({ type: "turn/started", payload: { turnId: start.turnId, nativeTurnId: userUuid } });
+        this.input.push(message);
+        result = { accepted: true, turnId: start.turnId };
+        break;
+      }
+      case "turn/interrupt": {
+        const request = params;
+        if (this.active?.id !== request.turnId)
+          throw new HarnessSdkError2("TURN_MISMATCH");
+        this.active.interrupted = true;
+        await this.query.interrupt();
+        result = { accepted: true, turnId: request.turnId };
+        break;
+      }
+      case "turn/steer":
+        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "Claude queued input is not current-turn steering");
+      case "session/config/set": {
+        const patch = params.patch;
+        try {
+          if (patch.model !== undefined) {
+            if (typeof patch.model !== "string")
+              throw new HarnessSdkError2("INVALID_PARAMS");
+            await this.query.setModel(patch.model);
+            this.model = patch.model;
+          }
+          if (patch.permissionMode !== undefined)
+            await this.query.setPermissionMode(permission(patch.permissionMode));
+          if (patch.fastMode !== undefined) {
+            if (typeof patch.fastMode !== "boolean")
+              throw new HarnessSdkError2("INVALID_PARAMS");
+            await this.query.applyFlagSettings({ fastMode: patch.fastMode });
+          }
+          if (patch.effort !== undefined) {
+            if (patch.effort !== null && !isEffort(patch.effort))
+              throw new HarnessSdkError2("INVALID_PARAMS");
+            await this.query.applyFlagSettings({ effortLevel: patch.effort });
+          }
+          if (patch.maxThinkingTokens !== undefined) {
+            if (patch.maxThinkingTokens !== null && typeof patch.maxThinkingTokens !== "number")
+              throw new HarnessSdkError2("INVALID_PARAMS");
+            await this.query.setMaxThinkingTokens(patch.maxThinkingTokens);
+          }
+        } catch (cause) {
+          throw sdkError(cause, "CLAUDE_CONFIG_FAILED", true);
+        }
+        this.config = { ...this.config, ...patch };
+        this.capabilityRevision++;
+        result = this.snapshot();
+        await this.sink.emit({ type: "session/state", payload: result });
+        break;
+      }
+      case "history/read": {
+        const request = params;
+        result = await this.readHistory(request);
+        break;
+      }
+      case "session/revert": {
+        const request = params;
+        const point = await this.boundaryPoint(this.nativeId, request.boundary);
+        let appliedFiles = false;
+        if (request.scope === "files" || request.scope === "both") {
+          if (!this.adapter.options.enableFileCheckpointing)
+            throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+          const checkpoint = request.boundary.relation === "before" ? point.promptUuid : point.nextPromptUuid;
+          if (!checkpoint)
+            throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED", "No verified post-turn checkpoint exists");
+          const preview = await this.query.rewindFiles(checkpoint, { dryRun: true });
+          if (!preview.canRewind)
+            throw new HarnessSdkError2("CHECKPOINT_UNAVAILABLE");
+          const rewound = await this.query.rewindFiles(checkpoint);
+          if (!rewound.canRewind || rewound.skippedLinks)
+            throw new HarnessSdkError2("REVERT_PARTIAL", "Some files could not be restored", false, true, { appliedScope: "files" });
+          appliedFiles = true;
+        }
+        if (request.scope !== "files") {
+          try {
+            const native = point.uuid ? await (this.adapter.options.forkSession ?? forkSession)(this.nativeId, { dir: this.params.cwd, sessionStore: this.adapter.sessionStore, upToMessageId: point.uuid }) : { sessionId: randomUUID2() };
+            this.generation++;
+            this.input?.end();
+            this.query.close();
+            this.binding = { ...this.binding, nativeRef: { provider: "claude", value: native.sessionId } };
+            this.adapter.turnMaps.set(this.nativeId, this.turns);
+            await this.fileStore?.saveTurnMap(this.nativeId, this.turns);
+            await this.startQuery(!point.uuid);
+            await this.sink.emit({ type: "session/state", payload: this.snapshot() });
+          } catch (cause) {
+            if (appliedFiles)
+              throw new HarnessSdkError2("REVERT_PARTIAL", "Files were restored but conversation restore could not be confirmed", false, true, { appliedScope: "files" });
+            throw cause;
+          }
+        }
+        result = { appliedScope: request.scope, boundary: request.boundary, nativeRef: this.binding.nativeRef };
+        break;
+      }
+      case "session/close":
+        await this.dispose();
+        result = { closed: true };
+        break;
+      default:
+        throw new HarnessSdkError2("CAPABILITY_UNSUPPORTED");
+    }
+    return result;
+  }
+  async readHistory(request) {
+    let snapshotToken = request.snapshotToken;
+    if (!snapshotToken) {
+      const messages = await this.messages();
+      const items = [];
+      let currentTurn = "native:session";
+      let currentNativeTurn;
+      const blockCounts = new Map;
+      for (const message of messages) {
+        if (isPrompt(message)) {
+          currentTurn = this.turns[message.uuid] ?? `native:${message.uuid}`;
+          currentNativeTurn = message.uuid;
+        }
+        const body = record2(message.message).content;
+        const blocks = typeof body === "string" ? [{ type: "text", text: body }] : Array.isArray(body) ? body.map(record2) : [];
+        if (message.type === "user" && isPrompt(message))
+          items.push({ turnId: currentTurn, nativeTurnId: message.uuid, nativeItemId: message.uuid, item: { id: message.uuid, type: "userMessage", content: blocks.filter((block) => block.type === "text").map((block) => ({ type: "text", text: str(block.text) ?? "" })), status: "completed" } });
+        else
+          for (let index = 0;index < blocks.length; index++) {
+            const block = blocks[index];
+            if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+              let previous;
+              for (let position = items.length - 1;position >= 0; position--) {
+                const candidate = items[position];
+                if (candidate.turnId === currentTurn && candidate.item.id === block.tool_use_id && candidate.item.type === "toolCall") {
+                  previous = candidate;
+                  break;
+                }
+              }
+              if (previous?.item.type === "toolCall") {
+                previous.item = completeClaudeTool(previous.item, { ...block, content: safe(block.content), ...record2(message).tool_use_result !== undefined ? { structuredContent: safe(record2(message).tool_use_result) } : {} });
+                continue;
+              }
+            }
+            const apiMessageId = str(record2(message.message).id);
+            const blockIndex = apiMessageId ? blockCounts.get(apiMessageId) ?? 0 : index;
+            if (apiMessageId)
+              blockCounts.set(apiMessageId, blockIndex + 1);
+            const item = this.blockItem(block, str(block.id) ?? `${apiMessageId ?? message.uuid}:${blockIndex}`, block.type === "tool_use");
+            if (block.type === "tool_use")
+              delete item.status;
+            items.push({ turnId: currentTurn, ...currentNativeTurn ? { nativeTurnId: currentNativeTurn } : {}, nativeItemId: message.uuid, item });
+          }
+      }
+      snapshotToken = randomUUID2();
+      this.historySnapshots.set(snapshotToken, items);
+      if (this.historySnapshots.size > 8)
+        this.historySnapshots.delete(this.historySnapshots.keys().next().value);
+    }
+    const snapshot = this.historySnapshots.get(snapshotToken);
+    if (!snapshot)
+      throw new HarnessSdkError2("CURSOR_EXPIRED");
+    const offset = request.cursor === undefined ? 0 : Number(request.cursor);
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset > snapshot.length)
+      throw new HarnessSdkError2("CURSOR_INVALID");
+    const limit = Math.min(request.limit ?? 200, 1000);
+    const page = snapshot.slice(offset, offset + limit);
+    return { items: structuredClone(page), ...offset + page.length < snapshot.length ? { nextCursor: String(offset + page.length) } : {}, snapshotToken, source: this.binding.nativeRef };
+  }
+  async dispose() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.generation++;
+    this.input?.end();
+    this.query?.close();
+    await this.query?.return?.();
+  }
+}
+function createClaudeAdapter(options) {
+  return new ClaudeNativeAdapter(options);
+}
+export {
+  ClaudeBackendSession,
+  ClaudeNativeAdapter,
+  FileSessionStore,
+  createClaudeAdapter
+};