bashkit 0.3.1 → 0.3.2

package/dist/durable/durable-session.d.ts

@@ -0,0 +1,220 @@
+import { Agent } from "agents";
+import { AIChatAgent } from "agents/ai-chat-agent";
+import type { Connection, ConnectionContext, WSMessage } from "agents";
+import type { Sandbox } from "../sandbox/interface";
+/**
+ * Configuration for creating a BashKit agent with sandbox support.
+ */
+export interface BashKitAgentConfig<TEnv = unknown> {
+    /**
+     * Sandbox lifecycle configuration.
+     */
+    sandbox: {
+        /**
+         * Create a new sandbox instance.
+         */
+        create: (env: TEnv) => Promise<Sandbox>;
+        /**
+         * Reconnect to an existing sandbox by ID.
+         */
+        reconnect: (sandboxId: string, env: TEnv) => Promise<Sandbox>;
+    };
+}
+/**
+ * Base class for BashKit agents with sandbox support.
+ * Extends the Cloudflare Agents SDK Agent class.
+ *
+ * @example
+ * ```typescript
+ * import { BashKitAgent } from 'bashkit/durable';
+ * import { createE2BSandbox } from 'bashkit';
+ *
+ * export class MyAgent extends BashKitAgent<Env> {
+ *   getSandboxConfig() {
+ *     return {
+ *       create: () => createE2BSandbox({ apiKey: this.env.E2B_API_KEY }),
+ *       reconnect: (id) => createE2BSandbox({ apiKey: this.env.E2B_API_KEY, sandboxId: id }),
+ *     };
+ *   }
+ *
+ *   async onMessage(connection: Connection, message: WSMessage) {
+ *     // Access sandbox via this.getSandbox()
+ *     const sandbox = this.getSandbox();
+ *     const result = await sandbox.commands.run('echo hello');
+ *     connection.send(JSON.stringify({ output: result.stdout }));
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BashKitAgent<TEnv = unknown, TState = unknown> extends Agent<TEnv, TState> {
+    /**
+     * Environment bindings (typed from generic).
+     * Exposed from parent class for TypeScript access.
+     */
+    env: TEnv;
+    /**
+     * The sandbox instance. Available after onStart() completes.
+     */
+    private _sandbox;
+    /**
+     * Override this to configure sandbox creation/reconnection.
+     * Called with access to this.env.
+     */
+    protected abstract getSandboxConfig(): BashKitAgentConfig<TEnv>["sandbox"];
+    /**
+     * Called when the agent starts. Initializes the sandbox.
+     */
+    onStart(): Promise<void>;
+    /**
+     * Initialize or reconnect to sandbox.
+     */
+    private initSandbox;
+    /**
+     * Create a new sandbox and persist its ID.
+     */
+    private createNewSandbox;
+    /**
+     * Ensure schema exists. Called automatically in onStart.
+     */
+    private ensureSchema;
+    /**
+     * Get the current sandbox, throwing if not initialized.
+     */
+    protected getSandbox(): Sandbox;
+    /**
+     * Check if sandbox is initialized.
+     */
+    protected hasSandbox(): boolean;
+}
+/**
+ * Factory function to create a BashKit agent class with sandbox support.
+ * This is an alternative to extending BashKitAgent directly.
+ *
+ * @example
+ * ```typescript
+ * import { createBashKitAgent } from 'bashkit/durable';
+ * import { createE2BSandbox } from 'bashkit';
+ *
+ * const BaseBashKitAgent = createBashKitAgent<Env>({
+ *   sandbox: {
+ *     create: (env) => createE2BSandbox({ apiKey: env.E2B_API_KEY }),
+ *     reconnect: (id, env) => createE2BSandbox({ apiKey: env.E2B_API_KEY, sandboxId: id }),
+ *   },
+ * });
+ *
+ * export class MyAgent extends BaseBashKitAgent {
+ *   async onMessage(connection, message) {
+ *     const sandbox = this.getSandbox();
+ *     const result = await sandbox.commands.run('echo hello');
+ *     connection.send(JSON.stringify({ output: result.stdout }));
+ *   }
+ * }
+ * ```
+ */
+export declare function createBashKitAgent<TEnv = unknown, TState = unknown>(config: BashKitAgentConfig<TEnv>): typeof BashKitAgent<TEnv, TState>;
+/**
+ * Base class for BashKit chat agents with sandbox support.
+ * Extends AIChatAgent for built-in chat handling + adds sandbox lifecycle management.
+ *
+ * Use this when building chat-based agents that need sandbox access.
+ * You get:
+ * - `this.messages` - automatic chat history
+ * - `onChatMessage()` - implement to handle chat, return streaming response
+ * - `getSandbox()` - access the E2B sandbox
+ * - Resumable streaming out of the box
+ * - Works with `useAgentChat` on the frontend
+ *
+ * @example
+ * ```typescript
+ * import { BashKitChatAgent } from 'bashkit/durable';
+ * import { createE2BSandbox, createAgentTools } from 'bashkit';
+ * import { streamText } from 'ai';
+ * import { anthropic } from '@ai-sdk/anthropic';
+ *
+ * export class MyChatAgent extends BashKitChatAgent<Env> {
+ *   getSandboxConfig() {
+ *     return {
+ *       create: () => createE2BSandbox({ apiKey: this.env.E2B_API_KEY }),
+ *       reconnect: (id) => createE2BSandbox({ apiKey: this.env.E2B_API_KEY, sandboxId: id }),
+ *     };
+ *   }
+ *
+ *   async onChatMessage() {
+ *     const sandbox = this.getSandbox();
+ *     const tools = createAgentTools(sandbox);
+ *
+ *     return streamText({
+ *       model: anthropic('claude-sonnet-4-20250514'),
+ *       messages: this.messages,
+ *       tools,
+ *     }).toUIMessageStreamResponse();
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BashKitChatAgent<TEnv = unknown, TState = unknown> extends AIChatAgent<TEnv, TState> {
+    /**
+     * Environment bindings (typed from generic).
+     */
+    env: TEnv;
+    /**
+     * The sandbox instance. Available after onStart() completes.
+     */
+    private _sandbox;
+    /**
+     * Override this to configure sandbox creation/reconnection.
+     */
+    protected abstract getSandboxConfig(): BashKitAgentConfig<TEnv>["sandbox"];
+    /**
+     * Called when the agent starts. Initializes the sandbox.
+     * If you override this, make sure to call super.onStart().
+     */
+    onStart(): Promise<void>;
+    /**
+     * Initialize or reconnect to sandbox.
+     */
+    private initSandbox;
+    /**
+     * Create a new sandbox and persist its ID.
+     */
+    private createNewSandbox;
+    /**
+     * Ensure sandbox schema exists.
+     */
+    private ensureSandboxSchema;
+    /**
+     * Get the current sandbox, throwing if not initialized.
+     */
+    protected getSandbox(): Sandbox;
+    /**
+     * Check if sandbox is initialized.
+     */
+    protected hasSandbox(): boolean;
+}
+/**
+ * Factory function to create a BashKit chat agent class with sandbox support.
+ *
+ * @example
+ * ```typescript
+ * import { createBashKitChatAgent } from 'bashkit/durable';
+ * import { createE2BSandbox, createAgentTools } from 'bashkit';
+ *
+ * const BaseChatAgent = createBashKitChatAgent<Env>({
+ *   sandbox: {
+ *     create: (env) => createE2BSandbox({ apiKey: env.E2B_API_KEY }),
+ *     reconnect: (id, env) => createE2BSandbox({ apiKey: env.E2B_API_KEY, sandboxId: id }),
+ *   },
+ * });
+ *
+ * export class MyChatAgent extends BaseChatAgent {
+ *   async onChatMessage() {
+ *     const tools = createAgentTools(this.getSandbox());
+ *     return streamText({ ... }).toUIMessageStreamResponse();
+ *   }
+ * }
+ * ```
+ */
+export declare function createBashKitChatAgent<TEnv = unknown, TState = unknown>(config: BashKitAgentConfig<TEnv>): typeof BashKitChatAgent<TEnv, TState>;
+export type { Connection, ConnectionContext, WSMessage };
+export { Agent } from "agents";
+export { AIChatAgent } from "agents/ai-chat-agent";

package/dist/durable/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * bashkit/durable - Durable agent sessions with Cloudflare Agents SDK
+ *
+ * This module provides sandbox-integrated agents built on the Cloudflare Agents SDK.
+ * It extends the Agent class with automatic sandbox lifecycle management.
+ *
+ * @example
+ * ```typescript
+ * import { BashKitAgent, createBashKitAgent } from 'bashkit/durable';
+ * import { createE2BSandbox } from 'bashkit';
+ *
+ * // Option 1: Extend BashKitAgent directly
+ * export class MyAgent extends BashKitAgent<Env> {
+ *   sandboxConfig = {
+ *     create: () => createE2BSandbox({ apiKey: this.env.E2B_API_KEY }),
+ *     reconnect: (id) => createE2BSandbox({ apiKey: this.env.E2B_API_KEY, sandboxId: id }),
+ *   };
+ *
+ *   async onMessage(connection, message) {
+ *     const result = await this.sandbox.commands.run('echo hello');
+ *     connection.send(JSON.stringify({ output: result.stdout }));
+ *   }
+ * }
+ *
+ * // Option 2: Use factory function
+ * const BaseBashKitAgent = createBashKitAgent({
+ *   sandbox: {
+ *     create: (env) => createE2BSandbox({ apiKey: env.E2B_API_KEY }),
+ *     reconnect: (id, env) => createE2BSandbox({ apiKey: env.E2B_API_KEY, sandboxId: id }),
+ *   },
+ * });
+ *
+ * export class MyAgent extends BaseBashKitAgent {
+ *   async onMessage(connection, message) {
+ *     // Your agent logic
+ *   }
+ * }
+ * ```
+ */
+export { BashKitAgent, createBashKitAgent, BashKitChatAgent, createBashKitChatAgent, Agent, AIChatAgent, } from "./durable-session";
+export type { BashKitAgentConfig, Connection, ConnectionContext, WSMessage, } from "./durable-session";

package/dist/durable/index.js

@@ -0,0 +1,159 @@
+// src/durable/durable-session.ts
+import { Agent } from "agents";
+import { AIChatAgent } from "agents/ai-chat-agent";
+import { Agent as Agent2 } from "agents";
+import { AIChatAgent as AIChatAgent2 } from "agents/ai-chat-agent";
+
+class BashKitAgent extends Agent {
+  _sandbox = null;
+  async onStart() {
+    this.ensureSchema();
+    await this.initSandbox();
+  }
+  async initSandbox() {
+    const config = this.getSandboxConfig();
+    let existingSandboxId = null;
+    try {
+      const rows = this.sql`
+        SELECT sandbox_id FROM _bashkit_sandbox WHERE id = 1
+      `;
+      existingSandboxId = rows[0]?.sandbox_id ?? null;
+    } catch {}
+    if (existingSandboxId) {
+      try {
+        this._sandbox = await config.reconnect(existingSandboxId, this.env);
+        console.log(`[bashkit] Reconnected to sandbox: ${existingSandboxId}`);
+      } catch (error) {
+        console.warn(`[bashkit] Failed to reconnect to sandbox ${existingSandboxId}, creating new:`, error);
+        await this.createNewSandbox(config);
+      }
+    } else {
+      await this.createNewSandbox(config);
+    }
+  }
+  async createNewSandbox(config) {
+    this._sandbox = await config.create(this.env);
+    if (this._sandbox.id) {
+      const now = Date.now();
+      const sandboxId = this._sandbox.id;
+      this.sql`
+        INSERT INTO _bashkit_sandbox (id, sandbox_id, status, created_at, updated_at)
+        VALUES (1, ${sandboxId}, 'active', ${now}, ${now})
+        ON CONFLICT(id) DO UPDATE SET
+          sandbox_id = ${sandboxId},
+          updated_at = ${now}
+      `;
+      console.log(`[bashkit] Created new sandbox: ${this._sandbox.id}`);
+    }
+  }
+  ensureSchema() {
+    this.sql`
+      CREATE TABLE IF NOT EXISTS _bashkit_sandbox (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        sandbox_id TEXT,
+        status TEXT DEFAULT 'active',
+        created_at INTEGER,
+        updated_at INTEGER
+      )
+    `;
+  }
+  getSandbox() {
+    if (!this._sandbox) {
+      throw new Error("Sandbox not initialized. Wait for onStart() to complete.");
+    }
+    return this._sandbox;
+  }
+  hasSandbox() {
+    return this._sandbox !== null;
+  }
+}
+function createBashKitAgent(config) {
+
+  class ConfiguredBashKitAgent extends BashKitAgent {
+    getSandboxConfig() {
+      return config.sandbox;
+    }
+  }
+  return ConfiguredBashKitAgent;
+}
+
+class BashKitChatAgent extends AIChatAgent {
+  _sandbox = null;
+  async onStart() {
+    this.ensureSandboxSchema();
+    await this.initSandbox();
+  }
+  async initSandbox() {
+    const config = this.getSandboxConfig();
+    let existingSandboxId = null;
+    try {
+      const rows = this.sql`
+        SELECT sandbox_id FROM _bashkit_sandbox WHERE id = 1
+      `;
+      existingSandboxId = rows[0]?.sandbox_id ?? null;
+    } catch {}
+    if (existingSandboxId) {
+      try {
+        this._sandbox = await config.reconnect(existingSandboxId, this.env);
+        console.log(`[bashkit] Reconnected to sandbox: ${existingSandboxId}`);
+      } catch (error) {
+        console.warn(`[bashkit] Failed to reconnect to sandbox ${existingSandboxId}, creating new:`, error);
+        await this.createNewSandbox(config);
+      }
+    } else {
+      await this.createNewSandbox(config);
+    }
+  }
+  async createNewSandbox(config) {
+    this._sandbox = await config.create(this.env);
+    if (this._sandbox.id) {
+      const now = Date.now();
+      const sandboxId = this._sandbox.id;
+      this.sql`
+        INSERT INTO _bashkit_sandbox (id, sandbox_id, status, created_at, updated_at)
+        VALUES (1, ${sandboxId}, 'active', ${now}, ${now})
+        ON CONFLICT(id) DO UPDATE SET
+          sandbox_id = ${sandboxId},
+          updated_at = ${now}
+      `;
+      console.log(`[bashkit] Created new sandbox: ${this._sandbox.id}`);
+    }
+  }
+  ensureSandboxSchema() {
+    this.sql`
+      CREATE TABLE IF NOT EXISTS _bashkit_sandbox (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        sandbox_id TEXT,
+        status TEXT DEFAULT 'active',
+        created_at INTEGER,
+        updated_at INTEGER
+      )
+    `;
+  }
+  getSandbox() {
+    if (!this._sandbox) {
+      throw new Error("Sandbox not initialized. Wait for onStart() to complete.");
+    }
+    return this._sandbox;
+  }
+  hasSandbox() {
+    return this._sandbox !== null;
+  }
+}
+function createBashKitChatAgent(config) {
+
+  class ConfiguredBashKitChatAgent extends BashKitChatAgent {
+    getSandboxConfig() {
+      return config.sandbox;
+    }
+  }
+  return ConfiguredBashKitChatAgent;
+}
+export {
+  createBashKitChatAgent,
+  createBashKitAgent,
+  BashKitChatAgent,
+  BashKitAgent,
+  Agent2 as Agent,
+  AIChatAgent2 as AIChatAgent
+};

package/dist/durable/schema.d.ts

@@ -0,0 +1,51 @@
+import type { BashkitSessionRow, BashkitStreamBufferRow, SqlStorage, StreamBufferOptions } from "./types";
+/**
+ * Initialize the bashkit schema in the Durable Object's SQLite.
+ * Creates tables if they don't exist.
+ * Tables are prefixed with `_bashkit_` to avoid collisions with consumer tables.
+ */
+export declare function initSchema(sql: SqlStorage): void;
+/**
+ * Get the stored sandbox ID from the session table.
+ * @returns The sandbox ID or null if no session exists.
+ */
+export declare function getSandboxId(sql: SqlStorage): string | null;
+/**
+ * Save or update the sandbox ID in the session table.
+ */
+export declare function saveSandboxId(sql: SqlStorage, sandboxId: string): void;
+/**
+ * Update the session status.
+ */
+export declare function updateSessionStatus(sql: SqlStorage, status: "active" | "idle" | "disconnected"): void;
+/**
+ * Get the current session row.
+ */
+export declare function getSession(sql: SqlStorage): BashkitSessionRow | null;
+/**
+ * Add a chunk to the stream buffer.
+ * Used to allow reconnecting clients to catch up on missed messages.
+ */
+export declare function addToStreamBuffer(sql: SqlStorage, chunk: string): void;
+/**
+ * Get all buffered chunks, optionally since a specific timestamp.
+ * @param sinceTimestamp - Unix timestamp to get chunks after (exclusive)
+ */
+export declare function getStreamBuffer(sql: SqlStorage, sinceTimestamp?: number): BashkitStreamBufferRow[];
+/**
+ * Get just the chunk strings from the buffer.
+ */
+export declare function getBufferedChunks(sql: SqlStorage, sinceTimestamp?: number): string[];
+/**
+ * Clear the stream buffer.
+ * Typically called after all clients have caught up.
+ */
+export declare function clearStreamBuffer(sql: SqlStorage): void;
+/**
+ * Cleanup old chunks from the stream buffer based on options.
+ */
+export declare function cleanupStreamBuffer(sql: SqlStorage, options?: StreamBufferOptions): number;
+/**
+ * Get the count of chunks in the stream buffer.
+ */
+export declare function getStreamBufferCount(sql: SqlStorage): number;

package/dist/durable/types.d.ts

@@ -0,0 +1,208 @@
+import type { Sandbox } from "../sandbox/interface";
+/**
+ * Cloudflare Workers runtime types.
+ * These are minimal types to avoid requiring @cloudflare/workers-types as a hard dependency.
+ * Consumers using Cloudflare Workers will have full types from their own @cloudflare/workers-types.
+ */
+/**
+ * WebSocketPair for creating client/server WebSocket pairs.
+ * This is a Cloudflare Workers runtime global.
+ */
+export interface WebSocketPair {
+    0: WebSocket;
+    1: WebSocket;
+}
+/**
+ * Constructor for WebSocketPair.
+ */
+export interface WebSocketPairConstructor {
+    new (): WebSocketPair;
+}
+/**
+ * Extended ResponseInit that includes Cloudflare's webSocket property.
+ */
+export interface CloudflareResponseInit extends ResponseInit {
+    webSocket?: WebSocket;
+}
+/**
+ * Declare WebSocketPair on globalThis for Cloudflare Workers runtime.
+ */
+declare global {
+    var WebSocketPair: WebSocketPairConstructor | undefined;
+}
+/**
+ * Cloudflare Durable Object context types.
+ */
+export interface DurableObjectState {
+    id: DurableObjectId;
+    storage: DurableObjectStorage;
+    acceptWebSocket(ws: WebSocket): void;
+    getWebSockets(): WebSocket[];
+}
+export interface DurableObjectId {
+    toString(): string;
+    name?: string;
+}
+export interface DurableObjectStorage {
+    sql: SqlStorage;
+}
+export interface SqlStorage {
+    exec<T = Record<string, unknown>>(query: string, ...params: unknown[]): SqlStorageCursor<T>;
+}
+export interface SqlStorageCursor<T = Record<string, unknown>> {
+    toArray(): T[];
+    one(): T | null;
+    raw(): unknown[][];
+}
+/**
+ * Configuration for creating a durable session.
+ * @template TContext - Custom context type that consumers can extend
+ */
+export interface DurableSessionConfig<TContext = unknown> {
+    /**
+     * Name of the durable session (used for identification/logging).
+     */
+    name: string;
+    /**
+     * Sandbox lifecycle configuration.
+     */
+    sandbox: {
+        /**
+         * Create a new sandbox instance.
+         * Called when no existing sandbox ID is found in storage.
+         */
+        create: () => Promise<Sandbox>;
+        /**
+         * Reconnect to an existing sandbox by ID.
+         * Called when a sandbox ID is found in storage.
+         */
+        reconnect: (sandboxId: string) => Promise<Sandbox>;
+    };
+    /**
+     * Called when a new session starts (first connection, no existing sandbox).
+     * Use this to hydrate the sandbox with files, setup environment, etc.
+     */
+    onSessionStart?: (ctx: SessionContext<TContext>) => Promise<void>;
+    /**
+     * Called when a message is received from any connected client.
+     * This is where you implement your agent logic.
+     */
+    onMessage: (ctx: MessageContext<TContext>) => Promise<void>;
+    /**
+     * Called when the last client disconnects.
+     * Use this for cleanup, snapshotting, etc.
+     */
+    onDisconnect?: (ctx: SessionContext<TContext>) => Promise<void>;
+    /**
+     * Called when a client reconnects to an existing session.
+     * Use this to send catch-up data to the reconnecting client.
+     */
+    onReconnect?: (ctx: ReconnectContext<TContext>) => Promise<void>;
+    /**
+     * Optional context factory. Called once per session to create custom context.
+     */
+    createContext?: (sessionId: string) => TContext | Promise<TContext>;
+}
+/**
+ * Base context available in all lifecycle hooks.
+ */
+export interface SessionContext<TContext = unknown> {
+    /**
+     * The sandbox instance (created or reconnected).
+     */
+    sandbox: Sandbox;
+    /**
+     * Durable Object's SQLite storage for custom data.
+     * bashkit manages internal tables prefixed with `_bashkit_`.
+     */
+    sql: SqlStorage;
+    /**
+     * Unique session identifier (Durable Object ID).
+     */
+    sessionId: string;
+    /**
+     * Custom context created by `createContext` config.
+     */
+    context: TContext;
+    /**
+     * Broadcast a message to all connected clients.
+     */
+    broadcast: (message: unknown) => void;
+}
+/**
+ * Context available in the `onMessage` handler.
+ */
+export interface MessageContext<TContext = unknown> extends SessionContext<TContext> {
+    /**
+     * The message received from the client.
+     */
+    message: unknown;
+    /**
+     * The WebSocket connection that sent the message.
+     */
+    connection: WebSocket;
+}
+/**
+ * Context available in the `onReconnect` handler.
+ */
+export interface ReconnectContext<TContext = unknown> extends SessionContext<TContext> {
+    /**
+     * The WebSocket connection that is reconnecting.
+     */
+    connection: WebSocket;
+    /**
+     * Buffered chunks from the stream buffer (if any).
+     * These are messages that were broadcast while this client was disconnected.
+     */
+    bufferedChunks: string[];
+}
+/**
+ * Internal session state stored in SQLite.
+ */
+export interface BashkitSessionRow {
+    id: number;
+    sandbox_id: string | null;
+    status: "active" | "idle" | "disconnected";
+    created_at: number;
+    updated_at: number;
+}
+/**
+ * Internal stream buffer row stored in SQLite.
+ */
+export interface BashkitStreamBufferRow {
+    id: number;
+    chunk: string;
+    created_at: number;
+}
+/**
+ * Options for buffering stream chunks.
+ */
+export interface StreamBufferOptions {
+    /**
+     * Maximum number of chunks to keep in the buffer.
+     * Older chunks are deleted when this limit is exceeded.
+     * @default 1000
+     */
+    maxChunks?: number;
+    /**
+     * Maximum age of chunks in seconds.
+     * Chunks older than this are deleted on cleanup.
+     * @default 300 (5 minutes)
+     */
+    maxAgeSeconds?: number;
+}
+/**
+ * The generated Durable Object class type.
+ */
+export interface DurableSessionClass {
+    new (state: DurableObjectState, env: unknown): DurableSessionInstance;
+}
+/**
+ * Instance of a generated Durable Session.
+ */
+export interface DurableSessionInstance {
+    fetch(request: Request): Promise<Response>;
+    webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void>;
+    webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+    webSocketError(ws: WebSocket, error: unknown): void;
+}

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export type { AgentConfig, AskUserConfig, CacheConfig, SkillConfig, ToolConfig,
 export { DEFAULT_CONFIG } from "./types";
 export type { CachedTool, CacheEntry, CacheOptions, CacheStats, CacheStore, RedisCacheStoreOptions, RedisClient, } from "./cache";
 export { cached, createRedisCacheStore, LRUCacheStore } from "./cache";
-export type { CompactConversationConfig, CompactConversationResult, CompactConversationState, ContextMetrics, ContextStatus, ContextStatusConfig, ContextStatusLevel, ModelContextLimit, PruneMessagesConfig, } from "./utils";
-export { compactConversation, contextNeedsAttention, contextNeedsCompaction, createCompactConfig, estimateMessagesTokens, estimateMessageTokens, estimateTokens, getContextStatus, MODEL_CONTEXT_LIMITS, pruneMessagesByTokens, } from "./utils";
+export type { CompactConversationConfig, CompactConversationResult, CompactConversationState, ContextMetrics, ContextStatus, ContextStatusConfig, ContextStatusLevel, DebugEvent, ModelContextLimit, PruneMessagesConfig, } from "./utils";
+export { clearDebugLogs, compactConversation, contextNeedsAttention, contextNeedsCompaction, createCompactConfig, estimateMessagesTokens, estimateMessageTokens, estimateTokens, getContextStatus, getDebugLogs, isDebugEnabled, MODEL_CONTEXT_LIMITS, pruneMessagesByTokens, reinitDebugMode, } from "./utils";
 export type { DiscoverSkillsOptions, SkillBundle, SkillMetadata, } from "./skills";
 export { discoverSkills, fetchSkill, fetchSkills, loadSkillBundle, loadSkillBundles, parseSkillMetadata, skillsToXml, } from "./skills";
 export type { AgentEnvironmentConfig, SetupResult, SkillContent, } from "./setup";