indusagi-coding-agent 0.2.5 → 0.2.9

package/src/runtime-bridge/broker.ts

@@ -0,0 +1,227 @@
+/**
+ * RuntimeBroker — the single decision point that routes every turn to either an
+ * external runtime or the framework network stream.
+ */
+import { streamSimple } from "indusagi/ai";
+import type {
+  Api,
+  AssistantMessageEventStream,
+  ChildTransport,
+  Context,
+  ExchangeOptions,
+  ExternalRuntimeSpec,
+  Model,
+  NormalizedEvent,
+  RuntimeBridge,
+  RuntimeBroker,
+} from "./contract.js";
+
+export const RUNTIME_LINK_ENTRY = "external-runtime-link" as const;
+export type RuntimeLinkEntryTag = typeof RUNTIME_LINK_ENTRY;
+
+export interface RuntimeLink {
+  readonly source: string;
+  readonly bridge: string;
+  readonly resumeToken: string;
+  readonly at: string;
+}
+
+export function runtimeSourceKey(source: string, modelId: string, bridge: string): string {
+  return `${source}|${modelId}|${bridge}`;
+}
+
+export interface RuntimeLinkStore {
+  save(link: RuntimeLink): Promise<void> | void;
+  find(sourceKey: string): Promise<string | undefined> | string | undefined;
+}
+
+export interface TransportContext {
+  readonly spec: ExternalRuntimeSpec;
+  readonly model: Model<Api>;
+  readonly opts: ExchangeOptions;
+  readonly resume?: string;
+}
+
+export type ChildTransportFactory = (ctx: TransportContext) => ChildTransport;
+
+export type FrameworkStream = (
+  model: Model<Api>,
+  context: Context,
+  opts: ExchangeOptions,
+) => AssistantMessageEventStream;
+
+export interface RuntimeBrokerDeps {
+  readonly transportFactory?: ChildTransportFactory;
+  readonly linkStore?: RuntimeLinkStore;
+  readonly frameworkStream?: FrameworkStream;
+  readonly bridges?: readonly RuntimeBridge[];
+}
+
+export interface RuntimeBrokerRuntime extends RuntimeBroker {
+  exchange(
+    model: Model<Api>,
+    context: Context,
+    opts?: ExchangeOptions,
+  ): AssistantMessageEventStream;
+}
+
+export type ResumeEvent = Extract<NormalizedEvent, { kind: "resume" }>;
+
+function resumeTokenOf(payload: unknown): string | undefined {
+  if (typeof payload !== "object" || payload === null) return undefined;
+  const rec = payload as Record<string, unknown>;
+  if (rec["method"] === "session/resume") {
+    const params = rec["params"];
+    if (typeof params === "object" && params !== null) {
+      const t = (params as Record<string, unknown>)["resumeToken"];
+      if (typeof t === "string") return t;
+    }
+    return undefined;
+  }
+  if (rec["type"] === "system" && rec["subtype"] === "init") {
+    const id = rec["session_id"];
+    if (typeof id === "string") return id;
+  }
+  if (rec["type"] === "thread.started") {
+    const id = rec["thread_id"];
+    if (typeof id === "string") return id;
+  }
+  return undefined;
+}
+
+interface ResumeTap {
+  onMessage: (m: { payload: unknown }) => void;
+  onClose: (disposer: () => void) => void;
+}
+
+function makeResumeTap(
+  store: RuntimeLinkStore | undefined,
+  source: string,
+  modelId: string,
+  bridge: string,
+): ResumeTap | undefined {
+  if (!store) return undefined;
+  let saved = false;
+  let disposer: (() => void) | undefined;
+  const persist = (resumeToken: string): void => {
+    if (saved) return;
+    saved = true;
+    const link: RuntimeLink = {
+      source,
+      bridge,
+      resumeToken,
+      at: new Date().toISOString(),
+    };
+    try {
+      const r = store.save(link);
+      if (r && typeof (r as Promise<void>).catch === "function") {
+        (r as Promise<void>).catch(() => undefined);
+      }
+    } catch {
+      /* ignore persistence failures */
+    }
+    disposer?.();
+  };
+  return {
+    onMessage: (m): void => {
+      const token = resumeTokenOf(m.payload);
+      if (token !== undefined) persist(token);
+    },
+    onClose: (d): void => {
+      disposer = d;
+    },
+  };
+}
+
+class Broker implements RuntimeBrokerRuntime {
+  readonly #bridges: Map<string, RuntimeBridge> = new Map();
+  readonly #transportFactory: ChildTransportFactory | undefined;
+  readonly #linkStore: RuntimeLinkStore | undefined;
+  readonly #framework: FrameworkStream;
+  readonly #knownSpecs: Readonly<Record<string, ExternalRuntimeSpec>> = {
+    "claude-cli": {
+      adapter: "claude-cli",
+      authMode: "external-cli",
+      binaryPath: "claude",
+      args: ["--output-format", "stream-json", "--verbose"],
+    },
+    "codex-cli": {
+      adapter: "codex-cli",
+      authMode: "external-cli",
+      binaryPath: "codex",
+      args: ["--json"],
+    },
+    "indusagi-cli": {
+      adapter: "indusagi-cli",
+      authMode: "external-cli",
+      binaryPath: "indusagi",
+      args: ["--rpc"],
+    },
+  };
+
+  constructor(deps: RuntimeBrokerDeps = {}) {
+    this.#transportFactory = deps.transportFactory;
+    this.#linkStore = deps.linkStore;
+    this.#framework = deps.frameworkStream ?? ((model, context, opts) => streamSimple(model, context, opts));
+    for (const bridge of deps.bridges ?? []) this.register(bridge);
+  }
+
+  register(bridge: RuntimeBridge): void {
+    this.#bridges.set(bridge.adapter, bridge);
+  }
+
+  resolveSpec(model: Model<Api>): ExternalRuntimeSpec | undefined {
+    const baseUrl = model.baseUrl;
+    if (!baseUrl.startsWith("bridge:")) return undefined;
+    const adapter = baseUrl.slice("bridge:".length);
+    if (!this.#bridges.has(adapter)) return undefined;
+    return this.#knownSpecs[adapter];
+  }
+
+  requiresCredential(spec: ExternalRuntimeSpec): boolean {
+    const bridge = this.#bridges.get(spec.adapter);
+    return bridge ? bridge.requiresCredential(spec) : spec.authMode === "api-key";
+  }
+
+  route(model: Model<Api>, _context: Context, _opts: ExchangeOptions): { target: "external"; bridge: RuntimeBridge; spec: ExternalRuntimeSpec } | { target: "framework" } {
+    const spec = this.resolveSpec(model);
+    if (!spec) return { target: "framework" };
+    const bridge = this.#bridges.get(spec.adapter);
+    if (!bridge) return { target: "framework" };
+    return { target: "external", bridge, spec };
+  }
+
+  exchange(model: Model<Api>, context: Context, opts: ExchangeOptions = {}): AssistantMessageEventStream {
+    const baseUrl = model.baseUrl;
+    const adapter = baseUrl.startsWith("bridge:") ? baseUrl.slice("bridge:".length) : undefined;
+    const spec = adapter ? this.resolveSpec(model) : undefined;
+    const bridge = spec ? this.#bridges.get(spec.adapter) : undefined;
+    if (!spec || !bridge) {
+      return this.#framework(model, context, opts);
+    }
+    if (!this.#transportFactory) {
+      return this.#framework(model, context, opts);
+    }
+    const source = String(model.provider);
+    const sourceKey = runtimeSourceKey(source, model.id, spec.adapter);
+    const persisted = this.#linkStore?.find(sourceKey);
+    const resume = typeof persisted === "string" ? persisted : opts.resume;
+    const exchangeOpts: ExchangeOptions = resume !== undefined ? { ...opts, resume } : opts;
+    const transport = this.#transportFactory({
+      spec,
+      model,
+      opts: exchangeOpts,
+      ...(resume !== undefined ? { resume } : {}),
+    });
+    const tap = makeResumeTap(this.#linkStore, source, model.id, spec.adapter);
+    if (tap) {
+      const dispose = transport.onMessage(tap.onMessage);
+      tap.onClose(dispose);
+    }
+    return bridge.runExchange(model, context, exchangeOpts, transport);
+  }
+}
+
+export function createRuntimeBroker(deps: RuntimeBrokerDeps = {}): RuntimeBrokerRuntime {
+  return new Broker(deps);
+}

package/src/runtime-bridge/contract.ts

@@ -0,0 +1,122 @@
+/**
+ * Runtime-bridge contract — the FROZEN type surface of provider *routing*.
+ */
+import type {
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
+  KnownProvider,
+  Model,
+  SimpleStreamOptions,
+  StopReason,
+  ToolCall,
+} from "indusagi/ai";
+
+export type {
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
+  KnownProvider,
+  Model,
+  SimpleStreamOptions,
+  StopReason,
+  ToolCall,
+};
+
+export type RuntimeAdapterId = "claude-cli" | "codex-cli" | "indusagi-cli" | (string & {});
+
+export type RuntimeAuthMode = "external-cli" | "api-key";
+
+export interface ExternalRuntimeSpec {
+  readonly adapter: RuntimeAdapterId;
+  readonly authMode: RuntimeAuthMode;
+  readonly binaryPath?: string;
+  readonly args?: readonly string[];
+  readonly env?: Readonly<Record<string, string>>;
+  readonly delegate?: string;
+}
+
+export const RUNTIME_ENDPOINT_SCHEME = "bridge:" as const;
+export type RuntimeEndpointScheme = typeof RUNTIME_ENDPOINT_SCHEME;
+
+export function runtimeEndpoint(adapter: RuntimeAdapterId): string {
+  return `${RUNTIME_ENDPOINT_SCHEME}${adapter}`;
+}
+
+export type NormalizedEvent =
+  | { readonly kind: "text"; readonly delta: string }
+  | { readonly kind: "thinking"; readonly delta: string }
+  | { readonly kind: "tool_call"; readonly call: ToolCall }
+  | { readonly kind: "resume"; readonly resumeToken: string }
+  | { readonly kind: "finish"; readonly reason: FinishReason }
+  | { readonly kind: "failed"; readonly error: BridgeFailure };
+
+export type NormalizedEventKind = NormalizedEvent["kind"];
+
+export type NormalizedEventOf<K extends NormalizedEventKind> = Extract<
+  NormalizedEvent,
+  { kind: K }
+>;
+
+export type FinishReason = Extract<StopReason, "stop" | "length" | "toolUse">;
+
+export interface BridgeFailure {
+  readonly message: string;
+  readonly aborted?: boolean;
+  readonly cause?: unknown;
+}
+
+export interface BridgeEventSink {
+  start(): void;
+  text(delta: string): void;
+  thinking(delta: string): void;
+  toolCall(call: ToolCall): void;
+  emit(event: NormalizedEvent): void;
+  finishSuccess(reason?: FinishReason): void;
+  finishError(error: BridgeFailure): void;
+  readonly stream: AssistantMessageEventStream;
+}
+
+export interface ChildMessage {
+  readonly payload: unknown;
+}
+
+export interface ChildRequest {
+  readonly body: unknown;
+}
+
+export interface ChildTransport {
+  send(request: ChildRequest): Promise<void>;
+  onMessage(listener: (message: ChildMessage) => void): () => void;
+  close(): Promise<void>;
+}
+
+export interface ExchangeOptions extends SimpleStreamOptions {
+  readonly sessionId?: string;
+  readonly cwd?: string;
+  readonly resume?: string;
+}
+
+export interface RuntimeBridge {
+  readonly adapter: RuntimeAdapterId;
+  runExchange(
+    model: Model<Api>,
+    context: Context,
+    opts: ExchangeOptions,
+    transport: ChildTransport,
+  ): AssistantMessageEventStream;
+  requiresCredential(spec: ExternalRuntimeSpec): boolean;
+}
+
+export type RuntimeRoute =
+  | { readonly target: "external"; readonly bridge: RuntimeBridge; readonly spec: ExternalRuntimeSpec }
+  | { readonly target: "framework" };
+
+export interface RuntimeBroker {
+  register(bridge: RuntimeBridge): void;
+  route(model: Model<Api>, context: Context, opts: ExchangeOptions): RuntimeRoute;
+  resolveSpec(model: Model<Api>): ExternalRuntimeSpec | undefined;
+  requiresCredential(spec: ExternalRuntimeSpec): boolean;
+}

package/src/runtime-bridge/index.ts

@@ -0,0 +1,79 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Runtime-bridge subsystem — public barrel.
+ *
+ * Re-exports the FROZEN provider-routing contract: the external-runtime
+ * annotation ({@link ExternalRuntimeSpec} + the `bridge:<adapter>` endpoint
+ * convention), the provider-neutral {@link NormalizedEvent} union, the single
+ * {@link BridgeEventSink} push-stream helper, the injectable
+ * {@link ChildTransport} boundary, and the routing surface itself
+ * ({@link RuntimeBridge}, {@link RuntimeBroker}, {@link RuntimeRoute}).
+ *
+ * Behavior modules (the concrete bridges under `bridges/`, the sink
+ * implementation, the broker) are added to this barrel as they land; consumers
+ * import the routing surface from `src/runtime-bridge` rather than reaching into
+ * individual modules.
+ */
+export type {
+  RuntimeAdapterId,
+  RuntimeAuthMode,
+  ExternalRuntimeSpec,
+  RuntimeEndpointScheme,
+  NormalizedEvent,
+  NormalizedEventKind,
+  NormalizedEventOf,
+  FinishReason,
+  BridgeFailure,
+  BridgeEventSink,
+  ChildMessage,
+  ChildRequest,
+  ChildTransport,
+  ExchangeOptions,
+  RuntimeBridge,
+  RuntimeBroker,
+  RuntimeRoute,
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
+  KnownProvider,
+  Model,
+  SimpleStreamOptions,
+  StopReason,
+  ToolCall,
+} from "./contract.js";
+export { RUNTIME_ENDPOINT_SCHEME, runtimeEndpoint } from "./contract.js";
+export type { BridgeMessageSeed } from "./sink.js";
+export { createBridgeSink } from "./sink.js";
+export {
+  claudeCliBridge,
+  codexCliBridge,
+  indusagiCliBridge,
+  makeIndusagiCliBridge,
+  BUILTIN_RUNTIME_SPECS,
+  BUILTIN_ADAPTERS,
+  builtinRuntimeSpec,
+  annotateCard,
+  withRuntimeEndpoint,
+  specFromModel,
+  type RuntimeAnnotatedModel,
+  driveExchange,
+  seedFromModel,
+  type ChildParser,
+  type ParseStep,
+} from "./bridges/index.js";
+export {
+  createRuntimeBroker,
+  runtimeSourceKey,
+  RUNTIME_LINK_ENTRY,
+  type RuntimeBrokerRuntime,
+  type RuntimeBrokerDeps,
+  type ChildTransportFactory,
+  type TransportContext,
+  type FrameworkStream,
+  type RuntimeLink,
+  type RuntimeLinkStore,
+  type RuntimeLinkEntryTag,
+  type ResumeEvent,
+} from "./broker.js";

package/src/runtime-bridge/sink.ts

@@ -0,0 +1,180 @@
+/**
+ * The single {@link BridgeEventSink} implementation.
+ */
+import {
+  createAssistantMessageEventStream,
+  type AssistantMessage,
+  type Usage,
+} from "indusagi/ai";
+import type {
+  BridgeEventSink,
+  BridgeFailure,
+  FinishReason,
+  NormalizedEvent,
+  ToolCall,
+} from "./contract.js";
+
+export interface BridgeMessageSeed {
+  readonly api: AssistantMessage["api"];
+  readonly provider: AssistantMessage["provider"];
+  readonly model: string;
+}
+
+function zeroUsage(): Usage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+class BridgeSink implements BridgeEventSink {
+  readonly stream: ReturnType<typeof createAssistantMessageEventStream>;
+  partial: AssistantMessage;
+  open: { kind: "text" | "thinking"; index: number } | undefined;
+  started = false;
+  settled = false;
+
+  constructor(seed: BridgeMessageSeed) {
+    this.stream = createAssistantMessageEventStream();
+    this.partial = {
+      role: "assistant",
+      content: [],
+      api: seed.api,
+      provider: seed.provider,
+      model: seed.model,
+      usage: zeroUsage(),
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+  }
+
+  start(): void {
+    if (this.started || this.settled) return;
+    this.started = true;
+    this.stream.pushStart(this.partial);
+  }
+
+  text(delta: string): void {
+    if (this.settled) return;
+    this.start();
+    const index = this.ensureOpen("text");
+    const block = this.partial.content[index];
+    if (block && block.type === "text") {
+      block.text += delta;
+    }
+    this.stream.pushTextDelta(index, delta, this.partial);
+  }
+
+  thinking(delta: string): void {
+    if (this.settled) return;
+    this.start();
+    const index = this.ensureOpen("thinking");
+    const block = this.partial.content[index];
+    if (block && block.type === "thinking") {
+      block.thinking += delta;
+    }
+    this.stream.pushThinkingDelta(index, delta, this.partial);
+  }
+
+  toolCall(call: ToolCall): void {
+    if (this.settled) return;
+    this.start();
+    this.closeOpen();
+    const index = this.partial.content.length;
+    const block = {
+      type: "toolCall" as const,
+      id: call.id,
+      name: call.name,
+      arguments: call.arguments,
+      ...(call.thoughtSignature !== undefined
+        ? { thoughtSignature: call.thoughtSignature }
+        : {}),
+    };
+    this.partial.content.push(block);
+    this.stream.pushToolCallStart(index, this.partial);
+    this.stream.pushToolCallDelta(index, JSON.stringify(block.arguments), this.partial);
+    this.stream.pushToolCallEnd(index, block, this.partial);
+  }
+
+  emit(event: NormalizedEvent): void {
+    switch (event.kind) {
+      case "text":
+        this.text(event.delta);
+        return;
+      case "thinking":
+        this.thinking(event.delta);
+        return;
+      case "tool_call":
+        this.toolCall(event.call);
+        return;
+      case "resume":
+        return;
+      case "finish":
+        this.finishSuccess(event.reason);
+        return;
+      case "failed":
+        this.finishError(event.error);
+        return;
+    }
+  }
+
+  finishSuccess(reason: FinishReason = "stop"): void {
+    if (this.settled) return;
+    this.start();
+    this.closeOpen();
+    this.settled = true;
+    this.partial.stopReason = reason;
+    this.stream.pushDone(reason, this.partial);
+  }
+
+  finishError(error: BridgeFailure): void {
+    if (this.settled) return;
+    this.start();
+    this.closeOpen();
+    this.settled = true;
+    const reason = error.aborted ? "aborted" : "error";
+    this.partial.stopReason = reason;
+    this.partial.errorMessage = error.message;
+    this.stream.pushError(reason, this.partial);
+  }
+
+  private ensureOpen(kind: "text" | "thinking"): number {
+    if (this.open) {
+      if (this.open.kind === kind) return this.open.index;
+      this.closeOpen();
+    }
+    const index = this.partial.content.length;
+    if (kind === "text") {
+      this.partial.content.push({ type: "text", text: "" });
+      this.stream.pushTextStart(index, this.partial);
+    } else {
+      this.partial.content.push({ type: "thinking", thinking: "" });
+      this.stream.pushThinkingStart(index, this.partial);
+    }
+    this.open = { kind, index };
+    return index;
+  }
+
+  private closeOpen(): void {
+    const open = this.open;
+    if (!open) return;
+    this.open = undefined;
+    const block = this.partial.content[open.index];
+    if (open.kind === "text" && block && block.type === "text") {
+      this.stream.pushTextEnd(open.index, block.text, this.partial);
+    } else if (open.kind === "thinking" && block && block.type === "thinking") {
+      this.stream.pushThinkingEnd(open.index, block.thinking, this.partial);
+    }
+  }
+}
+
+/**
+ * Construct a {@link BridgeEventSink} seeded with the bound model's identity.
+ */
+export function createBridgeSink(seed: BridgeMessageSeed): BridgeEventSink {
+  return new BridgeSink(seed);
+}

package/src/sessions/contract.ts

@@ -0,0 +1,81 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Session Library contract — the value types the library surface speaks in.
+ *
+ * The library sits on top of the conductor's persistent transcript store: it
+ * enumerates the session files a workspace has accumulated, opens one back into
+ * a live {@link TranscriptStore}, and projects the resulting node tree into the
+ * flat shapes a navigator and a forking picker consume.
+ *
+ * These records are the *catalog/navigation* projections — the minimum a chooser
+ * UI needs. They deliberately hold no framework message objects: text is already
+ * reduced to a short preview, and identity is carried by stable string ids so a
+ * caller can list, rename, delete, walk, and fork without rehydrating payloads.
+ */
+/**
+ * One persisted session as the library catalogs it — what a chooser shows in a
+ * list before anything is opened.
+ *
+ * `id` is the bare session identifier (the filename stem the conductor's
+ * filesystem backend writes to); `path` is its absolute on-disk location. The
+ * remaining fields are best-effort enrichments filled when the library is asked
+ * to peek inside a file: a derived `name`, file `lastModified`/`size`, the
+ * `messageCount` of conversational nodes, and a short `preview` of the opening
+ * user turn. Any of them may be absent when only a shallow listing was taken.
+ */
+export interface SavedSession {
+    /** Bare session identifier — the filename stem, no extension or directory. */
+    readonly id: string;
+    /** Absolute on-disk path the session persists to. */
+    readonly path: string;
+    /** Human-facing label for the session, when one could be derived. */
+    readonly name?: string;
+    /** Last-modified wall-clock time of the file, in epoch milliseconds. */
+    readonly lastModified?: number;
+    /** Byte size of the session file on disk. */
+    readonly size?: number;
+    /** Count of conversational (user/assistant/tool) nodes in the transcript. */
+    readonly messageCount?: number;
+    /** Short single-line excerpt of the opening turn, for at-a-glance recognition. */
+    readonly preview?: string;
+}
+/**
+ * One row in the flattened view of a loaded transcript tree.
+ *
+ * The conductor stores a branchable tree of nodes; a navigator wants a single
+ * ordered list it can render and select against. Each {@link BranchNode} names
+ * its `id`, its `parent` link (so a caller can still reconstruct the tree),
+ * a render-ready `label`, the indentation `depth` from the root, and two flags:
+ * `isLeaf` for a tip of the tree and `isCurrent` for the node the active head
+ * points at.
+ */
+export interface BranchNode {
+    /** Stable id of the underlying transcript node. */
+    readonly id: string;
+    /** Parent node id, or `null` for a transcript root. */
+    readonly parent: string | null;
+    /** Render-ready, depth-indented one-line label. */
+    readonly label: string;
+    /** Distance from the root (a root is depth 0). */
+    readonly depth: number;
+    /** True when this node has no children — a tip of the tree. */
+    readonly isLeaf: boolean;
+    /** True when the active head currently points at this node. */
+    readonly isCurrent: boolean;
+}
+/**
+ * A past user turn offered as a fork point.
+ *
+ * To re-ask or re-edit an earlier prompt, a caller picks one of these and the
+ * conductor branches the transcript at `entryId`. `text` is the full prompt
+ * text; `preview` is the trimmed single-line form a picker renders.
+ */
+export interface PriorTurn {
+    /** Id of the transcript node this user turn lives on (the fork target). */
+    readonly entryId: string;
+    /** Full text of the user prompt. */
+    readonly text: string;
+    /** Trimmed single-line excerpt of {@link text}, for display. */
+    readonly preview: string;
+}

package/src/sessions/index.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+// Type declarations recovered from dist/types (no runtime body)
+/**
+ * Sessions subsystem — public barrel.
+ *
+ * Exposes the {@link SessionLibrary} (the catalog-and-navigation layer over the
+ * conductor's persisted transcripts) and its value contract — the
+ * {@link SavedSession} catalog row, the {@link BranchNode} navigator row, and
+ * the {@link PriorTurn} fork candidate. Consumers import the session-library
+ * surface from `src/sessions` rather than reaching into the individual modules.
+ */
+export type { SavedSession, BranchNode, PriorTurn } from "./contract.js";
+export { SessionLibrary, type SessionLibraryOptions } from "./library.js";