@nathapp/nax-agent 0.1.0 → 0.3.0

package/dist/native/credentials/change-guard.d.ts

@@ -16,14 +16,21 @@ import type { AuthStamp } from "#src/session/session-types";
 /**
  * Where a credential came from, as reported by `describe`. `AuthStamp` without
  * the fingerprint — the guard computes that itself from the credential.
+ * `memory` is a store held in process (a session's own credentials), distinct
+ * from the on-disk `file` and the `exec` helper.
  */
 export interface CredentialOrigin {
-    source: "file" | "exec";
+    source: "file" | "exec" | "memory";
     account?: string;
 }
 export interface ChangeGuardOptions {
     /** `warn` adopts the new identity and serves it; `refuse` throws instead. */
     onChange: CredentialAuthConfig["onChange"];
+    /**
+     * Fingerprint key. Absent = the machine salt file (today). A session store
+     * passes an in-memory salt, so its fingerprints never touch the slot.
+     */
+    readonly salt?: Buffer;
     /**
      * Where the credential read from `inner` came from. Called immediately after
      * each successful read, because the credential itself carries no provenance.

package/dist/native/credentials/change-guard.js

@@ -87,7 +87,7 @@ export function createChangeGuard(inner, options) {
         const described = options.describe(providerId);
         const identity = {
             kind: credential.kind,
-            fingerprint: await fingerprintCredential(credential),
+            fingerprint: await fingerprintCredential(credential, options.salt),
             source: described?.source ?? "file",
             ...(described?.account !== undefined ? { account: described.account } : {}),
         };

package/dist/native/credentials/fingerprint.d.ts

@@ -22,5 +22,8 @@ export declare function _resetFingerprintSalt(): void;
  * is fingerprinted as the template, because nax-ai documents `key` as opaque.
  * `oauth` fingerprints its `refresh` token, so access-token rotation is
  * invisible while refresh-token rotation is not.
+ *
+ * `salt` overrides the machine salt file: an in-process caller that keeps its own
+ * key (a session store) passes one, and a supplied salt never touches the slot.
  */
-export declare function fingerprintCredential(credential: StoredCredential): Promise<string>;
+export declare function fingerprintCredential(credential: StoredCredential, salt?: Buffer): Promise<string>;

package/dist/native/credentials/fingerprint.js

@@ -166,9 +166,12 @@ function identifyingSecret(credential) {
  * is fingerprinted as the template, because nax-ai documents `key` as opaque.
  * `oauth` fingerprints its `refresh` token, so access-token rotation is
  * invisible while refresh-token rotation is not.
+ *
+ * `salt` overrides the machine salt file: an in-process caller that keeps its own
+ * key (a session store) passes one, and a supplied salt never touches the slot.
  */
-export async function fingerprintCredential(credential) {
-    const salt = await resolveSalt();
+export async function fingerprintCredential(credential, salt) {
+    const key = salt ?? (await resolveSalt());
     const secret = identifyingSecret(credential);
-    return createHmac("sha256", salt).update(secret).digest("hex").slice(0, FINGERPRINT_CHARS);
+    return createHmac("sha256", key).update(secret).digest("hex").slice(0, FINGERPRINT_CHARS);
 }

package/dist/native/credentials/session-source.d.ts

@@ -0,0 +1,12 @@
+import { type StoredCredential } from "@nathapp/nax-ai";
+import { type GuardedCredentialStore } from "./change-guard.ts";
+export type CredentialSource = {
+    readonly kind: "memory";
+    readonly credentials: Readonly<Record<string, StoredCredential>>;
+} | {
+    readonly kind: "exec";
+    readonly command: readonly string[];
+    readonly timeoutMs?: number;
+    readonly onChange?: "warn" | "refuse";
+};
+export declare function createSessionCredentialStore(source: CredentialSource): GuardedCredentialStore;

package/dist/native/credentials/session-source.js

@@ -0,0 +1,33 @@
+/**
+ * A credential source owned by one session (S3 spec 5.2), instead of the
+ * process-wide store behind `configureCredentials`. It never reads the slot:
+ * the fingerprint salt is random per store, so an embedder that never called
+ * `configureCredentials` can still run a session and stamp its cost rows.
+ */
+import { randomBytes } from "node:crypto";
+import { createMemoryCredentialStore } from "@nathapp/nax-ai";
+import { createChangeGuard } from "./change-guard.js";
+import { createExecCredentialSource } from "./exec-source.js";
+const SALT_BYTES = 32;
+export function createSessionCredentialStore(source) {
+    const salt = randomBytes(SALT_BYTES);
+    if (source.kind === "memory") {
+        return createChangeGuard(createMemoryCredentialStore(source.credentials), {
+            onChange: "warn",
+            salt,
+            describe: () => ({ source: "memory" }),
+        });
+    }
+    const exec = createExecCredentialSource({
+        command: source.command,
+        ...(source.timeoutMs !== undefined ? { timeoutMs: source.timeoutMs } : {}),
+    });
+    return createChangeGuard(exec, {
+        onChange: source.onChange ?? "warn",
+        salt,
+        describe: (providerId) => {
+            const account = exec.accountOf(providerId);
+            return account === undefined ? { source: "exec" } : { source: "exec", account };
+        },
+    });
+}

package/dist/native/index.d.ts

@@ -19,7 +19,9 @@ export { credentialFilePath, naxCredentialStore, type StoredEntry, servedAuth }
 export { NativeSessionUnsupportedError } from "./errors.ts";
 export { type ResolveResult, type ResolveStatus, resolveNativeId, } from "./model-resolver.ts";
 export { NATIVE_AGENT } from "./models.ts";
-export { MAX_RETAINED_TRANSCRIPTS, pruneRetainedTranscripts, } from "./session/transcript-store.ts";
+export { createMemoryTranscriptStore, type MemoryTranscriptStore } from "./session/memory-transcript-store.ts";
+export { createFileTranscriptStore, MAX_RETAINED_TRANSCRIPTS, pruneRetainedTranscripts, } from "./session/transcript-store.ts";
+export type { TranscriptAcpRecord, TranscriptDoc, TranscriptStore, TurnMarker } from "./session/transcript-types.ts";
 export { NativeSessionAdapter } from "./session-adapter.ts";
 export { newSessionKey } from "./session-affinity.ts";
 export { type NativeTierConfig, nativeTierProviders } from "./tier-providers.ts";

package/dist/native/index.js

@@ -17,7 +17,8 @@ export { credentialFilePath, naxCredentialStore, servedAuth } from "./credential
 export { NativeSessionUnsupportedError } from "./errors.js";
 export { resolveNativeId, } from "./model-resolver.js";
 export { NATIVE_AGENT } from "./models.js";
-export { MAX_RETAINED_TRANSCRIPTS, pruneRetainedTranscripts, } from "./session/transcript-store.js";
+export { createMemoryTranscriptStore } from "./session/memory-transcript-store.js";
+export { createFileTranscriptStore, MAX_RETAINED_TRANSCRIPTS, pruneRetainedTranscripts, } from "./session/transcript-store.js";
 export { NativeSessionAdapter } from "./session-adapter.js";
 export { newSessionKey } from "./session-affinity.js";
 export { nativeTierProviders } from "./tier-providers.js";

package/dist/native/session/loop-events/types.d.ts

@@ -159,7 +159,7 @@ export interface BeforeCompactionPatch {
     /** A replacement summary, skipping the summarizer call. */
     readonly summary?: string;
 }
-/** `before_turn_end` — fires before the final saveTranscript. */
+/** `before_turn_end` — fires before the turn-end transcript save. */
 export interface BeforeTurnEndPayload {
     readonly messages: readonly NativeTranscriptMessage[];
     readonly roundTrips: number;

package/dist/native/session/loop-handlers.d.ts

@@ -33,6 +33,7 @@
 import { type SpinBreaker } from "#src/infra/spin-breaker/index";
 import { type InvalidCallBudget } from "./handle-invalid-tool-call.ts";
 import { type LoopEventRegistry, type LoopHandlerContext, type LoopHandlerSet } from "./loop-events/index.ts";
+import type { NativeSessionState } from "./session.ts";
 export interface BuiltinLoopHandlerDeps {
     /**
      * The session the handlers run for. Truncation resolves its spill root
@@ -40,6 +41,8 @@ export interface BuiltinLoopHandlerDeps {
      * per-turn dep, so a repointed registry never keeps a stale session.
      */
     readonly sessionName: string;
+    /** The owning adapter's per-session state, read through `state.current` at dispatch like the session name. */
+    readonly sessionState: NativeSessionState;
     /** Per-turn invalid-call budget. The loop reads `exceeded` for the halt. */
     readonly budget: InvalidCallBudget;
     /** Absent disables the breaker, exactly as `TurnDeps.spinBreaker` does. */

package/dist/native/session/loop-handlers.js

@@ -96,7 +96,7 @@ export function registerBuiltinLoopHandlers(registry, deps) {
     // whatever the handlers produced. The handler is rebuilt per dispatch so the
     // session name is read through `state.current` — the same lifetime the other
     // per-turn deps use — rather than frozen at install time.
-    registry.register("after_tool", (payload) => createTruncationHandler(state.current.sessionName)(payload));
+    registry.register("after_tool", (payload) => createTruncationHandler(state.current.sessionState, state.current.sessionName)(payload));
 }
 function repairInvalidCall(state, call, tools) {
     const invalid = state.current.budget.observe(call, tools);

package/dist/native/session/memory-transcript-store.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An in-process `TranscriptStore` for tests and simple embedders (S3 spec 5.5).
+ * Every document crossing the boundary is copied, so a caller mutating what it
+ * saved or loaded cannot rewrite stored history. History is lost with the
+ * process; an embedder that must resume after a restart injects a durable store.
+ */
+import type { TranscriptDoc, TranscriptStore } from "./transcript-types.ts";
+export interface MemoryTranscriptStore extends TranscriptStore {
+    /** The last document `retainFailed` moved aside for `sessionId`, if any. */
+    retained(sessionId: string): TranscriptDoc | undefined;
+}
+export declare function createMemoryTranscriptStore(): MemoryTranscriptStore;

package/dist/native/session/memory-transcript-store.js

@@ -0,0 +1,36 @@
+/**
+ * An in-process `TranscriptStore` for tests and simple embedders (S3 spec 5.5).
+ * Every document crossing the boundary is copied, so a caller mutating what it
+ * saved or loaded cannot rewrite stored history. History is lost with the
+ * process; an embedder that must resume after a restart injects a durable store.
+ */
+export function createMemoryTranscriptStore() {
+    const live = new Map();
+    const failed = new Map();
+    const copy = (doc) => doc === undefined ? undefined : structuredClone(doc);
+    return {
+        load: (sessionId) => Promise.resolve(copy(live.get(sessionId)) ?? null),
+        save: (sessionId, doc) => {
+            live.set(sessionId, structuredClone(doc));
+            return Promise.resolve();
+        },
+        retainFailed: (sessionId) => {
+            const doc = live.get(sessionId);
+            if (doc !== undefined) {
+                failed.set(sessionId, doc);
+                live.delete(sessionId);
+            }
+            return Promise.resolve();
+        },
+        delete: (sessionId) => {
+            live.delete(sessionId);
+            return Promise.resolve();
+        },
+        markTurn: (sessionId, marker) => {
+            const base = live.get(sessionId) ?? { savedAt: new Date().toISOString(), messages: [] };
+            live.set(sessionId, { ...base, turn: { ...marker } });
+            return Promise.resolve();
+        },
+        retained: (sessionId) => copy(failed.get(sessionId)),
+    };
+}

package/dist/native/session/session.d.ts

@@ -10,104 +10,133 @@ import { type SpinBreaker } from "#src/infra/spin-breaker/index";
 import type { AgentStreamEvent } from "#src/session/agent-stream-events";
 import type { OpenSessionOpts, SessionHandle } from "#src/session/session-types";
 import type { ResolvedCompaction } from "./compaction.ts";
+import type { TranscriptStore } from "./transcript-types.ts";
 import type { TurnRetryConfig } from "./turn-retry.ts";
-/**
- * Session name -> transcript directory, so sendTurn and close can find it.
- *
- * Cleared by every close path — `closeNativeSession` (in-process) and the
- * adapter's `closePhysicalSession` (run teardown, which only has the name) —
- * through the shared `clearNativeSessionState`. A caller that opens a session
- * and never closes it (e.g. an early return, or a thrown error between open and
- * close) still leaks an entry for the lifetime of the process. Harmless in
- * practice (it is a small in-memory map keyed by session name, not a handle
- * to a real resource), but worth knowing when debugging a growing map.
- */
-export declare const nativeTranscriptDirs: Map<string, string>;
-/**
- * Session name -> the root whose `.nax/scratchpad/` holds this session's
- * spill files (US-003).
- *
- * Recorded from the session's `workdir` at open — the same root the coding
- * tools are confined to — so a spilled body is reachable through
- * `ScratchpadRead` with the relative path the truncation marker names. Same
- * lifecycle as the maps above: set on open, cleared on close.
- */
-export declare const nativeSessionScratchpadRoots: Map<string, string>;
-/**
- * Session name -> timeoutSeconds, so sendTurn can bound each `complete()`
- * call with a deadline (whole-branch review finding 4). Same lifecycle as
- * `nativeTranscriptDirs` — populated on open, cleared on close only.
- */
-export declare const nativeSessionTimeouts: Map<string, number>;
-/**
- * Session name -> the runtime hooks handed to openSession. SessionManager
- * passes both (manager.ts, openSession) and the native adapter previously
- * ignored them, which is why the idle watchdog never covered native. Same
- * lifecycle as `nativeTranscriptDirs`: set on open, cleared on close only.
- */
-export declare const nativeSessionStreamHooks: Map<string, {
+/** The runtime hooks handed to openSession. */
+export interface NativeSessionStreamHooks {
     onStreamActivity?: (event: AgentStreamEvent) => void;
     onActiveCall?: (callId: string, cancel: () => Promise<void>) => void;
-}>;
-/**
- * Session names whose most recent turn failed.
- *
- * `AgentAdapter.closeSession(handle)` carries no failure signal, so the close
- * cannot tell a finished session from a broken one and passed `failed: false`
- * for both -- deleting the transcript of exactly the session whose history the
- * retry needs and a human would read (nax#1838). Rather than widen the adapter
- * interface for one transport, the turn records what it knows here and the
- * close reads it. Same lifecycle as the maps above: written per turn, cleared
- * on close.
- *
- * A later successful turn clears the mark. "Failed" describes the session's
- * current state, not whether it ever stumbled -- a session that recovered and
- * finished is still cleaned up.
- */
-export declare const nativeSessionFailed: Set<string>;
-/**
- * Session name -> the identity that owns this session's transcript (nax#1877).
- *
- * Read by `runNativeTurn` on both the load and the save, so a transcript left
- * behind by an abandoned invocation of the same deterministic session name is
- * recognised as foreign rather than silently resumed. Same lifecycle as the
- * maps above: set on open, cleared on close.
- */
-export declare const nativeSessionTranscriptOwners: Map<string, string>;
-/** Session name -> resolved compaction settings. Same lifecycle as the maps above. */
-export declare const nativeSessionCompaction: Map<string, ResolvedCompaction>;
-/**
- * Session name -> resolved transport-fault retry settings (nax#1870). Same
- * lifecycle as the maps above: set on open, cleared on close.
- */
-export declare const nativeSessionTransportRetry: Map<string, TurnRetryConfig>;
-/**
- * Session name -> live `SpinBreaker` instance (nax#2013, lifetime extended in
- * nax#2047). Constructed once at open so the cumulative counter survives
- * across `runNativeTurn` calls — a fix round that opens a new turn on the
- * same `handle.id` must inherit the prior turn's evidence rather than start
- * fresh. Same lifecycle as `nativeSessionTransportRetry`: set on open, cleared
- * on close.
- */
-export declare const nativeSessionSpinBreaker: Map<string, SpinBreaker>;
+}
+/** Where one open session's history lives, and whether close may remove it. */
+export interface SessionTranscript {
+    readonly store: TranscriptStore;
+    readonly retainOnClose: boolean;
+}
 /**
- * Session name -> the last round trip's reported input tokens and the index it
- * covers, so the next estimate can anchor on a real number.
- *
- * In-memory rather than persisted because runNativeTurn reloads the transcript
- * from disk on EVERY turn: without this the second turn of every session would
- * be estimated from scratch. A process restart still loses it, which is the case
- * the reactive backstop covers.
+ * The per-owner state behind the native session lifecycle.
  *
- * `model` is the transcript model identity the anchor was measured under
- * (P3 spec 8.3(d)); read it through `sessionAnchorFor`, never directly.
+ * Every map below is keyed by session name and owned by one state instance, so
+ * two owners (the orchestrator and a test, or two concurrent runs) never share
+ * an entry for the same deterministic name.
  */
+export interface NativeSessionState {
+    /**
+     * Session name -> transcript directory, so sendTurn and close can find it.
+     *
+     * Cleared by every close path — `closeNativeSession` (in-process) and the
+     * adapter's `closePhysicalSession` (run teardown, which only has the name) —
+     * through the shared `clearNativeSessionState`. A caller that opens a session
+     * and never closes it (e.g. an early return, or a thrown error between open and
+     * close) still leaks an entry for the lifetime of the state. Harmless in
+     * practice (it is a small in-memory map keyed by session name, not a handle
+     * to a real resource), but worth knowing when debugging a growing map.
+     */
+    readonly transcriptDirs: Map<string, string>;
+    /**
+     * Session name -> the session's transcript store and close policy (S3-1).
+     * Set by every `openNativeSession`; read through `sessionTranscriptFor`. Same
+     * lifecycle as the maps above: set on open, cleared on close.
+     */
+    readonly transcripts: Map<string, SessionTranscript>;
+    /**
+     * Session name -> the root whose `.nax/scratchpad/` holds this session's
+     * spill files (US-003).
+     *
+     * Recorded from the session's `workdir` at open — the same root the coding
+     * tools are confined to — so a spilled body is reachable through
+     * `ScratchpadRead` with the relative path the truncation marker names. Same
+     * lifecycle as the maps above: set on open, cleared on close.
+     */
+    readonly scratchpadRoots: Map<string, string>;
+    /**
+     * Session name -> timeoutSeconds, so sendTurn can bound each `complete()`
+     * call with a deadline (whole-branch review finding 4). Same lifecycle as
+     * `transcriptDirs` — populated on open, cleared on close only.
+     */
+    readonly timeouts: Map<string, number>;
+    /**
+     * Session name -> the runtime hooks handed to openSession. SessionManager
+     * passes both (manager.ts, openSession) and the native adapter previously
+     * ignored them, which is why the idle watchdog never covered native. Same
+     * lifecycle as `transcriptDirs`: set on open, cleared on close only.
+     */
+    readonly streamHooks: Map<string, NativeSessionStreamHooks>;
+    /**
+     * Session names whose most recent turn failed.
+     *
+     * `AgentAdapter.closeSession(handle)` carries no failure signal, so the close
+     * cannot tell a finished session from a broken one and passed `failed: false`
+     * for both -- deleting the transcript of exactly the session whose history the
+     * retry needs and a human would read (nax#1838). Rather than widen the adapter
+     * interface for one transport, the turn records what it knows here and the
+     * close reads it. Same lifecycle as the maps above: written per turn, cleared
+     * on close.
+     *
+     * A later successful turn clears the mark. "Failed" describes the session's
+     * current state, not whether it ever stumbled -- a session that recovered and
+     * finished is still cleaned up.
+     */
+    readonly failed: Set<string>;
+    /**
+     * Session name -> the identity that owns this session's transcript (nax#1877).
+     *
+     * Read by `runNativeTurn` on both the load and the save, so a transcript left
+     * behind by an abandoned invocation of the same deterministic session name is
+     * recognised as foreign rather than silently resumed. Same lifecycle as the
+     * maps above: set on open, cleared on close.
+     */
+    readonly transcriptOwners: Map<string, string>;
+    /** Session name -> resolved compaction settings. Same lifecycle as the maps above. */
+    readonly compaction: Map<string, ResolvedCompaction>;
+    /**
+     * Session name -> resolved transport-fault retry settings (nax#1870). Same
+     * lifecycle as the maps above: set on open, cleared on close.
+     */
+    readonly transportRetry: Map<string, TurnRetryConfig>;
+    /**
+     * Session name -> live `SpinBreaker` instance (nax#2013, lifetime extended in
+     * nax#2047). Constructed once at open so the cumulative counter survives
+     * across `runNativeTurn` calls — a fix round that opens a new turn on the
+     * same `handle.id` must inherit the prior turn's evidence rather than start
+     * fresh. Same lifecycle as `transportRetry`: set on open, cleared on close.
+     */
+    readonly spinBreakers: Map<string, SpinBreaker>;
+    /**
+     * Session name -> the last round trip's reported input tokens and the index it
+     * covers, so the next estimate can anchor on a real number.
+     *
+     * In-memory rather than persisted because runNativeTurn reloads the transcript
+     * from disk on EVERY turn: without this the second turn of every session would
+     * be estimated from scratch. A process restart still loses it, which is the case
+     * the reactive backstop covers.
+     *
+     * `model` is the transcript model identity the anchor was measured under
+     * (P3 spec 8.3(d)); read it through `sessionAnchorFor`, never directly.
+     */
+    readonly lastUsage: Map<string, SessionAnchor>;
+    /**
+     * Session name -> the system prompt sent as each round trip's top-level
+     * `system` (S3-4; the facade's `instructions`). nax opens without one. Same
+     * lifecycle as the maps above: set on open, cleared on close.
+     */
+    readonly systemPrompts: Map<string, string>;
+}
+export declare function createNativeSessionState(): NativeSessionState;
 export interface SessionAnchor {
     readonly promptTokens: number;
     readonly anchorIndex: number;
     readonly model?: string;
 }
-export declare const nativeSessionLastUsage: Map<string, SessionAnchor>;
 /**
  * The persisted anchor a turn on `model` may use. Prefix stability is a
  * property of (model, prefix) (P3 spec 3.3): an anchor measured under a
@@ -115,12 +144,23 @@ export declare const nativeSessionLastUsage: Map<string, SessionAnchor>;
  * so it is dropped here rather than mis-sizing the next compaction decision.
  * An entry or a turn with no model makes no claim — the store's own rule.
  */
-export declare function sessionAnchorFor(sessionName: string, model: string | undefined): SessionAnchor | undefined;
+export declare function sessionAnchorFor(state: NativeSessionState, sessionName: string, model: string | undefined): SessionAnchor | undefined;
 /** Records how the session's latest turn ended, for `closeNativeSession`. */
-export declare function markNativeTurnOutcome(sessionName: string, failed: boolean): void;
-export declare function openNativeSession(name: string, opts: OpenSessionOpts): Promise<SessionHandle>;
+export declare function markNativeTurnOutcome(state: NativeSessionState, sessionName: string, failed: boolean): void;
+/**
+ * The session's transcript. A state seeded with only a transcript directory
+ * (tests that drive `runNativeTurn` without opening) resolves to the file store
+ * over it; `openNativeSession` always records an entry, so production does not
+ * take that path.
+ */
+export declare function sessionTranscriptFor(state: NativeSessionState, sessionName: string): SessionTranscript | undefined;
+/** The request field for the session's system prompt: `{ system }`, or `{}` when it has none. */
+export declare function systemFieldFor(state: NativeSessionState, sessionName: string): {
+    readonly system?: string;
+};
+export declare function openNativeSession(state: NativeSessionState, name: string, opts: OpenSessionOpts): Promise<SessionHandle>;
 /**
- * Clear every module-level entry for one session name.
+ * Clear every state entry for one session name.
  *
  * Extracted so both close paths share one source of truth. `closeNativeSession`
  * has a `SessionHandle`; the adapter's `closePhysicalSession` gets only the
@@ -129,11 +169,13 @@ export declare function openNativeSession(name: string, opts: OpenSessionOpts):
  * is that name — but the signatures are not interchangeable, so this helper is
  * string-keyed rather than reconstructed into a synthetic handle.
  */
-export declare function clearNativeSessionState(sessionName: string): void;
+export declare function clearNativeSessionState(state: NativeSessionState, sessionName: string): void;
 /**
  * Kept on failure, deleted on success. Every Phase B op is lifetime "fresh", so
- * the transcript survives exactly when it is worth reading. The kept-on-failure
- * set is otherwise unbounded, so a failed close also prunes the feature's
- * `sessions/` directory down to `MAX_RETAINED_TRANSCRIPTS` (ADR-028 section 3).
+ * the transcript survives exactly when it is worth reading. Keeping is the
+ * store's `retainFailed`; the file store's also prunes the feature's
+ * `sessions/` directory down to `MAX_RETAINED_TRANSCRIPTS` (ADR-028 section 3),
+ * since the kept-on-failure set is otherwise unbounded. A session opened with
+ * `retainOnClose` skips both: its live document stays resumable.
  */
-export declare function closeNativeSession(handle: SessionHandle, failed?: boolean): Promise<void>;
+export declare function closeNativeSession(state: NativeSessionState, handle: SessionHandle, failed?: boolean): Promise<void>;