anyclaude-sdk 0.1.0

package/dist/sandbox/local.js

@@ -0,0 +1,155 @@
+// Local real-OS sandbox — runs the agent against the actual filesystem and
+// shell of the host machine (Node.js), like Claude Code does when executed in a
+// working directory. Auto-detects the platform (Windows / macOS / Linux) and
+// picks an appropriate shell.
+//
+// Node-only. All node built-ins are imported lazily inside methods so this file
+// can sit in the browser barrel without breaking browser bundles — the node
+// code only executes when LocalSandbox is actually used.
+/** Detect the host platform from process.platform. */
+export function detectPlatform() {
+    const p = globalThis.process?.platform;
+    if (p === 'win32')
+        return 'windows';
+    if (p === 'darwin')
+        return 'mac';
+    if (p === 'linux')
+        return 'linux';
+    return 'unknown';
+}
+/**
+ * A Sandbox backed by the local OS filesystem and shell. Pair with an Anthropic/
+ * OpenAI client and pass to `query()` to run the agent on real files:
+ *
+ *   const workspace = new LocalSandbox({ cwd: '/path/to/project' })
+ *   query({ prompt, workspace, llm })
+ */
+export class LocalSandbox {
+    constructor(options = {}) {
+        this.opts = options;
+        this.platform = detectPlatform();
+        // process.cwd() resolved lazily but captured here when available.
+        const proc = globalThis.process;
+        this.cwd = options.cwd ?? proc?.cwd?.() ?? '/';
+    }
+    async fs() {
+        return (this._fs ??= await import('node:fs/promises'));
+    }
+    async path() {
+        return (this._path ??= await import('node:path'));
+    }
+    async cp() {
+        return (this._cp ??= await import('node:child_process'));
+    }
+    async resolve(p) {
+        const path = await this.path();
+        return path.isAbsolute(p) ? p : path.resolve(this.cwd, p);
+    }
+    // ---- FileSystem ----
+    async readFile(p) {
+        try {
+            const fs = await this.fs();
+            return await fs.readFile(await this.resolve(p), 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async readBinary(p) {
+        try {
+            const fs = await this.fs();
+            const buf = await fs.readFile(await this.resolve(p));
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(p, contents) {
+        const fs = await this.fs();
+        const path = await this.path();
+        const abs = await this.resolve(p);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        await fs.writeFile(abs, contents, 'utf-8');
+    }
+    async writeBinary(p, data) {
+        const fs = await this.fs();
+        const path = await this.path();
+        const abs = await this.resolve(p);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        await fs.writeFile(abs, data);
+    }
+    async deleteFile(p) {
+        const fs = await this.fs();
+        await fs.rm(await this.resolve(p), { recursive: true, force: true });
+    }
+    async readdir(p) {
+        try {
+            const fs = await this.fs();
+            const entries = await fs.readdir(await this.resolve(p), { withFileTypes: true });
+            return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async mkdir(p) {
+        const fs = await this.fs();
+        await fs.mkdir(await this.resolve(p), { recursive: true });
+    }
+    // ---- CommandExecutor ----
+    async exec(command, timeoutMs = 120_000, env) {
+        const cp = await this.cp();
+        const proc = globalThis.process;
+        const { shell, args } = this.shellFor(command);
+        return await new Promise((resolve) => {
+            let output = '';
+            let settled = false;
+            const child = cp.spawn(shell, args, {
+                cwd: this.cwd,
+                env: { ...proc?.env, ...this.opts.env, ...env },
+                windowsHide: true,
+            });
+            const finish = (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve({ output: output.trimEnd(), exitCode });
+            };
+            const timer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    /* ignore */
+                }
+                output += `\n[command timed out after ${timeoutMs}ms]`;
+                finish(124);
+            }, timeoutMs);
+            child.stdout?.on('data', (d) => (output += d.toString()));
+            child.stderr?.on('data', (d) => (output += d.toString()));
+            child.on('error', (err) => {
+                output += `\n[failed to spawn shell: ${err.message}]`;
+                finish(127);
+            });
+            child.on('close', (code) => finish(code ?? 0));
+        });
+    }
+    /** Pick the shell + args for the detected platform (overridable via options). */
+    shellFor(command) {
+        if (this.opts.shell) {
+            return { shell: this.opts.shell, args: [...(this.opts.shellArgs ?? []), command] };
+        }
+        if (this.platform === 'windows') {
+            // cmd.exe is universally present; /d skips AutoRun, /s /c runs the string.
+            return { shell: 'cmd.exe', args: ['/d', '/s', '/c', command] };
+        }
+        const proc = globalThis.process;
+        const shell = proc?.env?.SHELL || '/bin/sh';
+        return { shell, args: ['-c', command] };
+    }
+}
+export function createLocalSandbox(options) {
+    return new LocalSandbox(options);
+}

package/dist/sandbox/types.d.ts

@@ -0,0 +1,18 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+export type ExecResult = {
+    output: string;
+    exitCode: number;
+};
+/** A runnable workspace: files + commands, optionally rooted at a cwd. */
+export interface Sandbox extends FileSystem, CommandExecutor {
+    readonly cwd?: string;
+    /** Optional lifecycle hooks (some providers need explicit setup/teardown). */
+    init?(): Promise<void>;
+    dispose?(): Promise<void>;
+}
+/**
+ * Mix any FileSystem with any CommandExecutor into a single Sandbox. Useful for
+ * pairing a persistent local FS (Dexie/OPFS) with a remote shell, or a
+ * file-only agent (with NoopCommandExecutor).
+ */
+export declare function composeWorkspace(fs: FileSystem, exec: CommandExecutor, cwd?: string): Sandbox;

package/dist/sandbox/types.js

@@ -0,0 +1,27 @@
+// Sandbox provider abstraction. A Sandbox is just a FileSystem plus a
+// CommandExecutor — the same `Workspace` the agent loop consumes. Adapters wrap
+// each provider's client (WebContainer, E2B, Vercel, Daytona, Cloudflare, …)
+// without a hard dependency on their SDKs (structural typing).
+import { resolvePath } from '../util/paths.js';
+/**
+ * Mix any FileSystem with any CommandExecutor into a single Sandbox. Useful for
+ * pairing a persistent local FS (Dexie/OPFS) with a remote shell, or a
+ * file-only agent (with NoopCommandExecutor).
+ */
+export function composeWorkspace(fs, exec, cwd) {
+    // When a cwd is given it is authoritative: relative paths resolve against it
+    // before hitting the underlying FS (whose own cwd may differ). Absolute paths
+    // pass through unchanged.
+    const r = cwd ? (p) => resolvePath(cwd, p) : (p) => p;
+    return {
+        cwd,
+        readFile: (p) => fs.readFile(r(p)),
+        readBinary: (p) => fs.readBinary(r(p)),
+        writeFile: (p, c) => fs.writeFile(r(p), c),
+        writeBinary: (p, d) => fs.writeBinary(r(p), d),
+        deleteFile: (p) => fs.deleteFile(r(p)),
+        readdir: (p) => fs.readdir(r(p)),
+        mkdir: (p) => fs.mkdir(r(p)),
+        exec: (cmd, timeoutMs, env) => exec.exec(cmd, timeoutMs, env),
+    };
+}

package/dist/sandbox/util.d.ts

@@ -0,0 +1,15 @@
+/** Encode bytes to base64 (browser btoa or Node Buffer), chunked for big inputs. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Decode base64 to bytes (browser atob or Node Buffer). */
+export declare function base64ToBytes(b64: string): Uint8Array;
+type StreamLike = ReadableStream<Uint8Array | string>;
+type ValueLike = string | Uint8Array | ArrayBuffer | StreamLike | null | undefined;
+/** A provider value that may be the data directly or a thunk/promise returning it. */
+export type MaybeAsync<T> = T | (() => T | Promise<T>) | Promise<T>;
+/** Coerce a provider value (possibly async / a stream) into a string. */
+export declare function toText(value: MaybeAsync<ValueLike>): Promise<string>;
+/** Coerce a provider value (possibly async / a stream) into bytes. */
+export declare function toBytes(value: MaybeAsync<ValueLike>): Promise<Uint8Array>;
+/** Shell-quote a single argument for safe interpolation into a command string. */
+export declare function shellQuote(s: string): string;
+export {};

package/dist/sandbox/util.js

@@ -0,0 +1,100 @@
+// Small browser-safe helpers shared by the sandbox adapters: base64 codec and
+// normalizers that coerce a provider's varied return shapes (string, bytes,
+// ArrayBuffer, ReadableStream, or a thunk returning any of those) into a
+// concrete string / Uint8Array.
+const CHUNK = 0x8000;
+/** Encode bytes to base64 (browser btoa or Node Buffer), chunked for big inputs. */
+export function bytesToBase64(bytes) {
+    const g = globalThis;
+    if (typeof g.btoa === 'function') {
+        let binary = '';
+        for (let i = 0; i < bytes.length; i += CHUNK) {
+            binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+        }
+        return g.btoa(binary);
+    }
+    const B = globalThis.Buffer;
+    if (B)
+        return B.from(bytes).toString('base64');
+    throw new Error('No base64 encoder available');
+}
+/** Decode base64 to bytes (browser atob or Node Buffer). */
+export function base64ToBytes(b64) {
+    const g = globalThis;
+    if (typeof g.atob === 'function') {
+        const binary = g.atob(b64);
+        const out = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            out[i] = binary.charCodeAt(i);
+        return out;
+    }
+    const B = globalThis.Buffer;
+    if (B)
+        return new Uint8Array(B.from(b64, 'base64'));
+    throw new Error('No base64 decoder available');
+}
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+async function unwrap(v) {
+    const r = typeof v === 'function' ? v() : v;
+    return await r;
+}
+async function readStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        const bytes = typeof value === 'string' ? encoder.encode(value) : value;
+        if (bytes) {
+            chunks.push(bytes);
+            total += bytes.length;
+        }
+    }
+    reader.releaseLock?.();
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+        out.set(c, off);
+        off += c.length;
+    }
+    return out;
+}
+/** Coerce a provider value (possibly async / a stream) into a string. */
+export async function toText(value) {
+    const v = await unwrap(value);
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    if (v instanceof Uint8Array)
+        return decoder.decode(v);
+    if (v instanceof ArrayBuffer)
+        return decoder.decode(new Uint8Array(v));
+    if (typeof v.getReader === 'function') {
+        return decoder.decode(await readStream(v));
+    }
+    return String(v);
+}
+/** Coerce a provider value (possibly async / a stream) into bytes. */
+export async function toBytes(value) {
+    const v = await unwrap(value);
+    if (v == null)
+        return new Uint8Array();
+    if (v instanceof Uint8Array)
+        return v;
+    if (v instanceof ArrayBuffer)
+        return new Uint8Array(v);
+    if (typeof v === 'string')
+        return encoder.encode(v);
+    if (typeof v.getReader === 'function') {
+        return readStream(v);
+    }
+    return encoder.encode(String(v));
+}
+/** Shell-quote a single argument for safe interpolation into a command string. */
+export function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/sandbox/vercel.d.ts

@@ -0,0 +1,48 @@
+import type { CommandExecutor, FileSystem } from '../types/index.js';
+import type { Sandbox } from './types.js';
+import { type MaybeAsync } from './util.js';
+interface VercelCommandResult {
+    exitCode?: number;
+    stdout?: MaybeAsync<string | Uint8Array>;
+    stderr?: MaybeAsync<string | Uint8Array>;
+}
+export interface VercelClientLike {
+    runCommand(opts: {
+        cmd: string;
+        args?: string[];
+        env?: Record<string, string>;
+        cwd?: string;
+    }): Promise<VercelCommandResult>;
+    readFile?(opts: {
+        path: string;
+    }): Promise<unknown>;
+    writeFiles?(files: Array<{
+        path: string;
+        content: Uint8Array | string;
+    }>): Promise<unknown>;
+    mkdir?(path: string): Promise<unknown>;
+}
+export declare class VercelSandbox implements Sandbox, FileSystem, CommandExecutor {
+    private readonly client;
+    readonly cwd: string;
+    constructor(client: VercelClientLike, cwd?: string);
+    private r;
+    /** Run a shell command string, returning combined output + exit code. */
+    private sh;
+    readFile(path: string): Promise<string | null>;
+    readBinary(path: string): Promise<Uint8Array | null>;
+    writeFile(path: string, contents: string): Promise<void>;
+    writeBinary(path: string, data: Uint8Array): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+    mkdir(path: string): Promise<void>;
+    exec(command: string, _timeoutMs?: number, env?: Record<string, string>): Promise<{
+        output: string;
+        exitCode: number;
+    }>;
+}
+export declare function createVercelSandbox(client: VercelClientLike, cwd?: string): VercelSandbox;
+export {};

package/dist/sandbox/vercel.js

@@ -0,0 +1,130 @@
+// Vercel Sandbox adapter.
+//
+// Wrap a `@vercel/sandbox` `Sandbox`:
+//
+//   import { Sandbox } from '@vercel/sandbox'
+//   const sbx = await Sandbox.create({ ... })
+//   const workspace = new VercelSandbox(sbx)
+//
+// Primary method used: sbx.runCommand({ cmd, args, env, cwd }) -> result with
+//   `.exitCode` and `.stdout()` / `.stderr()` (string | stream | thunk).
+//
+// File ops: the adapter prefers native methods when the client exposes them
+//   (readFile({path}), writeFiles([{path,content}]), mkdir(path)), and otherwise
+//   falls back to POSIX shell commands run via runCommand (cat / base64 / ls /
+//   mkdir -p / rm). The shell fallback assumes a Unix image with `base64`.
+import { dirname, resolvePath } from '../util/paths.js';
+import { base64ToBytes, bytesToBase64, shellQuote, toBytes, toText, } from './util.js';
+export class VercelSandbox {
+    constructor(client, cwd = '/vercel/sandbox') {
+        this.client = client;
+        this.cwd = cwd;
+    }
+    r(p) {
+        return resolvePath(this.cwd, p);
+    }
+    /** Run a shell command string, returning combined output + exit code. */
+    async sh(command) {
+        const res = await this.client.runCommand({
+            cmd: 'sh',
+            args: ['-c', command],
+            cwd: this.cwd,
+        });
+        const out = await toText(res.stdout);
+        const err = await toText(res.stderr);
+        return {
+            output: (out + (err ? (out ? '\n' : '') + err : '')).trimEnd(),
+            exitCode: res.exitCode ?? 0,
+        };
+    }
+    async readFile(path) {
+        const abs = this.r(path);
+        if (this.client.readFile) {
+            try {
+                return await toText((await this.client.readFile({ path: abs })));
+            }
+            catch {
+                return null;
+            }
+        }
+        const { output, exitCode } = await this.sh(`cat ${shellQuote(abs)}`);
+        return exitCode === 0 ? output : null;
+    }
+    async readBinary(path) {
+        const abs = this.r(path);
+        if (this.client.readFile) {
+            try {
+                return await toBytes((await this.client.readFile({ path: abs })));
+            }
+            catch {
+                return null;
+            }
+        }
+        const { output, exitCode } = await this.sh(`base64 ${shellQuote(abs)} | tr -d '\\n'`);
+        if (exitCode !== 0)
+            return null;
+        try {
+            return base64ToBytes(output.trim());
+        }
+        catch {
+            return null;
+        }
+    }
+    async writeFile(path, contents) {
+        await this.writeBinary(path, new TextEncoder().encode(contents));
+    }
+    async writeBinary(path, data) {
+        const abs = this.r(path);
+        if (this.client.writeFiles) {
+            await this.client.writeFiles([{ path: abs, content: data }]);
+            return;
+        }
+        // Shell fallback: recreate parent dir and pipe base64 through `base64 -d`.
+        const b64 = bytesToBase64(data);
+        const dir = dirname(abs);
+        const { exitCode, output } = await this.sh(`mkdir -p ${shellQuote(dir)} && printf %s ${shellQuote(b64)} | base64 -d > ${shellQuote(abs)}`);
+        if (exitCode !== 0)
+            throw new Error(`writeFile failed: ${output}`);
+    }
+    async deleteFile(path) {
+        await this.sh(`rm -rf ${shellQuote(this.r(path))}`);
+    }
+    async readdir(path) {
+        // `ls -1Ap` lists one-per-line, all entries, with a trailing '/' on dirs.
+        const { output, exitCode } = await this.sh(`ls -1Ap ${shellQuote(this.r(path))}`);
+        if (exitCode !== 0)
+            return null;
+        return output
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .map((name) => name.endsWith('/')
+            ? { name: name.slice(0, -1), isDir: true }
+            : { name, isDir: false });
+    }
+    async mkdir(path) {
+        const abs = this.r(path);
+        if (this.client.mkdir) {
+            await this.client.mkdir(abs);
+            return;
+        }
+        await this.sh(`mkdir -p ${shellQuote(abs)}`);
+    }
+    async exec(command, _timeoutMs, env) {
+        const res = await this.client.runCommand({
+            cmd: 'sh',
+            args: ['-c', command],
+            env,
+            cwd: this.cwd,
+        });
+        const out = await toText(res.stdout);
+        const err = await toText(res.stderr);
+        return {
+            output: (out + (err ? (out ? '\n' : '') + err : '')).trimEnd(),
+            exitCode: res.exitCode ?? 0,
+        };
+    }
+}
+export function createVercelSandbox(client, cwd) {
+    return new VercelSandbox(client, cwd);
+}

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export { SessionStore } from './store.js';
+export type { SessionMeta, StoredSession, SessionStoreOptions } from './types.js';

package/dist/session/index.js

@@ -0,0 +1,6 @@
+// Session persistence + resume for browser-claude-sdk.
+//
+// SessionStore persists per-session metadata and the full LLM transcript to
+// IndexedDB (via Dexie), enabling listSessions / resume / fork / rename across
+// reloads.
+export { SessionStore } from './store.js';

package/dist/session/store.d.ts

@@ -0,0 +1,28 @@
+import type { ChatMsg } from '../types/index.js';
+import type { SessionMeta, SessionStoreOptions, StoredSession } from './types.js';
+export declare class SessionStore {
+    private readonly dbName;
+    private db;
+    private opening;
+    constructor(options?: SessionStoreOptions);
+    private open;
+    /** Upsert a session's transcript + metadata. */
+    save(sessionId: string, transcript: ChatMsg[], meta?: {
+        title?: string;
+        model?: string;
+    }): Promise<void>;
+    /** Load a session's transcript, or null if not found. */
+    load(sessionId: string): Promise<ChatMsg[] | null>;
+    /** Load full session (metadata + transcript), or null if not found. */
+    get(sessionId: string): Promise<StoredSession | null>;
+    /** List all sessions (metadata only), newest first. */
+    list(): Promise<SessionMeta[]>;
+    /** Set a session's title. */
+    rename(sessionId: string, title: string): Promise<void>;
+    /** Copy a session's transcript + metadata to a new id. Returns false if source missing. */
+    fork(sessionId: string, newSessionId: string): Promise<boolean>;
+    /** Delete a session and its transcript. */
+    remove(sessionId: string): Promise<void>;
+    /** Wipe all sessions. */
+    clear(): Promise<void>;
+}

package/dist/session/store.js

@@ -0,0 +1,122 @@
+// SessionStore — durable session persistence + resume, backed by IndexedDB via
+// Dexie. Stores per-session metadata and the full LLM transcript (ChatMsg[]),
+// enabling listSessions/resume/fork/rename across page reloads.
+//
+// `dexie` is an OPTIONAL peer dependency — imported dynamically so this module
+// loads even when Dexie isn't installed (the error surfaces only on first use).
+export class SessionStore {
+    constructor(options = {}) {
+        this.db = null;
+        this.opening = null;
+        this.dbName = options.dbName ?? 'bcs-sessions';
+    }
+    async open() {
+        if (this.db)
+            return this.db;
+        if (this.opening)
+            return this.opening;
+        this.opening = (async () => {
+            // @ts-ignore optional peer dependency, resolved at runtime
+            const mod = await import('dexie');
+            const Dexie = mod.default ?? mod;
+            const db = new Dexie(this.dbName);
+            db.version(1).stores({
+                sessions: 'sessionId, updatedAt',
+                transcripts: 'sessionId',
+            });
+            this.db = db;
+            return db;
+        })();
+        return this.opening;
+    }
+    /** Upsert a session's transcript + metadata. */
+    async save(sessionId, transcript, meta = {}) {
+        const db = await this.open();
+        const now = Date.now();
+        const existing = await db.sessions.get(sessionId);
+        const row = {
+            sessionId,
+            title: meta.title ?? existing?.title,
+            model: meta.model ?? existing?.model,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+            messageCount: transcript.length,
+        };
+        await db.sessions.put(row);
+        await db.transcripts.put({ sessionId, transcript });
+    }
+    /** Load a session's transcript, or null if not found. */
+    async load(sessionId) {
+        try {
+            const db = await this.open();
+            const row = await db.transcripts.get(sessionId);
+            return row?.transcript ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Load full session (metadata + transcript), or null if not found. */
+    async get(sessionId) {
+        try {
+            const db = await this.open();
+            const meta = await db.sessions.get(sessionId);
+            if (!meta)
+                return null;
+            const t = await db.transcripts.get(sessionId);
+            return { ...meta, transcript: t?.transcript ?? [] };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** List all sessions (metadata only), newest first. */
+    async list() {
+        try {
+            const db = await this.open();
+            const rows = await db.sessions.toArray();
+            return rows.sort((a, b) => b.updatedAt - a.updatedAt);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Set a session's title. */
+    async rename(sessionId, title) {
+        const db = await this.open();
+        const meta = await db.sessions.get(sessionId);
+        if (!meta)
+            return;
+        await db.sessions.put({ ...meta, title, updatedAt: Date.now() });
+    }
+    /** Copy a session's transcript + metadata to a new id. Returns false if source missing. */
+    async fork(sessionId, newSessionId) {
+        const db = await this.open();
+        const meta = await db.sessions.get(sessionId);
+        const t = await db.transcripts.get(sessionId);
+        if (!meta || !t)
+            return false;
+        const now = Date.now();
+        await db.sessions.put({
+            ...meta,
+            sessionId: newSessionId,
+            title: (meta.title ?? sessionId) + ' (fork)',
+            createdAt: now,
+            updatedAt: now,
+        });
+        await db.transcripts.put({ sessionId: newSessionId, transcript: t.transcript });
+        return true;
+    }
+    /** Delete a session and its transcript. */
+    async remove(sessionId) {
+        const db = await this.open();
+        await db.sessions.delete(sessionId);
+        await db.transcripts.delete(sessionId);
+    }
+    /** Wipe all sessions. */
+    async clear() {
+        const db = await this.open();
+        await db.sessions.clear();
+        await db.transcripts.clear();
+    }
+}

package/dist/session/types.d.ts

@@ -0,0 +1,22 @@
+import type { ChatMsg } from '../types/index.js';
+/** Lightweight metadata for a stored session (no transcript). */
+export interface SessionMeta {
+    sessionId: string;
+    title?: string;
+    /** Epoch ms when the session was first saved. */
+    createdAt: number;
+    /** Epoch ms of the last save. */
+    updatedAt: number;
+    /** Model id last used in the session. */
+    model?: string;
+    /** Number of transcript messages at last save. */
+    messageCount: number;
+}
+/** A full stored session: metadata plus the LLM transcript. */
+export type StoredSession = SessionMeta & {
+    transcript: ChatMsg[];
+};
+export interface SessionStoreOptions {
+    /** IndexedDB database name. Default: 'bcs-sessions'. */
+    dbName?: string;
+}