@anureo/sdk 0.0.0-stage → 0.2.0

package/dist/interactions.d.ts

@@ -0,0 +1,20 @@
+import { type InteractionRequested, type InteractionResponse, type InteractionResult } from "@anureo/protocol";
+import type { NativeInteractionResponder } from "./ports.js";
+export declare class InteractionRegistry {
+    private readonly publish;
+    private readonly limits;
+    private readonly beforeResponse?;
+    private readonly records;
+    constructor(publish: (result: InteractionResult) => Promise<void>, limits: {
+        maxPending: number;
+        timeoutMs: number;
+        responseTimeoutMs?: number;
+    }, beforeResponse?: ((request: InteractionRequested, response: InteractionResponse) => void) | undefined);
+    get pendingCount(): number;
+    pending(): InteractionRequested[];
+    begin(request: InteractionRequested, responder: NativeInteractionResponder): Promise<InteractionResponse>;
+    respond(id: string, requestId: string, response: InteractionResponse): Promise<InteractionResult>;
+    cancel(id: string, reason?: string, outcome?: "cancelled" | "expired" | "unknown"): Promise<InteractionResult>;
+    cancelAll(reason: string, turnId?: string): Promise<void>;
+    resolveExternally(result: InteractionResult): Promise<void>;
+}

package/dist/ports.d.ts

@@ -0,0 +1,66 @@
+import type { Capabilities, AhpEvent, AhpEventPayload, AhpMethod, AhpRequestMap, AhpResultMap, InitializeParams, InitializeResult, InteractionRequested, InteractionResponse, SessionBinding, SessionOpenParams } from "@anureo/protocol";
+import type { RequestOptions } from "./errors.js";
+import type { QueueLimits } from "./queue.js";
+export type SessionMethod = Exclude<AhpMethod, "initialize" | "session/open">;
+export interface EventScope {
+    turnId?: string;
+    itemId?: string;
+}
+export type NativeInteractionResponder = (response: InteractionResponse | null, reason?: string) => Promise<void>;
+export interface SessionEventSink {
+    emit(event: AhpEventPayload, scope?: EventScope): Promise<void>;
+    /** Non-pausable callback: false means the source must stop and the stream has failed. */
+    tryEmit(event: AhpEventPayload, scope?: EventScope): boolean;
+    requestInteraction(request: InteractionRequested, responder: NativeInteractionResponder): Promise<InteractionResponse>;
+    /** A remote peer resolved/expired an existing request. Never sends a second native response. */
+    resolveInteraction(result: AhpResultMap["interaction/respond"]): Promise<void>;
+    fail(cause: unknown): Promise<void>;
+}
+export interface BackendSession {
+    readonly binding: SessionBinding;
+    readonly capabilities: Capabilities;
+    execute<M extends SessionMethod>(method: M, params: AhpRequestMap[M]): Promise<AhpResultMap[M]>;
+    dispose(): Promise<void>;
+}
+export interface HarnessAdapter {
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<BackendSession>;
+    dispose(): Promise<void>;
+}
+export interface RuntimeOptions {
+    createId?: () => string;
+    now?: () => string;
+    requestTimeoutMs?: number;
+    openTimeoutMs?: number;
+    interactionTimeoutMs?: number;
+    maxPendingInteractions?: number;
+    requestCacheSize?: number;
+    queue?: QueueLimits;
+    /** Runs synchronously before native submission; persist only irreversible privacy metadata. */
+    onMarkedSecret?: (binding: Readonly<SessionBinding>, value: string) => void;
+    /** Host-owned cross-process privacy projection for authoritative native history. */
+    redactHistory?: (binding: Readonly<SessionBinding>, page: AhpResultMap["history/read"]) => AhpResultMap["history/read"] | Promise<AhpResultMap["history/read"]>;
+}
+export interface HarnessSession {
+    readonly binding: Readonly<SessionBinding>;
+    readonly capabilities: Readonly<Capabilities>;
+    events(): AsyncIterable<AhpEvent>;
+    startTurn(params: AhpRequestMap["turn/start"], options?: RequestOptions): Promise<AhpResultMap["turn/start"]>;
+    steer(params: AhpRequestMap["turn/steer"], options?: RequestOptions): Promise<AhpResultMap["turn/steer"]>;
+    interrupt(params: AhpRequestMap["turn/interrupt"], options?: RequestOptions): Promise<AhpResultMap["turn/interrupt"]>;
+    respond(params: AhpRequestMap["interaction/respond"], options?: RequestOptions): Promise<AhpResultMap["interaction/respond"]>;
+    cancelInteraction(params: AhpRequestMap["interaction/cancel"], options?: RequestOptions): Promise<AhpResultMap["interaction/cancel"]>;
+    setConfig(params: AhpRequestMap["session/config/set"], options?: RequestOptions): Promise<AhpResultMap["session/config/set"]>;
+    revert(params: AhpRequestMap["session/revert"], options?: RequestOptions): Promise<AhpResultMap["session/revert"]>;
+    readHistory(params: AhpRequestMap["history/read"], options?: RequestOptions): Promise<AhpResultMap["history/read"]>;
+    setGoal(params: AhpRequestMap["goal/set"], options?: RequestOptions): Promise<AhpResultMap["goal/set"]>;
+    clearGoal(params: AhpRequestMap["goal/clear"], options?: RequestOptions): Promise<AhpResultMap["goal/clear"]>;
+    compact(params: AhpRequestMap["compact/start"], options?: RequestOptions): Promise<AhpResultMap["compact/start"]>;
+    review(params: AhpRequestMap["review/start"], options?: RequestOptions): Promise<AhpResultMap["review/start"]>;
+    close(options?: RequestOptions): Promise<void>;
+}
+export interface HarnessRuntime {
+    initialize(params: InitializeParams, options?: RequestOptions): Promise<InitializeResult>;
+    openSession(params: SessionOpenParams, options?: RequestOptions): Promise<HarnessSession>;
+    dispose(): Promise<void>;
+}

package/dist/process.d.ts

@@ -0,0 +1,34 @@
+export type ProcessExit = {
+    code: number | null;
+    signal: string | null;
+    errorCode?: string;
+};
+export interface HarnessProcessOptions {
+    command: string;
+    args?: readonly string[];
+    cwd?: string;
+    /** A complete child environment; omitted means inherit. Never mutates the parent environment. */
+    env?: Record<string, string | undefined>;
+    /** False for a process whose lifetime belongs to an external owner. */
+    owned?: boolean;
+    shutdownTimeoutMs?: number;
+}
+export interface HarnessProcess {
+    readonly pid: number;
+    readonly owned: boolean;
+    readonly stdout: AsyncIterable<Uint8Array>;
+    readonly stderr: AsyncIterable<Uint8Array>;
+    /** Resolves at process exit; consumers may still drain buffered stdout/stderr. */
+    readonly exited: Promise<ProcessExit>;
+    write(chunk: string | Uint8Array): Promise<void>;
+    closeInput(): Promise<void>;
+    /** Idempotent: terminate an owned process tree, detach an externally owned process. */
+    dispose(): Promise<void>;
+}
+export declare class ProcessPortError extends Error {
+    readonly code: 'HARNESS_UNAVAILABLE' | 'PROCESS_WRITE_FAILED' | 'PROCESS_DISPOSE_FAILED';
+    readonly nativeCode?: string;
+    constructor(code: ProcessPortError['code'], message: string, options?: ErrorOptions);
+}
+/** Node's child_process implementation is also supported by Bun; no shell parsing is involved. */
+export declare function spawnHarnessProcess(options: HarnessProcessOptions): Promise<HarnessProcess>;

package/dist/process.js

@@ -0,0 +1,191 @@
+// packages/core/src/process.ts
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+
+class ProcessPortError extends Error {
+  code;
+  nativeCode;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "ProcessPortError";
+    this.code = code;
+    const cause = options?.cause;
+    if (cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(cause.code))
+      this.nativeCode = cause.code;
+  }
+}
+function exists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (error.code !== "ESRCH")
+      throw error;
+  }
+}
+async function signalGroupWithExitRace(pid, signal) {
+  for (let attempt = 0;; attempt++) {
+    try {
+      signalGroup(pid, signal);
+      return;
+    } catch (error) {
+      if (error.code !== "EPERM" || attempt >= 4)
+        throw error;
+      await delay(10);
+    }
+  }
+}
+async function windowsKillTree(pid, force) {
+  await new Promise((resolve, reject) => {
+    const killer = spawn("taskkill.exe", ["/PID", String(pid), "/T", ...force ? ["/F"] : []], {
+      stdio: "ignore",
+      windowsHide: true,
+      shell: false
+    });
+    killer.once("error", reject);
+    killer.once("exit", (code) => {
+      if (code === 0 || !exists(pid))
+        resolve();
+      else
+        reject(new ProcessPortError("PROCESS_DISPOSE_FAILED", "Unable to terminate harness process tree"));
+    });
+  });
+}
+async function terminateTree(child, pid, timeoutMs, didExit) {
+  if (!Number.isSafeInteger(pid) || pid <= 1)
+    throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Invalid original harness PID");
+  if (process.platform === "win32") {
+    if (!didExit()) {
+      try {
+        await windowsKillTree(pid, false);
+      } catch {
+        if (!didExit())
+          await windowsKillTree(pid, true);
+      }
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (!didExit() && Date.now() < deadline)
+      await delay(10);
+    if (!didExit())
+      await windowsKillTree(pid, true);
+    return;
+  }
+  await signalGroupWithExitRace(pid, "SIGTERM");
+  const deadline = Date.now() + timeoutMs;
+  while (exists(-pid) && Date.now() < deadline)
+    await delay(10);
+  if (exists(-pid))
+    await signalGroupWithExitRace(pid, "SIGKILL");
+}
+async function spawnHarnessProcess(options) {
+  if (!options.command || options.command.includes("\x00") || options.args?.some((arg) => arg.includes("\x00"))) {
+    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Invalid harness executable or argument");
+  }
+  const timeoutMs = options.shutdownTimeoutMs ?? 1000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 60000) {
+    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Invalid process shutdown timeout");
+  }
+  const owned = options.owned ?? true;
+  let child;
+  try {
+    child = spawn(options.command, [...options.args ?? []], {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: owned && process.platform !== "win32",
+      shell: false,
+      windowsHide: true
+    });
+  } catch (cause) {
+    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Unable to start harness executable", { cause });
+  }
+  let didExit = false;
+  let originalPid = child.pid;
+  let disposePromise;
+  const exited = new Promise((resolve) => {
+    child.once("exit", (code, signal) => {
+      didExit = true;
+      resolve({ code, signal });
+    });
+    child.once("error", (error) => {
+      if (!child.pid) {
+        didExit = true;
+        resolve({ code: null, signal: null, errorCode: error.code });
+      }
+    });
+  });
+  child.stdin.on("error", () => {});
+  try {
+    await new Promise((resolve, reject) => {
+      child.once("spawn", () => {
+        if (child.pid !== undefined && child.pid > 1)
+          originalPid = child.pid;
+        resolve();
+      });
+      child.once("error", reject);
+    });
+  } catch (cause) {
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+    throw new ProcessPortError("HARNESS_UNAVAILABLE", "Unable to start harness executable", { cause });
+  }
+  const pid = originalPid;
+  const closeInput = () => new Promise((resolve, reject) => {
+    if (child.stdin.destroyed || child.stdin.writableEnded) {
+      resolve();
+      return;
+    }
+    child.stdin.end((error) => error ? reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Unable to close harness input", { cause: error })) : resolve());
+  });
+  return {
+    pid,
+    owned,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    exited,
+    write(chunk) {
+      if (disposePromise || child.stdin.destroyed || child.stdin.writableEnded || didExit) {
+        return Promise.reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Harness process input is closed"));
+      }
+      return new Promise((resolve, reject) => {
+        child.stdin.write(chunk, (error) => error ? reject(new ProcessPortError("PROCESS_WRITE_FAILED", "Unable to write harness input", { cause: error })) : resolve());
+      });
+    },
+    closeInput,
+    dispose() {
+      return disposePromise ??= (async () => {
+        try {
+          if (owned) {
+            await terminateTree(child, pid, timeoutMs, () => didExit);
+            if (!didExit) {
+              await Promise.race([exited, delay(1000)]);
+              if (!didExit)
+                throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Harness process did not exit after termination");
+            }
+          } else
+            child.unref();
+        } catch (cause) {
+          if (cause instanceof ProcessPortError)
+            throw cause;
+          throw new ProcessPortError("PROCESS_DISPOSE_FAILED", "Unable to dispose harness process", { cause });
+        } finally {
+          child.stdin.destroy();
+          child.stdout.destroy();
+          child.stderr.destroy();
+        }
+      })();
+    }
+  };
+}
+export {
+  ProcessPortError,
+  spawnHarnessProcess
+};

package/dist/queue.d.ts

@@ -0,0 +1,36 @@
+export interface QueueLimits {
+    maxEvents?: number;
+    maxBytes?: number;
+    maxFrameBytes?: number;
+    maxWaitingWriters?: number;
+    maxControlEvents?: number;
+}
+/** A single-active-reader queue. Returning an iterator detaches; it does not cancel its producer. */
+export declare class BoundedEventQueue<T> implements AsyncIterable<T> {
+    private readonly sizeOf;
+    private readonly entries;
+    private bytes;
+    private reader?;
+    private waiting?;
+    private controls;
+    private ended;
+    private failure?;
+    private writers;
+    readonly limits: Required<QueueLimits>;
+    constructor(limits?: QueueLimits, sizeOf?: (value: T) => number);
+    get bufferedEvents(): number;
+    get bufferedBytes(): number;
+    private wakeWriters;
+    private assertOpen;
+    private checkedSize;
+    /** For producers that cannot pause. Overflow is an explicit error, never an eviction. */
+    assertWritable(value: T): void;
+    push(value: T): void;
+    /** For producers which await the sink. The number of suspended writers is bounded too. */
+    write(value: T, accepted?: () => void): Promise<void>;
+    /** Reserved for a final failure event, even if the regular queue is full. */
+    pushControl(value: T): void;
+    endWithControl(value: T): void;
+    end(cause?: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/queue.js

@@ -0,0 +1,166 @@
+// packages/core/src/errors.ts
+class HarnessSdkError extends Error {
+  code;
+  retryable;
+  outcomeUnknown;
+  details;
+  name = "HarnessSdkError";
+  constructor(code, message = code, retryable = false, outcomeUnknown = false, details) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.outcomeUnknown = outcomeUnknown;
+    this.details = details;
+  }
+}
+
+// packages/core/src/queue.ts
+class BoundedEventQueue {
+  sizeOf;
+  entries = [];
+  bytes = 0;
+  reader;
+  waiting;
+  controls = [];
+  ended = false;
+  failure;
+  writers = new Set;
+  limits;
+  constructor(limits = {}, sizeOf = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength) {
+    this.sizeOf = sizeOf;
+    this.limits = { maxEvents: limits.maxEvents ?? 2048, maxBytes: limits.maxBytes ?? 16 * 1024 * 1024, maxFrameBytes: limits.maxFrameBytes ?? 8 * 1024 * 1024, maxWaitingWriters: limits.maxWaitingWriters ?? 32, maxControlEvents: limits.maxControlEvents ?? 33 };
+    if (Object.values(this.limits).some((n) => !Number.isSafeInteger(n) || n <= 0))
+      throw new HarnessSdkError("INVALID_PARAMS", "Queue limits must be positive integers");
+  }
+  get bufferedEvents() {
+    return this.entries.length + this.controls.length;
+  }
+  get bufferedBytes() {
+    return this.bytes;
+  }
+  wakeWriters() {
+    for (const wake of this.writers)
+      wake();
+    this.writers.clear();
+  }
+  assertOpen() {
+    if (this.ended)
+      throw this.failure ?? new HarnessSdkError("STREAM_CLOSED");
+  }
+  checkedSize(value) {
+    const bytes = this.sizeOf(value);
+    if (bytes > this.limits.maxFrameBytes || bytes > this.limits.maxBytes)
+      throw new HarnessSdkError("FRAME_TOO_LARGE");
+    return bytes;
+  }
+  assertWritable(value) {
+    this.assertOpen();
+    const bytes = this.checkedSize(value);
+    if (!this.waiting && (this.entries.length >= this.limits.maxEvents || this.bytes + bytes > this.limits.maxBytes))
+      throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
+  }
+  push(value) {
+    this.assertWritable(value);
+    const bytes = this.checkedSize(value);
+    if (this.waiting) {
+      const waiting = this.waiting;
+      this.waiting = undefined;
+      waiting.resolve({ done: false, value });
+      return;
+    }
+    this.entries.push({ value, bytes });
+    this.bytes += bytes;
+  }
+  async write(value, accepted) {
+    const bytes = this.checkedSize(value);
+    while (!this.waiting && (this.entries.length >= this.limits.maxEvents || this.bytes + bytes > this.limits.maxBytes)) {
+      this.assertOpen();
+      if (this.writers.size >= this.limits.maxWaitingWriters)
+        throw new HarnessSdkError("BACKPRESSURE_EXCEEDED");
+      await new Promise((resolve) => this.writers.add(resolve));
+    }
+    this.push(value);
+    accepted?.();
+  }
+  pushControl(value) {
+    this.assertOpen();
+    this.checkedSize(value);
+    if (this.waiting) {
+      const waiter = this.waiting;
+      this.waiting = undefined;
+      waiter.resolve({ done: false, value });
+    } else {
+      if (this.controls.length >= this.limits.maxControlEvents)
+        throw new HarnessSdkError("BACKPRESSURE_EXCEEDED", "Control event limit exceeded");
+      this.controls.push(value);
+    }
+  }
+  endWithControl(value) {
+    if (this.ended)
+      return;
+    this.pushControl(value);
+    this.end();
+  }
+  end(cause) {
+    if (this.ended)
+      return;
+    this.ended = true;
+    this.failure = cause;
+    this.wakeWriters();
+    if (this.waiting) {
+      const waiter = this.waiting;
+      this.waiting = undefined;
+      cause ? waiter.reject(cause) : waiter.resolve({ done: true, value: undefined });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    if (this.reader)
+      throw new HarnessSdkError("EVENT_STREAM_ALREADY_OWNED");
+    const reader = Symbol("reader");
+    this.reader = reader;
+    let detached = false;
+    const detach = () => {
+      detached = true;
+      if (this.reader === reader)
+        this.reader = undefined;
+      if (this.waiting?.reader === reader) {
+        const waiter = this.waiting;
+        this.waiting = undefined;
+        waiter.resolve({ done: true, value: undefined });
+      }
+      return { done: true, value: undefined };
+    };
+    return {
+      next: () => {
+        if (detached)
+          return Promise.resolve({ done: true, value: undefined });
+        const entry = this.entries.shift();
+        if (entry) {
+          this.bytes -= entry.bytes;
+          this.wakeWriters();
+          return Promise.resolve({ done: false, value: entry.value });
+        }
+        if (this.controls.length)
+          return Promise.resolve({ done: false, value: this.controls.shift() });
+        if (this.ended) {
+          detach();
+          return this.failure ? Promise.reject(this.failure) : Promise.resolve({ done: true, value: undefined });
+        }
+        if (this.waiting)
+          return Promise.reject(new HarnessSdkError("CONCURRENT_EVENT_READ"));
+        return new Promise((resolve, reject) => {
+          this.waiting = { reader, resolve, reject };
+          this.wakeWriters();
+        });
+      },
+      return: async () => detach(),
+      throw: async (cause) => {
+        detach();
+        throw cause;
+      }
+    };
+  }
+}
+export {
+  BoundedEventQueue
+};

package/dist/runtime.d.ts

@@ -0,0 +1,85 @@
+import { type Capabilities, type AhpEvent, type AhpEventPayload, type AhpRequestMap, type AhpResultMap, type InitializeParams, type InitializeResult, type InteractionRequested, type InteractionResponse, type SessionBinding, type SessionOpenParams, type SessionState } from "@anureo/protocol";
+import { type RequestOptions } from "./errors.js";
+import type { BackendSession, EventScope, HarnessAdapter, HarnessRuntime, HarnessSession, NativeInteractionResponder, RuntimeOptions, SessionEventSink } from "./ports.js";
+export declare class ManagedHarnessSession implements HarnessSession, SessionEventSink {
+    private readonly options;
+    private readonly clientCapabilities?;
+    private _binding;
+    private _capabilities;
+    private readonly queue;
+    private readonly interactions;
+    private readonly streamId;
+    private seq;
+    private activeTurnId?;
+    private readonly started;
+    private readonly ended;
+    private readonly deliveredStarted;
+    private readonly deliveredEnded;
+    private readonly items;
+    private backend?;
+    private closed;
+    private recovering;
+    private controlBusy;
+    private maintenancePending;
+    private emitter;
+    private pendingEmissions;
+    private disposePromise?;
+    private failurePromise?;
+    private failureCause?;
+    private emergencyPublication;
+    private backendDisposal?;
+    private requests;
+    private state;
+    private readonly createId;
+    private readonly secrets;
+    constructor(binding: SessionBinding, capabilities: Capabilities, options?: RuntimeOptions, initial?: Pick<SessionOpenParams, "config" | "model">, clientCapabilities?: Capabilities | undefined);
+    get binding(): Readonly<SessionBinding>;
+    get capabilities(): Readonly<Capabilities>;
+    get isClosed(): boolean;
+    get snapshot(): SessionState;
+    events(): AsyncIterable<AhpEvent>;
+    reserveFork(binding: SessionBinding): () => void;
+    attach(backend: BackendSession): Promise<void>;
+    private makeEvent;
+    private prepare;
+    private accepted;
+    emit(payload: AhpEventPayload, scope?: EventScope): Promise<void>;
+    tryEmit(payload: AhpEventPayload, scope?: EventScope): boolean;
+    requestInteraction(request: InteractionRequested, responder: NativeInteractionResponder): Promise<InteractionResponse>;
+    resolveInteraction(result: AhpResultMap["interaction/respond"]): Promise<void>;
+    fail(cause: unknown): Promise<void>;
+    private performFailure;
+    private requireBackend;
+    private guard;
+    private call;
+    startTurn(params: AhpRequestMap["turn/start"], options?: RequestOptions): Promise<import("@anureo/protocol").TurnStartResult>;
+    steer(params: AhpRequestMap["turn/steer"], options?: RequestOptions): Promise<import("@anureo/protocol").TurnSteerResult>;
+    interrupt(params: AhpRequestMap["turn/interrupt"], options?: RequestOptions): Promise<import("@anureo/protocol").TurnInterruptResult>;
+    respond(params: AhpRequestMap["interaction/respond"], options?: RequestOptions): Promise<import("@anureo/protocol").InteractionResult>;
+    cancelInteraction(params: AhpRequestMap["interaction/cancel"], options?: RequestOptions): Promise<import("@anureo/protocol").InteractionResult>;
+    setConfig(params: AhpRequestMap["session/config/set"], options?: RequestOptions): Promise<SessionState>;
+    revert(params: AhpRequestMap["session/revert"], options?: RequestOptions): Promise<import("@anureo/protocol").RevertResult>;
+    readHistory(params: AhpRequestMap["history/read"], options?: RequestOptions): Promise<import("@anureo/protocol").HistoryPage>;
+    setGoal(params: AhpRequestMap["goal/set"], options?: RequestOptions): Promise<import("@anureo/protocol").GoalState>;
+    clearGoal(params: AhpRequestMap["goal/clear"], options?: RequestOptions): Promise<import("@anureo/protocol").GoalState>;
+    compact(params: AhpRequestMap["compact/start"], options?: RequestOptions): Promise<import("@anureo/protocol").MaintenanceResult>;
+    review(params: AhpRequestMap["review/start"], options?: RequestOptions): Promise<import("@anureo/protocol").TurnStartResult>;
+    close(options?: RequestOptions): Promise<void>;
+    private disposeBackend;
+    dispose(): Promise<void>;
+}
+export declare class ManagedHarnessRuntime implements HarnessRuntime {
+    private readonly adapter;
+    private readonly options;
+    private initialized?;
+    private readonly sessions;
+    private closed;
+    private disposing?;
+    private initialization?;
+    private clientCapabilities?;
+    constructor(adapter: HarnessAdapter, options?: RuntimeOptions);
+    initialize(params: InitializeParams, options?: RequestOptions): Promise<InitializeResult>;
+    openSession(params: SessionOpenParams, options?: RequestOptions): Promise<HarnessSession>;
+    dispose(): Promise<void>;
+}
+export declare function createHarnessRuntime(adapter: HarnessAdapter, options?: RuntimeOptions): HarnessRuntime;

package/dist/secrets.d.ts

@@ -0,0 +1,28 @@
+import type { Capabilities, AhpEventPayload, AhpMethod, AhpResultMap, GoalState, HistoryPage, InteractionRequested, InteractionResponse, Item, JsonValue, SessionState } from "@anureo/protocol";
+/** Session-local marked answers only. Values never persist and unmarked chat text is not inferred. */
+export declare class SecretRedactor {
+    private readonly onRemember?;
+    private readonly values;
+    private readonly streams;
+    private secretBytes;
+    constructor(onRemember?: ((secret: string) => void) | undefined);
+    private remember;
+    rememberResponse(request: InteractionRequested, response: InteractionResponse): void;
+    private fromSchema;
+    private scan;
+    text(value: string): string;
+    delta(stream: string, value: string): string;
+    json(value: JsonValue): JsonValue;
+    private schema;
+    capabilities(value: Capabilities): Capabilities;
+    goal(value: GoalState): GoalState;
+    state(value: SessionState): SessionState;
+    /** Redact content fields while preserving IDs, protocol enums, revisions and schema constraints. */
+    result<M extends AhpMethod>(method: M, value: AhpResultMap[M]): AhpResultMap[M];
+    private input;
+    item(item: Item): Item;
+    interaction(request: InteractionRequested): InteractionRequested;
+    private deltaValue;
+    event(event: AhpEventPayload): AhpEventPayload;
+    history(page: HistoryPage): HistoryPage;
+}