@anureo/adapter-claude 0.2.0 → 0.3.0

package/README.md

@@ -2,26 +2,35 @@
 
 Adapter connecting the Anureo SDK to the official [`@anthropic-ai/claude-agent-sdk`](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). It drives the Claude SDK's streaming `query()` interface and maps messages, permissions, tool use, and subagents onto the unified AHP session model.
 
-> Part of the [Anureo SDK workspace](../../README.md). Install with `npm install @anureo/adapter-claude`.
+> Part of the [Anureo SDK workspace](../../../README.md). Install with `npm install @anureo/adapter-claude`.
 
 ## Usage
 
+This example uses the revised workspace API described under [Capabilities](#capabilities).
+
 ```typescript
-import { createHarnessRuntime } from '@anureo/sdk'
+import { createClient } from '@anureo/sdk'
 import { createClaudeAdapter } from '@anureo/adapter-claude'
 
-const runtime = createHarnessRuntime(createClaudeAdapter({
-  // Claude must run under an isolated, explicit CLAUDE_CONFIG_DIR…
-  stateDir: '/var/my-host/claude-state',
-  // …or deliberately reuse the CLI's login/profile home:
-  // defaultHome: true,
-}))
+const client = await createClient({
+  adapter: createClaudeAdapter({
+    // Claude must run under an isolated, explicit CLAUDE_CONFIG_DIR…
+    stateDir: '/var/my-host/claude-state',
+    // …or deliberately reuse the CLI's login/profile home:
+    // defaultHome: true,
+  }),
+  identity: { adapterId: 'claude', runtimeConfigId: 'local' },
+})
+// Use client.sessions.create(...) and session.submit(...); dispose in finally.
 ```
 
 Initialization fails with `HARNESS_CONFIG_INVALID` unless one of `stateDir` (or `env.CLAUDE_CONFIG_DIR`), `defaultHome`, or an injected `queryFactory` is provided — accidental reuse of a user's default Claude home is never silent.
 
 ## Capabilities
 
+The revised workspace API shown here differs from the published 0.2.0 API.
+The adapter pins `@anthropic-ai/claude-agent-sdk` to 0.3.265.
+
 What the adapter can offer depends on the options it was constructed with:
 
 | Condition | Unlocks |
@@ -29,7 +38,78 @@ What the adapter can offer depends on the options it was constructed with:
 | A session store is present (`stateDir`, or injected `sessionStore`) | `session.resume`, fork (`before`/`through`), `revert: conversation`, `history` |
 | `enableFileCheckpointing: true` | `revert: files` (and `both` together with a store), backed by the SDK's checkpoint/rewind support |
 
-Always available: `turn.interrupt`, `approval` / `userInput` / `elicitation` interactions, nested subagent events, and MCP (stdio + http, with `form`/`url` elicitation). Steer and output schemas are not offered because the Claude SDK does not support them.
+Revert requires no active execution or pending input. Those cases, and input,
+configuration changes or another revert attempted during a revert, reject with
+`SESSION_BUSY`. Finish or interrupt the current execution and await its terminal
+result before reverting.
+
+The revised workspace exposes native input delivery (`native` → `next`,
+`afterTurn` → `later`) and **session-scoped** interrupt with pending-input receipts.
+Exact-turn steer and interrupt are not declared. It also supports `approval` / `userInput` / `elicitation` interactions, nested subagent events, MCP (stdio + http, with `form`/`url` elicitation), and `turn.outputSchema`.
+
+Validation covers two layers:
+
+- Injected Query fixtures exercise native input priority mapping, multi-message
+  correlation, and session interrupt mapping, including pending-input receipts.
+- Transport tests run the pinned official SDK against a simulated child executable
+  to check single-input correlation.
+
+Validation of native input priority, multi-message correlation, and interruption
+behavior with real Claude execution remains unconfirmed by these tests.
+
+Additional guidance uses another `await session.submit({ input, delivery: 'native' })`.
+It may join the same execution or reach a later one. Session input delivery is
+distinct from atomic exact-turn steering. See the
+[Claude example](../../../docs/native-harness-lifecycle.md#42-claude追加会话指导与精确-steer-分开).
+
+## Structured output
+
+Pass a self-contained draft-07 JSON Schema with `type: 'object'` at its root:
+
+```typescript
+const turn = await session.submit({
+  input: 'Return the number of matching files.',
+  outputSchema: {
+    type: 'object',
+    properties: { count: { type: 'integer', minimum: 0 } },
+    required: ['count'],
+    additionalProperties: false,
+  },
+})
+const result = await turn.result()
+if (result.status === 'completed') {
+  const data = JSON.parse(result.text)
+  console.log(data.count)
+}
+```
+
+The adapter passes the schema to the official Agent SDK's `outputFormat` option.
+The SDK handles tool use, output validation and correction attempts. The adapter
+validates the returned `structured_output` with draft-07 AJV and publishes its
+JSON serialization as the final `agentMessage` and `TurnResult.text`. Intermediate
+prose remains commentary. `format` annotations are accepted without enforcement;
+asynchronous schemas, external references and newer schema dialects are rejected
+with `INVALID_PARAMS` before input dispatch.
+
+The pinned SDK sets output format at Query initialization. Equal schemas (object
+key order does not matter) reuse the existing Query, including native overlapping
+input. Changing or omitting the schema closes and drains that Query, then starts
+another with the same native session ID and the latest session configuration.
+After an execution, the new Query resumes the saved conversation. This adds
+process startup cost when switching formats. A switch requires no active execution,
+pending inputs or configuration changes; otherwise it rejects with `SESSION_BUSY`,
+including for `delivery: 'afterTurn'`. Omit `outputSchema` to return to ordinary text;
+the previous schema is never implicitly inherited. Input and configuration changes
+are also refused while a format switch is in progress.
+
+Missing or invalid structured output fails the turn with
+`CLAUDE_STRUCTURED_OUTPUT_MISSING` or `CLAUDE_STRUCTURED_OUTPUT_INVALID`.
+Native correction-limit exhaustion maps to
+`CLAUDE_STRUCTURED_OUTPUT_RETRIES_EXCEEDED`; interruption remains `interrupted`.
+The adapter never resubmits the task to repair output or recover a failed switch.
+When a session store is available, history also exposes saved structured-output
+attachments linked to surviving `StructuredOutput` calls, including after resume
+or fork. Reading these saved attachments does not rerun schema validation.
 
 ## Exports
 
@@ -47,6 +127,17 @@ Resume, fork, and history need the official `SessionStore` contract. `FileSessio
 
 `createClaudeCatalogSession(options)` opens a prompt-less connection to list supported models (including effort levels per model) without creating a product session; `adapter.listModels(cwd)` is the one-shot variant.
 
+## Code structure
+
+| Path | Responsibility |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Assembles the application factories, adapter types, store and catalog exports. |
+| [`src/adapter.ts`](src/adapter.ts) | Implements the native adapter and its backend sessions, including input, events and query lifecycle. `ClaudeBackendSession` remains exported for compatibility; the adapter constructs it. |
+| [`src/options.ts`](src/options.ts) | Defines host launch options and query-factory extension contracts shared with catalog discovery. Hosts supply these contracts; adapter and catalog operations invoke the factories and close their queries. |
+| [`src/catalog.ts`](src/catalog.ts) | Owns reusable prompt-less discovery queries and cancellation, sharing adapter launch options through `queryOptions()`. |
+| [`src/store.ts`](src/store.ts) | Implements the public opaque session store used for resume, fork and history. |
+| [`src/file-changes.ts`](src/file-changes.ts), [`src/output-schema.ts`](src/output-schema.ts), [`src/turn-error.ts`](src/turn-error.ts) | Project native file changes, validate structured output and classify terminal failures. |
+
 ## Configuration options
 
 Session-scoped config options exposed through AHP: `model`, `permissionMode` (`default` / `acceptEdits` / `bypassPermissions` / `plan` / `dontAsk` / `auto`), `effort` (`low`–`max`, per-model support reported by the catalog), `fastMode`, and `maxThinkingTokens`. Text and image inputs are supported.
@@ -56,12 +147,16 @@ For script-based Claude executables, `executableRuntime: 'node' | 'bun' | 'deno'
 ## Development
 
 ```sh
-cd packages/claude
+cd packages/adapter/claude
 bun run typecheck
 bun test src
 ```
 
 ## Documentation
 
-- [Architecture](../../docs/architecture.md) — adapters' role in the SDK (currently in Chinese)
-- [AHP v1 protocol](../../spec/ahp-v1.md)
+- [Architecture](../../../docs/architecture.md) — adapters' role in the SDK (currently in Chinese)
+- [AHP v1 protocol](../../../spec/ahp-v1.md)
+
+## AHP v1 lifecycle revision
+
+See the [design and implementation plan](../../../docs/native-harness-lifecycle.md).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anureo/adapter-claude",
-  "version": "0.2.0",
   "description": "Anureo SDK adapter for the official Claude Agent SDK",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "keywords": [
     "anureo",
@@ -15,7 +15,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/hi-youichi/anureo-sdk.git",
-    "directory": "packages/claude"
+    "directory": "packages/adapter/claude"
   },
   "bugs": {
     "url": "https://github.com/hi-youichi/anureo-sdk/issues"
@@ -26,35 +26,35 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
     },
     "./store": {
-      "types": "./dist/store.d.ts",
-      "import": "./dist/store.js",
-      "default": "./dist/store.js"
+      "types": "./src/store.d.ts",
+      "import": "./src/store.js",
+      "default": "./src/store.js"
     },
     "./catalog": {
-      "types": "./dist/catalog.d.ts",
-      "import": "./dist/catalog.js",
-      "default": "./dist/catalog.js"
+      "types": "./src/catalog.d.ts",
+      "import": "./src/catalog.js",
+      "default": "./src/catalog.js"
     }
   },
-  "files": [
-    "dist",
-    "schema",
-    "protocol",
-    "examples",
-    "README.md",
-    "LICENSE"
-  ],
   "dependencies": {
-    "@anureo/protocol": "0.2.0",
-    "@anureo/sdk": "0.2.0",
-    "@anthropic-ai/claude-agent-sdk": "0.3.257"
+    "@anthropic-ai/claude-agent-sdk": "0.3.265",
+    "@anureo/protocol": "0.3.0",
+    "@anureo/sdk": "0.3.0",
+    "ajv": "8.20.0"
   },
   "engines": {
     "node": ">=22"
-  }
+  },
+  "files": [
+    "src",
+    "bin",
+    "schema",
+    "protocol",
+    "examples"
+  ]
 }

package/src/adapter.d.ts

@@ -0,0 +1,253 @@
+import type { ClaudeAdapterOptions } from "./options.js";
+import { type Options, type Query, type SessionStore } from "@anthropic-ai/claude-agent-sdk";
+import { type BackendSession, type HarnessAdapter, type SessionEventSink, type SessionMethod } from "@anureo/sdk";
+import { type Capabilities, type AhpRequestMap, type AhpResultMap, type InitializeParams, type InitializeResult, type SessionBinding, type SessionOpenParams } from "@anureo/protocol";
+import { FileSessionStore } from "./store.js";
+/** Connect a client to Claude queries and retain ownership of opened backend sessions.
+ * createClient initializes and disposes this adapter through its output wrapper; direct consumers
+ * initialize before opening sessions and await disposal when finished. */
+export declare class ClaudeNativeAdapter implements HarnessAdapter {
+    /** Select the launch environment and store without starting Claude. stateDir takes precedence
+     * for adapter storage. With defaultHome enabled, an explicitly supplied CLAUDE_CONFIG_DIR is
+     * forwarded as supplied. */
+    constructor(options?: ClaudeAdapterOptions);
+    /** Report store/checkpoint-dependent support without native discovery or resource acquisition. */
+    get capabilities(): Capabilities;
+    /** Negotiate protocol support for Client.initialize through withStructuredOutput. Reject invalid
+     * negotiation, a disposed adapter, or an absent Claude home unless defaultHome or a query
+     * factory is supplied. Native launch is deferred to discovery or a session open. */
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    /** Open and retain a backend for OutputSession.open to attach. Await resume/fork setup, query
+     * construction and any resumed-title refresh. Native handshake and execution events arrive
+     * independently through the sink. Setup errors reject the open. The client disposes the backend
+     * it attaches, and adapter disposal also releases retained sessions. */
+    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<BackendSession>;
+    /** Read model metadata with a one-shot query using cwd, which defaults to process.cwd().
+     * The adapter supplies an empty input stream and closes the query after discovery. Startup,
+     * discovery and close failures reject, with a close failure taking precedence over discovery. */
+    listModels(cwd?: string): Promise<Awaited<ReturnType<Query["supportedModels"]>>>;
+    /** Build native launch options for internal use without starting a query. listModels uses them
+     * directly. ClaudeBackendSession.sessionQueryOptions and createClaudeCatalogSession's openConnection
+     * add their own options. The operation that starts the query owns its cleanup. */
+    queryOptions(cwd: string): Options;
+    /** Release retained sessions. Await all attempts and reject with the first cleanup failure in
+     * registry order. Once disposal starts, subsequent calls resolve independently of that cleanup. */
+    dispose(): Promise<void>;
+    /** Retained launch/extension configuration used by later queries; avoid mutating it during work. */
+    readonly options: ClaudeAdapterOptions;
+    /** Selected native store, shared with sessions; an injected store keeps its host-owned lifecycle. */
+    readonly sessionStore?: SessionStore;
+    /** Native launch environment; may contain credentials and is not a safe diagnostic projection. */
+    readonly env: Record<string, string | undefined>;
+    private readonly sessions;
+    /** Internal map from native session ID to the input UUIDs verified against SDK turns.
+     * Backend sessions reuse it across in-memory resume and copy it for forks. */
+    readonly turnMaps: Map<string, Record<string, string>>;
+    private readonly defaultStore?;
+    private disposed;
+}
+/** Adapter-internal BackendSession implementation retained in the root export for compatibility.
+ * ClaudeNativeAdapter.openSession constructs and opens it; OutputSession.execute forwards SDK
+ * requests and OutputSession.dispose awaits its cleanup on behalf of the client.
+ * Native receipt, execution association and terminal completion remain separate observations. */
+export declare class ClaudeBackendSession implements BackendSession {
+    private readonly adapter;
+    private readonly params;
+    private readonly sink;
+    private readonly fileStore?;
+    /** Prepare binding/configuration for ClaudeNativeAdapter.openSession without starting a query.
+     * Reject unsupported config keys or invalid values before native open. */
+    constructor(adapter: ClaudeNativeAdapter, params: SessionOpenParams, sink: SessionEventSink, fileStore?: FileSessionStore | undefined);
+    /** Resolve resume/fork state and start a query for ClaudeNativeAdapter.openSession. Store,
+     * boundary and query-setup failures reject before the adapter registers the backend. */
+    open(): Promise<void>;
+    /** Dispatch requests forwarded by OutputSession.execute. Submission returns after enqueueing
+     * native input. Association and terminal results arrive through the sink. Busy or unsupported
+     * operations and native failures reject. Close awaits query cleanup with execution stop unconfirmed. */
+    execute<M extends SessionMethod>(method: M, params: AhpRequestMap[M]): Promise<AhpResultMap[M]>;
+    /** Share query close/return completion between the close request and OutputSession.dispose.
+     * Stop input admission, clear pending associations and invalidate message observation immediately.
+     * Cleanup rejects on release failure and leaves native execution stop unconfirmed. */
+    dispose(): Promise<void>;
+    /** Current native session identity, updated by fork/revert and native initialization. */
+    binding: SessionBinding;
+    /** Store/checkpoint capability projection captured from the adapter at construction. */
+    readonly capabilities: Capabilities;
+    /** Enforce execute's query admission policy for operations other than history and close. */
+    private requireQuery;
+    /** Apply execute's configuration controls in order and publish state after all controls succeed.
+     * Earlier native effects, including model changes, survive a rejected patch. Keep output-format
+     * replacement blocked until the patch settles. Session.onRequestFailed enters recovery when
+     * the returned SDK error carries an unknown outcome. */
+    private setConfig;
+    private release?;
+    private readonly nativeInputs;
+    private query?;
+    private pumping?;
+    private readonly queryReleases;
+    private outputSchema?;
+    private switchingOutput;
+    private queryMode;
+    private queryResumeAt?;
+    private queryFailure?;
+    private configOperations;
+    private input?;
+    private active?;
+    private generation;
+    private closed;
+    private reverting;
+    private config;
+    private capabilityRevision;
+    private model?;
+    private turns;
+    private historySnapshots;
+    /** Native fast-mode outcome as the CLI reports it (the setting may be on but not in effect). */
+    private fastMode?;
+    private storeKeys;
+    private sessionTitle?;
+    private metadataTail;
+    private metadataPending?;
+    /** Wrap startQuery's store so successful main-session appends schedule title refreshes.
+     * Forward store failures unchanged and ignore appends from replaced queries; metadata refresh runs
+     * independently so title reads cannot reject a committed append. Store lifecycle stays host-owned. */
+    private observedStore;
+    /** Coalesce title reads for observedStore, startQuery and completeTurn. startQuery awaits the
+     * refresh on resume, while append and terminal publication proceed independently. Ignore stale
+     * reads after replacement or close and report read failures with a best-effort warning. */
+    private refreshMetadata;
+    private get nativeId();
+    /** Let open choose a fresh query for an empty fork. A history read failure rejects open. */
+    private hasHistory;
+    /** Copy the source transcript through a verified cutoff for open or restoreConversation.
+     * The caller installs the returned session ID. Native copy failures reject that phase. */
+    private forkTranscript;
+    /** Open, association, init and conversation restore update the in-memory map before awaiting
+     * its optional disk copy. Save failure rejects the caller without undoing the map update. */
+    private rememberTurnMap;
+    /** Accept native init/result fast-mode states and report whether the public snapshot changed. */
+    private trackFastMode;
+    /** Clone binding and config for state publications during initialization, configuration,
+     * completion and conversation restore. Report running while an execution occupies the active slot. */
+    private snapshot;
+    /** Construct a generation-specific query for open, restoreConversation or replaceOutputFormat,
+     * then start background pumping and await resumed-title refresh. Fresh mode opens the current native
+     * ID as a new session; resume mode reopens its transcript, optionally at resumeAt. Factory/setup
+     * failures reject here; subsequent source failures are reported to the sink by pump. */
+    private startQuery;
+    /** Project the session and generation into launch options for startQuery. Native tool callbacks
+     * are invoked by the SDK. The observed store schedules title refreshes only for this generation. */
+    private sessionQueryOptions;
+    /** Consume the query started by startQuery until closure/generation replacement. Fail SDK
+     * observation on source errors or early EOF with pending work; never replay native input. */
+    private pump;
+    /** Return the active execution to associateInputs. Allocate and publish it on the first native
+     * execution evidence from associateInputs or permissionRequest. Starting work also makes later
+     * schema replacements resume the native transcript. Publication failure rejects to the caller. */
+    private beginExecution;
+    /** Route pump messages after processing native input refusal or association evidence. Bind
+     * inputs before projecting the associated reply. Sink and store failures reject back to pump. */
+    private mapMessage;
+    /** Complete live tool calls from matching native user-message results. mapMessage awaits
+     * publication to keep these effects ordered before later native messages. */
+    private publishToolResults;
+    /** Map native task updates to an item's start, patch or terminal event. mapMessage awaits
+     * publication, falling back to a notice when the native task identity is missing. */
+    private publishTask;
+    /** Give hook progress a start event when the hook was previously unseen. mapMessage awaits
+     * publication before consuming another message, including when a missing hook ID emits a notice. */
+    private publishHook;
+    /** Publish mapMessage's native refusal/no-execution evidence before removing a pending input.
+     * Unknown UUIDs are ignored; publication failure leaves the input retained and rejects into pump. */
+    private rejectInput;
+    /** Bind mapMessage's echoed UUIDs to the current execution and persist the verified map.
+     * Native evidence can add inputs to an existing execution, but cannot move a bound input to a
+     * different execution. Binding or store failures reject and are reported by pump. */
+    private associateInputs;
+    /** Finish mapMessage's captured execution. Validate final output, publish items and usage, then
+     * clear consumed input IDs before the terminal and ready-state events. Uncorrelated inputs stay
+     * pending. A sink failure rejects into pump. */
+    private completeTurn;
+    /** Classify native termination and validate structured output before completeTurn publishes
+     * any final item. Missing or invalid output becomes a terminal error. An interruption bypasses
+     * schema validation and retains precedence in the terminal event. */
+    private terminalOutput;
+    /** Update the active turn from streamed content, publishing starts/deltas before final blocks.
+     * mapMessage calls only with an active turn; sink rejection propagates to the query pump. */
+    private streamEvent;
+    /** Project a live/history content block to a public item, preserving unknown native content safely. */
+    private blockItem;
+    /** Reconcile completeBlock with unfinished text/thinking streams before allocating a fallback ID.
+     * Mutates the turn's fallback counter only when no native or unfinished-stream identity exists. */
+    private resolveCompleteBlockId;
+    /** Merge a complete assistant block into active output and publish its start/patch/completion.
+     * Text and tool calls stay pending until native result/tool evidence; sink failures reach pump. */
+    private completeBlock;
+    /** Publish otherwise unmapped native messages through the sink with privacy-safe raw content. */
+    private notice;
+    /** Native canUseTool callback supplied by sessionQueryOptions. Await SDK approval/user answers or
+     * native cancellation, translating unavailable interactions to denial and removing the abort listener.
+     * Session and InteractionRegistry invoke the registered responder for answers or cancellation.
+     * Execution-start publication failures reject this native callback before interaction registration. */
+    private permissionRequest;
+    /** Build stable qN question identities for permissionRequest so answers map back to native text. */
+    private createUserQuestionRequest;
+    /** Offer session approval to permissionRequest only when the native callback supplied a
+     * session-scoped permission update it can return. */
+    private createToolApprovalRequest;
+    /** Native onElicitation callback supplied by sessionQueryOptions. Await a sink-delivered answer
+     * or native abort. The answer can reach Claude before the sink publishes interaction/resolved.
+     * Unrepresentable form content rejects responder delivery. Native abort or a rejected sink wait
+     * returns cancellation. */
+    private elicitationRequest;
+    /** Register the responder for permissionRequest and elicitationRequest. Resolve the native
+     * wait once and remove its abort listener. Native abort reports expiry to the sink without
+     * awaiting publication. A rejected sink wait supplies the operation's fallback response. */
+    private awaitInteraction;
+    /** Read native history for boundary/history callers through the supplied public store. Capture
+     * the SDK-derived store key for opaque attachment reads; reject absent stores and read failures. */
+    private messages;
+    /** Resolve the checkpoint and transcript cutoff for open and revert. Without a store, use
+     * native prompt IDs or known associations for file checkpoints. With a store, verify the prompt
+     * in history and include opaque trailing entries for through boundaries when available.
+     * Unknown boundaries and store failures reject the caller. */
+    private boundaryPoint;
+    /** Restore execute's requested file/conversation scope only while idle. Drain the old query
+     * before replacement. Hold admission across lookup and cleanup, releasing it on any outcome.
+     * Failed conversation restoration after file rewind rejects with REVERT_PARTIAL and appliedScope. */
+    private revert;
+    /** Revert's file phase verifies a checkpoint with a dry run before applying it. Recheck close
+     * after preview; a failed/partial native rewind rejects without attempting conversation restore. */
+    private restoreFiles;
+    /** Revert's conversation phase forks at the verified cutoff, drains the old query, then publishes
+     * the replacement binding/state. Recheck close after native waits so disposal cannot reopen work;
+     * revert translates failure to a REVERT_PARTIAL rejection when its file phase already applied. */
+    private restoreConversation;
+    /** Admit execute's bounded input and enqueue native content, returning a dispatch receipt.
+     * Changed schemas replace an idle query first; rejection never retries or replays the new input. */
+    private submitInput;
+    /** Drain and replace the query for submitInput before enqueueing its input. Reject startup or
+     * cleanup failure as a definite dispatch failure and latch it for later query operations while open. */
+    private replaceOutputFormat;
+    /** Invalidate the retired query's observation and end its input before release. Conversation
+     * restore and output replacement each await close/return and their own pump before reopening. */
+    private endQueryInput;
+    /** Share query close/return completion across replacement, revert and disposal. Attempt both
+     * stages and reject RESOURCE_RELEASE_FAILED with safe codes when either fails. */
+    private releaseQuery;
+    /** Build/reuse one of eight retained history snapshots for execute, then clone the requested page.
+     * A new snapshot projects native entries before loading structured-output attachments. Reject expired
+     * snapshots, invalid offsets or store failures; pagination reuses the snapshot without rereading it. */
+    private readHistory;
+    /** Reconstruct readHistory's live-compatible item IDs and tool results from ordered native entries.
+     * Keep grouping and per-API-message block counters local to this snapshot; tool results amend only
+     * an earlier call in the same turn, and unmatched results remain visible as unknown content. */
+    private projectHistory;
+    /** Add saved structured-output attachments only for tool calls surviving readHistory's transcript.
+     * Read the captured public-store key; missing keys leave history unchanged and load failures reject. */
+    private structuredHistory;
+}
+/** Construct the adapter supplied to createClient without opening Claude. The client initializes
+ * and disposes it through its output wrapper; direct adapter consumers initialize before session opens
+ * and await disposal after use. Options and injected store lifecycle remain host-owned. */
+export declare function createClaudeAdapter(options?: ClaudeAdapterOptions): ClaudeNativeAdapter;
+export { FileSessionStore } from "./store.js";