@everworker/oneringai 0.4.7 → 0.5.0

package/dist/{index-D8RCwpK9.d.cts → index-t4cRhBZW.d.cts}

@@ -98,6 +98,148 @@ interface ReasoningItem {
 type InputItem = Message | CompactionItem;
 type OutputItem = Message | CompactionItem | ReasoningItem;
 
+/**
+ * IHistoryJournal - Interface for append-only conversation history logging
+ *
+ * Provides a durable, append-only log of all conversation messages,
+ * independent of context compaction. While the agent's working window
+ * (_conversation) may be compacted to fit the LLM context, the journal
+ * preserves the full conversation history on disk/database.
+ *
+ * The journal is a companion capability of IContextStorage — storage
+ * implementations that support history logging expose it via the
+ * `journal` property. Consumers never configure the journal separately;
+ * it comes for free with the storage backend.
+ *
+ * Access patterns:
+ * - **Write**: append-only, per-message, fire-and-forget (non-blocking)
+ * - **Read**: on-demand, explicit (never loaded automatically)
+ *
+ * @example
+ * ```typescript
+ * // File storage → FileHistoryJournal (JSONL files)
+ * const storage = new FileContextStorage({ agentId: 'my-agent' });
+ * storage.journal.append('session-1', [entry]);
+ *
+ * // Mongo storage → MongoHistoryJournal (collection)
+ * const storage = new MongoContextStorage({ agentId: 'my-agent', db });
+ * storage.journal.append('session-1', [entry]);
+ *
+ * // Reading history (on-demand, explicit)
+ * const entries = await storage.journal.read('session-1', { limit: 50 });
+ * const total = await storage.journal.count('session-1');
+ * ```
+ */
+
+/**
+ * Type of history entry, derived from the message's role/purpose.
+ */
+type HistoryEntryType = 'user' | 'assistant' | 'tool_result' | 'system';
+/**
+ * A single entry in the history journal.
+ *
+ * Wraps an InputItem with metadata for ordering and filtering.
+ * The `item` field is the exact InputItem as it was added to the conversation,
+ * preserving full fidelity (including __images, tool_use_id, etc.).
+ */
+interface HistoryEntry {
+    /** When this entry was recorded (epoch ms) */
+    timestamp: number;
+    /** Entry type for filtering */
+    type: HistoryEntryType;
+    /** The actual conversation item (Message or CompactionItem) */
+    item: InputItem;
+    /**
+     * Monotonically increasing turn counter.
+     * A "turn" is one user message + one assistant response (+ any tool calls in between).
+     * Useful for grouping related messages and pagination.
+     */
+    turnIndex: number;
+}
+/**
+ * Options for reading history entries.
+ */
+interface HistoryReadOptions {
+    /** Skip this many entries from the start */
+    offset?: number;
+    /** Maximum number of entries to return */
+    limit?: number;
+    /** Filter by entry type(s) */
+    types?: HistoryEntryType[];
+    /** Only entries after this timestamp (epoch ms, inclusive) */
+    after?: number;
+    /** Only entries before this timestamp (epoch ms, inclusive) */
+    before?: number;
+    /** Only entries from this turn index onwards (inclusive) */
+    fromTurn?: number;
+    /** Only entries up to this turn index (inclusive) */
+    toTurn?: number;
+}
+/**
+ * Append-only history journal for conversation persistence.
+ *
+ * Implementations:
+ * - FileHistoryJournal: JSONL files at ~/.oneringai/agents/<agentId>/sessions/<sessionId>.history.jsonl
+ * - (Future) MongoHistoryJournal: MongoDB collection
+ * - (Future) RedisHistoryJournal: Redis Streams
+ */
+interface IHistoryJournal {
+    /**
+     * Append entries to the journal.
+     *
+     * This is the primary write operation, called on every addUserMessage(),
+     * addAssistantResponse(), and addToolResults(). Should be fast (append-only).
+     *
+     * @param sessionId - Session to append to
+     * @param entries - One or more history entries to append
+     */
+    append(sessionId: string, entries: HistoryEntry[]): Promise<void>;
+    /**
+     * Read history entries with optional filtering and pagination.
+     *
+     * Entries are returned in chronological order (oldest first).
+     *
+     * @param sessionId - Session to read from
+     * @param options - Filtering and pagination options
+     * @returns Array of history entries
+     */
+    read(sessionId: string, options?: HistoryReadOptions): Promise<HistoryEntry[]>;
+    /**
+     * Get the total number of entries in the journal.
+     *
+     * @param sessionId - Session to count
+     * @returns Number of entries (0 if session has no journal)
+     */
+    count(sessionId: string): Promise<number>;
+    /**
+     * Delete all history for a session.
+     *
+     * Called when a session is deleted via IContextStorage.delete().
+     *
+     * @param sessionId - Session to clear
+     */
+    clear(sessionId: string): Promise<void>;
+    /**
+     * Stream history entries for large histories.
+     *
+     * Optional — implementations may omit this if streaming isn't practical
+     * (e.g., in-memory storage). Callers should fall back to read() with
+     * pagination if stream() is not available.
+     *
+     * @param sessionId - Session to stream
+     * @param options - Same filtering options as read()
+     * @returns AsyncIterable of history entries in chronological order
+     */
+    stream?(sessionId: string, options?: HistoryReadOptions): AsyncIterable<HistoryEntry>;
+    /**
+     * Get a human-readable location string for debugging/display.
+     *
+     * @param sessionId - Session ID
+     * @returns Location string (file path, MongoDB URI, etc.)
+     */
+    getLocation?(sessionId: string): string;
+}
+
 /**
  * Memory entities for WorkingMemory
  *
@@ -373,6 +515,10 @@ interface ToolContext {
     identities?: AuthIdentity[];
     /** Connector registry scoped to this agent's allowed connectors and userId */
     connectorRegistry?: IConnectorRegistry;
+    /** User roles for permission policy evaluation */
+    roles?: string[];
+    /** Session ID for approval cache scoping */
+    sessionId?: string;
     /** Working memory access (if agent has memory feature enabled) */
     memory?: WorkingMemoryAccess;
     /** Abort signal for cancellation */
@@ -443,6 +589,47 @@ interface ToolExecutionContext {
     pendingNonBlocking: Set<string>;
     completedResults: Map<string, ToolResult>;
 }
+/**
+ * Configuration for async (non-blocking) tool behavior
+ */
+interface AsyncToolConfig {
+    /**
+     * If true, the agent automatically re-enters the agentic loop
+     * when async tool results arrive. If false, results are queued
+     * and the caller must call `continueWithAsyncResults()` manually.
+     * @default true
+     */
+    autoContinue?: boolean;
+    /**
+     * Window in ms to batch multiple async results before triggering
+     * a continuation. If multiple async tools complete within this window,
+     * their results are delivered together in a single user message.
+     * @default 500
+     */
+    batchWindowMs?: number;
+    /**
+     * Timeout in ms for async tool execution. If a tool doesn't complete
+     * within this window, it's treated as a timeout error.
+     * @default 300000 (5 minutes)
+     */
+    asyncTimeout?: number;
+}
+/**
+ * Status of a pending async tool execution
+ */
+type PendingAsyncToolStatus = 'running' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+/**
+ * Tracks a single async tool execution in flight
+ */
+interface PendingAsyncTool {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    startTime: number;
+    status: PendingAsyncToolStatus;
+    result?: ToolResult;
+    error?: Error;
+}
 /**
  * Output handling hints for context management
  */
@@ -723,6 +910,21 @@ interface IContextStorage {
      * Falls back to getPath() if not implemented.
      */
     getLocation?(): string;
+    /**
+     * History journal companion for full conversation logging.
+     *
+     * When present, AgentContextNextGen automatically appends every message
+     * to the journal (append-only, fire-and-forget). The journal is never
+     * affected by compaction, preserving full conversation history.
+     *
+     * Storage implementations create the appropriate journal for their backend:
+     * - FileContextStorage → FileHistoryJournal (JSONL files)
+     * - MongoContextStorage → MongoHistoryJournal (collection)
+     *
+     * Consumers never configure the journal separately — it comes for free
+     * with the storage backend.
+     */
+    readonly journal?: IHistoryJournal;
 }
 /**
  * Options for listing sessions
@@ -1055,12 +1257,6 @@ declare class ToolCatalogRegistry {
     static reset(): void;
 }
 
-/**
- * AgentContextNextGen - Type Definitions
- *
- * Clean, minimal type definitions for the next-generation context manager.
- */
-
 /**
  * A single auth identity: connector + optional account alias.
  *
@@ -1404,6 +1600,140 @@ interface IContextPluginNextGen {
      */
     restoreState(state: unknown): void;
 }
+/**
+ * Describes a store's schema for dynamic tool description generation.
+ * The `descriptionFactory` on each store tool uses this to build
+ * a comparison table so the LLM knows which store to use.
+ */
+interface StoreEntrySchema {
+    /** Short identifier used as the `store` parameter value (e.g., "memory", "context") */
+    storeId: string;
+    /** Human-readable store name (e.g., "Working Memory", "Live Context") */
+    displayName: string;
+    /** One-line description of what this store holds */
+    description: string;
+    /**
+     * "Use for:" guidance — tells the LLM when to pick this store.
+     * Should include explicit "NOT for:" guidance referencing other stores.
+     */
+    usageHint: string;
+    /**
+     * Human-readable description of the data fields accepted by storeSet.
+     * Shown in the store_set tool description. One line per field.
+     * Example: "description (required): Brief description of the data"
+     */
+    setDataFields: string;
+    /**
+     * Available actions for store_action, keyed by action name.
+     * If undefined or empty, this store has no actions.
+     */
+    actions?: Record<string, {
+        /** What this action does */
+        description: string;
+        /** Human-readable params description */
+        paramsDescription?: string;
+        /** If true, requires confirm: true parameter */
+        destructive?: boolean;
+    }>;
+}
+/**
+ * Result types for store operations.
+ * These are intentionally loose (Record-based) to accommodate
+ * store-specific fields in responses.
+ */
+interface StoreGetResult {
+    found: boolean;
+    key?: string;
+    /** Single entry data (when key provided) */
+    entry?: Record<string, unknown>;
+    /** All entries (when no key provided) */
+    entries?: Array<Record<string, unknown>>;
+}
+interface StoreSetResult {
+    success: boolean;
+    key: string;
+    message?: string;
+    [k: string]: unknown;
+}
+interface StoreDeleteResult {
+    deleted: boolean;
+    key: string;
+}
+interface StoreListResult {
+    entries: Array<Record<string, unknown>>;
+    total?: number;
+}
+interface StoreActionResult {
+    success: boolean;
+    action: string;
+    [k: string]: unknown;
+}
+/**
+ * Interface for plugins that provide CRUD storage.
+ *
+ * When a plugin implements both `IContextPluginNextGen` and `IStoreHandler`,
+ * it automatically gets the 5 generic `store_*` tools — no tool creation needed.
+ *
+ * ## How to implement a custom CRUD plugin
+ *
+ * 1. Create a class that extends `BasePluginNextGen` and implements `IStoreHandler`
+ * 2. Implement `getStoreSchema()` — describes your store for tool descriptions
+ * 3. Implement the 5 handler methods (storeGet, storeSet, storeDelete, storeList)
+ * 4. Optionally implement `storeAction()` for non-CRUD operations
+ * 5. Write `getInstructions()` — explains when to use YOUR store vs others
+ * 6. Register with `ctx.registerPlugin(yourPlugin)` — store tools auto-include it
+ *
+ * Your plugin does NOT need to define any tools via `getTools()`.
+ * The `StoreToolsManager` creates the 5 `store_*` tools once and routes
+ * calls to the correct handler based on the `store` parameter.
+ *
+ * @example
+ * ```typescript
+ * class NotesPlugin extends BasePluginNextGen implements IStoreHandler {
+ *   readonly name = 'notes';
+ *   private notes = new Map<string, { text: string; tag?: string }>();
+ *
+ *   getStoreSchema(): StoreEntrySchema {
+ *     return {
+ *       storeId: 'notes',
+ *       displayName: 'Notes',
+ *       description: 'Simple text notes with optional tags',
+ *       usageHint: 'Use for: quick notes. NOT for structured data (use "memory").',
+ *       setDataFields: 'text (required): Note content\ntag?: Optional category tag',
+ *     };
+ *   }
+ *
+ *   async storeGet(key?: string) { ... }
+ *   async storeSet(key: string, data: Record<string, unknown>) { ... }
+ *   async storeDelete(key: string) { ... }
+ *   async storeList(filter?: Record<string, unknown>) { ... }
+ *
+ *   getInstructions() {
+ *     return 'Store name: "notes". Use store_set("notes", key, { text, tag? }).';
+ *   }
+ *   async getContent() { ... }
+ *   getContents() { return Object.fromEntries(this.notes); }
+ * }
+ * ```
+ */
+interface IStoreHandler {
+    /** Return the store's schema for dynamic tool descriptions */
+    getStoreSchema(): StoreEntrySchema;
+    /** Get one entry by key, or all entries if key is undefined */
+    storeGet(key?: string, context?: ToolContext): Promise<StoreGetResult>;
+    /** Create or update an entry */
+    storeSet(key: string, data: Record<string, unknown>, context?: ToolContext): Promise<StoreSetResult>;
+    /** Delete an entry by key */
+    storeDelete(key: string, context?: ToolContext): Promise<StoreDeleteResult>;
+    /** List entries with optional filter */
+    storeList(filter?: Record<string, unknown>, context?: ToolContext): Promise<StoreListResult>;
+    /** Execute a store-specific action (optional — only needed if store has actions) */
+    storeAction?(action: string, params?: Record<string, unknown>, context?: ToolContext): Promise<StoreActionResult>;
+}
+/**
+ * Type guard to check if a plugin implements IStoreHandler.
+ */
+declare function isStoreHandler(plugin: IContextPluginNextGen): plugin is IContextPluginNextGen & IStoreHandler;
 /**
  * Token budget breakdown - clear and simple
  */
@@ -1470,7 +1800,11 @@ interface OversizedInputResult {
 /**
  * Feature flags for enabling/disabling plugins
  */
-interface ContextFeatures {
+/**
+ * Known feature flags for built-in plugins (provides autocomplete/docs).
+ * External plugins register via PluginRegistry and use arbitrary string keys.
+ */
+interface KnownContextFeatures {
     /** Enable WorkingMemory plugin (default: true) */
     workingMemory?: boolean;
     /** Enable InContextMemory plugin (default: false) */
@@ -1481,44 +1815,56 @@ interface ContextFeatures {
     userInfo?: boolean;
     /** Enable ToolCatalog plugin for dynamic tool loading/unloading (default: false) */
     toolCatalog?: boolean;
+    /** Enable SharedWorkspace plugin for multi-agent coordination (default: false) */
+    sharedWorkspace?: boolean;
 }
 /**
- * Default feature configuration
+ * Feature flags for enabling/disabling plugins.
+ * Known keys provide autocomplete; arbitrary string keys are also accepted
+ * for externally registered plugins (via PluginRegistry).
  */
-declare const DEFAULT_FEATURES: Required<ContextFeatures>;
+type ContextFeatures = KnownContextFeatures & {
+    [key: string]: boolean | undefined;
+};
+/**
+ * Resolved features — all known keys guaranteed present, plus any extras.
+ * Used internally after merging with DEFAULT_FEATURES.
+ */
+type ResolvedContextFeatures = Required<KnownContextFeatures> & Record<string, boolean>;
+/**
+ * Default feature configuration for built-in plugins.
+ */
+declare const DEFAULT_FEATURES: Required<KnownContextFeatures>;
 /**
  * Plugin configurations for auto-initialization.
  * When features are enabled, plugins are created with these configs.
  * The config shapes match each plugin's constructor parameter.
  */
-interface PluginConfigs {
-    /**
-     * Working memory plugin config (used when features.workingMemory=true).
-     * See WorkingMemoryPluginConfig for full options.
-     */
+/**
+ * Known plugin configurations for built-in plugins (provides autocomplete/docs).
+ */
+interface KnownPluginConfigs {
+    /** Working memory plugin config. See WorkingMemoryPluginConfig. */
     workingMemory?: Record<string, unknown>;
-    /**
-     * In-context memory plugin config (used when features.inContextMemory=true).
-     * See InContextMemoryConfig for full options.
-     */
+    /** In-context memory plugin config. See InContextMemoryConfig. */
     inContextMemory?: Record<string, unknown>;
-    /**
-     * Persistent instructions plugin config (used when features.persistentInstructions=true).
-     * Note: agentId is auto-filled from context config if not provided.
-     * See PersistentInstructionsConfig for full options.
-     */
+    /** Persistent instructions plugin config. See PersistentInstructionsConfig. Note: agentId auto-filled. */
     persistentInstructions?: Record<string, unknown>;
-    /**
-     * User info plugin config (used when features.userInfo=true).
-     * See UserInfoPluginConfig for full options.
-     */
+    /** User info plugin config. See UserInfoPluginConfig. */
     userInfo?: Record<string, unknown>;
-    /**
-     * Tool catalog plugin config (used when features.toolCatalog=true).
-     * See ToolCatalogPluginConfig for full options.
-     */
+    /** Tool catalog plugin config. See ToolCatalogPluginConfig. */
     toolCatalog?: Record<string, unknown>;
+    /** Shared workspace plugin config. See SharedWorkspaceConfig. */
+    sharedWorkspace?: Record<string, unknown>;
 }
+/**
+ * Plugin configurations for auto-initialization.
+ * Known keys provide autocomplete; arbitrary string keys accepted
+ * for externally registered plugins (via PluginRegistry).
+ */
+type PluginConfigs = KnownPluginConfigs & {
+    [key: string]: Record<string, unknown> | undefined;
+};
 /**
  * AgentContextNextGen configuration
  */
@@ -1569,6 +1915,13 @@ interface AgentContextNextGenConfig {
      * Default: 0 (disabled - relies on each tool's own timeout)
      */
     toolExecutionTimeout?: number;
+    /**
+     * Filter which message types are written to the history journal.
+     * When set, only entries matching these types are appended.
+     * Default: undefined (all types journaled).
+     * Example: ['user', 'assistant'] to exclude tool_result entries.
+     */
+    journalFilter?: HistoryEntryType[];
 }
 /**
  * Default configuration values
@@ -1674,6 +2027,12 @@ interface CompactionContext {
     readonly plugins: ReadonlyArray<IContextPluginNextGen>;
     /** Strategy name for logging */
     readonly strategyName: string;
+    /**
+     * Describe a tool call using the tool's describeCall function.
+     * Returns a human-readable summary of the tool call args (e.g., "src/core/Agent.ts [lines 100-200]").
+     * Returns undefined if the tool is not found or has no describeCall.
+     */
+    describeToolCall?(toolName: string, toolArgs: unknown): string | undefined;
     /**
      * Remove messages by indices.
      * Handles tool pair preservation internally.
@@ -1755,8 +2114,50 @@ interface ICompactionStrategy {
 }
 
 /**
- * LLM Response entity based on OpenAI Responses API format
+ * Interface for objects that manage resources and need explicit cleanup.
+ *
+ * Implementing classes should release all resources (event listeners, timers,
+ * connections, etc.) when destroy() is called. After destruction, the instance
+ * should not be used.
+ */
+interface IDisposable {
+    /**
+     * Releases all resources held by this instance.
+     *
+     * After calling destroy():
+     * - All event listeners should be removed
+     * - All timers/intervals should be cleared
+     * - All internal state should be cleaned up
+     * - The instance should not be reused
+     *
+     * Multiple calls to destroy() should be safe (idempotent).
+     */
+    destroy(): void;
+    /**
+     * Returns true if destroy() has been called.
+     * Methods should check this before performing operations.
+     */
+    readonly isDestroyed: boolean;
+}
+/**
+ * Async version of IDisposable for resources requiring async cleanup.
+ */
+interface IAsyncDisposable {
+    /**
+     * Asynchronously releases all resources held by this instance.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Returns true if destroy() has been called.
+     */
+    readonly isDestroyed: boolean;
+}
+/**
+ * Helper to check if an object is destroyed and throw if so.
+ * @param obj - The disposable object to check
+ * @param operation - Name of the operation being attempted
  */
+declare function assertNotDestroyed(obj: IDisposable | IAsyncDisposable, operation: string): void;
 
 /**
  * Token usage statistics
@@ -1773,7 +2174,17 @@ interface LLMResponse {
     id: string;
     object: 'response';
     created_at: number;
-    status: 'completed' | 'failed' | 'in_progress' | 'cancelled' | 'queued' | 'incomplete';
+    /**
+     * Response status:
+     * - `completed` — Generation finished successfully
+     * - `failed` — Generation failed with an error
+     * - `incomplete` — Generation stopped early (e.g. max tokens reached)
+     * - `cancelled` — Generation was cancelled by the caller
+     * - `in_progress` — Async/streaming generation still running (used by StreamState, video generation)
+     * - `queued` — Queued for processing (used by async video generation via Sora)
+     * - `suspended` — Agent loop suspended waiting for external input (via SuspendSignal)
+     */
+    status: 'completed' | 'failed' | 'in_progress' | 'cancelled' | 'queued' | 'incomplete' | 'suspended';
     model: string;
     output: OutputItem[];
     output_text?: string;
@@ -1784,6 +2195,28 @@ interface LLMResponse {
         message: string;
     };
     metadata?: Record<string, string>;
+    /** Non-empty when async tools are still executing in the background */
+    pendingAsyncTools?: Array<{
+        toolCallId: string;
+        toolName: string;
+        startTime: number;
+        status: PendingAsyncToolStatus;
+    }>;
+    /** Present when status is 'suspended' — contains info needed to resume the session */
+    suspension?: {
+        /** Correlation ID for routing external events back to this session */
+        correlationId: string;
+        /** Session ID where the agent state is persisted */
+        sessionId: string;
+        /** Agent ID for reconstructing the agent via Agent.hydrate() */
+        agentId: string;
+        /** How the external response should be injected on resume */
+        resumeAs: 'user_message' | 'tool_result';
+        /** ISO timestamp when this suspension expires */
+        expiresAt: string;
+        /** Application-specific metadata from the SuspendSignal */
+        metadata?: Record<string, unknown>;
+    };
 }
 type AgentResponse = LLMResponse;
 
@@ -1809,6 +2242,7 @@ declare enum StreamEventType {
     REASONING_DELTA = "response.reasoning.delta",
     REASONING_DONE = "response.reasoning.done",
     RESPONSE_COMPLETE = "response.complete",
+    RETRY = "response.retry",
     ERROR = "response.error",
     AUDIO_CHUNK_READY = "response.audio_chunk.ready",
     AUDIO_CHUNK_ERROR = "response.audio_chunk.error",
@@ -1923,6 +2357,18 @@ interface ResponseCompleteEvent extends BaseStreamEvent {
     usage: TokenUsage;
     iterations: number;
     duration_ms?: number;
+    /** Raw provider stop reason for diagnostics (e.g., 'end_turn', 'max_tokens', 'SAFETY') */
+    stop_reason?: string;
+}
+/**
+ * Retry event - emitted when agent retries an empty/incomplete LLM response
+ */
+interface RetryEvent extends BaseStreamEvent {
+    type: StreamEventType.RETRY;
+    attempt: number;
+    max_attempts: number;
+    reason: string;
+    delay_ms: number;
 }
 /**
  * Reasoning/thinking delta - incremental reasoning output
@@ -1995,7 +2441,7 @@ interface AudioStreamCompleteEvent extends BaseStreamEvent {
  * Union type of all stream events
  * Discriminated by 'type' field for type narrowing
  */
-type StreamEvent = ResponseCreatedEvent | ResponseInProgressEvent | OutputTextDeltaEvent | OutputTextDoneEvent | ReasoningDeltaEvent | ReasoningDoneEvent | ToolCallStartEvent | ToolCallArgumentsDeltaEvent | ToolCallArgumentsDoneEvent | ToolExecutionStartEvent | ToolExecutionDoneEvent | IterationCompleteEvent$1 | ResponseCompleteEvent | ErrorEvent | AudioChunkReadyEvent | AudioChunkErrorEvent | AudioStreamCompleteEvent;
+type StreamEvent = ResponseCreatedEvent | ResponseInProgressEvent | OutputTextDeltaEvent | OutputTextDoneEvent | ReasoningDeltaEvent | ReasoningDoneEvent | ToolCallStartEvent | ToolCallArgumentsDeltaEvent | ToolCallArgumentsDoneEvent | ToolExecutionStartEvent | ToolExecutionDoneEvent | IterationCompleteEvent$1 | ResponseCompleteEvent | RetryEvent | ErrorEvent | AudioChunkReadyEvent | AudioChunkErrorEvent | AudioStreamCompleteEvent;
 /**
  * Type guard to check if event is a specific type
  */
@@ -2272,6 +2718,14 @@ interface ExecutionEmptyOutputEvent {
     duration: number;
     usage?: TokenUsage;
 }
+interface ExecutionRetryEvent {
+    executionId: string;
+    attempt: number;
+    maxAttempts: number;
+    reason: string;
+    delayMs: number;
+    timestamp: Date;
+}
 interface ExecutionMaxIterationsEvent {
     executionId: string;
     iteration: number;
@@ -2367,6 +2821,44 @@ interface CircuitClosedEvent {
     successCount: number;
     timestamp: Date;
 }
+interface AsyncToolStartedEvent {
+    executionId: string;
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    timestamp: Date;
+}
+interface AsyncToolCompleteEvent {
+    executionId: string;
+    toolCallId: string;
+    toolName: string;
+    result: ToolResult;
+    duration: number;
+    timestamp: Date;
+}
+interface AsyncToolErrorEvent {
+    executionId: string;
+    toolCallId: string;
+    toolName: string;
+    error: Error;
+    duration: number;
+    timestamp: Date;
+}
+interface AsyncToolTimeoutEvent {
+    executionId: string;
+    toolCallId: string;
+    toolName: string;
+    timeout: number;
+    timestamp: Date;
+}
+interface AsyncContinuationStartEvent {
+    executionId: string;
+    results: Array<{
+        toolCallId: string;
+        toolName: string;
+    }>;
+    timestamp: Date;
+}
 /**
  * Map of all event names to their payload types
  */
@@ -2390,9 +2882,15 @@ interface AgenticLoopEvents {
     'tool:timeout': ToolTimeoutEvent;
     'hook:error': HookErrorEvent;
     'execution:empty_output': ExecutionEmptyOutputEvent;
+    'execution:retry': ExecutionRetryEvent;
     'circuit:opened': CircuitOpenedEvent;
     'circuit:half-open': CircuitHalfOpenEvent;
     'circuit:closed': CircuitClosedEvent;
+    'async:tool:started': AsyncToolStartedEvent;
+    'async:tool:complete': AsyncToolCompleteEvent;
+    'async:tool:error': AsyncToolErrorEvent;
+    'async:tool:timeout': AsyncToolTimeoutEvent;
+    'async:continuation:start': AsyncContinuationStartEvent;
 }
 type AgenticLoopEventName = keyof AgenticLoopEvents;
 /**
@@ -2551,7 +3049,8 @@ interface HookSignatures {
  * Includes error isolation, timeouts, and optional parallel execution
  */
 
-declare class HookManager {
+declare class HookManager implements IDisposable {
+    private _isDestroyed;
     private hooks;
     private timeout;
     private parallel;
@@ -2607,6 +3106,14 @@ declare class HookManager {
      * Clear all hooks and reset error tracking
      */
     clear(): void;
+    /**
+     * Check if the hook manager has been destroyed
+     */
+    get isDestroyed(): boolean;
+    /**
+     * Destroy the hook manager and release all references
+     */
+    destroy(): void;
     /**
      * Re-enable a disabled hook
      */
@@ -2617,4 +3124,4 @@ declare class HookManager {
     getDisabledHooks(): string[];
 }
 
-export { type TokenUsage as $, type AgentContextNextGenConfig as A, type BeforeCompactionCallback as B, type ContextFeatures as C, type HookName as D, ExecutionContext as E, type FunctionToolDefinition as F, type ITokenEstimator as G, type HookConfig as H, type IContextStorage as I, type ToolCategoryScope as J, type CompactionContext as K, type LLMResponse as L, type MemoryEntry as M, type CompactionResult as N, type OutputItem as O, type PriorityCalculator as P, type AudioChunkReadyEvent as Q, type StaleEntryInfo as R, type SerializedContextState as S, type Tool as T, type PriorityContext as U, type MemoryIndex as V, type WorkingMemoryConfig as W, type TaskStatusForMemory as X, type WorkingMemoryAccess as Y, type ContextStorageListOptions as Z, type ContextSessionSummary as _, type MemoryScope as a, defaultDescribeCall as a$, StreamEventType as a0, type TextGenerateOptions as a1, type ModelCapabilities as a2, MessageRole as a3, type AfterToolContext as a4, type AgentEventName as a5, type AgenticLoopEventName as a6, type AgenticLoopEvents as a7, type ApprovalResult as a8, type ApproveToolContext as a9, type OutputTextContent as aA, type OutputTextDeltaEvent as aB, type OutputTextDoneEvent as aC, type OversizedInputResult as aD, type PluginConfigs as aE, type ReasoningDeltaEvent as aF, type ReasoningDoneEvent as aG, type ReasoningItem as aH, type ResponseCompleteEvent as aI, type ResponseCreatedEvent as aJ, type ResponseInProgressEvent as aK, type SimpleScope as aL, type TaskAwareScope as aM, type ThinkingContent as aN, type ToolCallArgumentsDeltaEvent as aO, type ToolCallArgumentsDoneEvent as aP, type ToolCallStartEvent as aQ, ToolCallState as aR, ToolCatalogRegistry as aS, type ToolCategoryDefinition as aT, type ToolExecutionContext as aU, type ToolExecutionDoneEvent as aV, type ToolExecutionStartEvent as aW, type ToolModification as aX, type ToolResultContent as aY, type ToolUseContent as aZ, calculateEntrySize as a_, type AudioChunkErrorEvent as aa, type AudioStreamCompleteEvent as ab, type BeforeToolContext as ac, type BuiltInTool as ad, CONTEXT_SESSION_FORMAT_VERSION as ae, type ToolRegistryEntry as af, type CatalogToolEntry as ag, type CompactionItem as ah, type ConnectorCategoryInfo as ai, ContentType as aj, DEFAULT_CONFIG as ak, DEFAULT_FEATURES as al, DEFAULT_MEMORY_CONFIG as am, type ErrorEvent as an, type ExecutionConfig as ao, type Hook as ap, HookManager as aq, type InputImageContent as ar, type InputTextContent as as, type IterationCompleteEvent$1 as at, type JSONSchema as au, MEMORY_PRIORITY_VALUES as av, type MemoryEntryInput as aw, type MemoryIndexEntry as ax, type Message as ay, type ModifyingHook as az, type ToolFunction as b, forPlan as b0, forTasks as b1, getToolCallDescription as b2, isAudioChunkError as b3, isAudioChunkReady as b4, isAudioStreamComplete as b5, isErrorEvent as b6, isOutputTextDelta as b7, isReasoningDelta as b8, isReasoningDone as b9, isResponseComplete as ba, isSimpleScope as bb, isStreamEvent as bc, isTaskAwareScope as bd, isTerminalMemoryStatus as be, isToolCallArgumentsDelta as bf, isToolCallArgumentsDone as bg, isToolCallStart as bh, scopeEquals as bi, scopeMatches as bj, type ExecutionCompleteEvent as bk, type ExecutionStartEvent as bl, type LLMRequestEvent as bm, type LLMResponseEvent as bn, type ToolCompleteEvent as bo, type ToolStartEvent as bp, type ToolContext as c, type ToolPermissionConfig as d, type ContextBudget as e, type ToolCall as f, type IContextPluginNextGen as g, type MemoryPriority as h, type MemoryTier as i, type ContextEvents as j, type AuthIdentity as k, type ICompactionStrategy as l, type InputItem as m, type Content as n, type PreparedContext as o, type ToolResult as p, type ConsolidationResult as q, type StoredContextSession as r, type ITextProvider as s, type ContextSessionMetadata as t, type StreamEvent as u, type HistoryMode as v, type AgentEvents as w, type AgentResponse as x, type ExecutionMetrics as y, type AuditEntry as z };
+export { type ITokenEstimator as $, type AgentContextNextGenConfig as A, type BeforeCompactionCallback as B, type ContextFeatures as C, type StoredContextSession as D, type ITextProvider as E, type ContextSessionMetadata as F, type FunctionToolDefinition as G, type StreamEvent as H, type IContextStorage as I, type HookConfig as J, type HistoryMode as K, type LLMResponse as L, type MemoryEntry as M, type AsyncToolConfig as N, type OutputItem as O, type PriorityCalculator as P, type AgentEvents as Q, type ResolvedContextFeatures as R, type StoreEntrySchema as S, type ToolCall as T, type AgentResponse as U, type PendingAsyncTool as V, type WorkingMemoryConfig as W, ExecutionContext as X, type ExecutionMetrics as Y, type AuditEntry as Z, type HookName as _, type MemoryScope as a, type ResponseCompleteEvent as a$, type ToolCategoryScope as a0, type CompactionContext as a1, type CompactionResult as a2, type PluginConfigs as a3, type AudioChunkReadyEvent as a4, type ContextStorageListOptions as a5, type ContextSessionSummary as a6, type HistoryEntry as a7, type HistoryReadOptions as a8, type StaleEntryInfo as a9, DEFAULT_FEATURES as aA, DEFAULT_MEMORY_CONFIG as aB, type ErrorEvent as aC, type ExecutionConfig as aD, type HistoryEntryType as aE, type Hook as aF, HookManager as aG, type IAsyncDisposable as aH, type InputImageContent as aI, type InputTextContent as aJ, type IterationCompleteEvent$1 as aK, type JSONSchema as aL, type KnownContextFeatures as aM, type KnownPluginConfigs as aN, MEMORY_PRIORITY_VALUES as aO, type MemoryEntryInput as aP, type MemoryIndexEntry as aQ, type Message as aR, type ModifyingHook as aS, type OutputTextContent as aT, type OutputTextDeltaEvent as aU, type OutputTextDoneEvent as aV, type OversizedInputResult as aW, type PendingAsyncToolStatus as aX, type ReasoningDeltaEvent as aY, type ReasoningDoneEvent as aZ, type ReasoningItem as a_, type PriorityContext as aa, type MemoryIndex as ab, type TaskStatusForMemory as ac, type WorkingMemoryAccess as ad, type TokenUsage as ae, StreamEventType as af, type TextGenerateOptions as ag, type ModelCapabilities as ah, MessageRole as ai, type AfterToolContext as aj, type AgentEventName as ak, type AgenticLoopEventName as al, type AgenticLoopEvents as am, type ApprovalResult as an, type ApproveToolContext as ao, type AudioChunkErrorEvent as ap, type AudioStreamCompleteEvent as aq, type BeforeToolContext as ar, type BuiltInTool as as, CONTEXT_SESSION_FORMAT_VERSION as at, type ToolRegistryEntry as au, type CatalogToolEntry as av, type CompactionItem as aw, type ConnectorCategoryInfo as ax, ContentType as ay, DEFAULT_CONFIG as az, type Tool as b, type ResponseCreatedEvent as b0, type ResponseInProgressEvent as b1, type SimpleScope as b2, type TaskAwareScope as b3, type ThinkingContent as b4, type ToolCallArgumentsDeltaEvent as b5, type ToolCallArgumentsDoneEvent as b6, type ToolCallStartEvent as b7, ToolCallState as b8, ToolCatalogRegistry as b9, isToolCallArgumentsDelta as bA, isToolCallArgumentsDone as bB, isToolCallStart as bC, scopeEquals as bD, scopeMatches as bE, type AsyncContinuationStartEvent as bF, type AsyncToolCompleteEvent as bG, type AsyncToolErrorEvent as bH, type AsyncToolStartedEvent as bI, type AsyncToolTimeoutEvent as bJ, type ExecutionCompleteEvent as bK, type ExecutionStartEvent as bL, type LLMRequestEvent as bM, type LLMResponseEvent as bN, type ToolCompleteEvent as bO, type ToolStartEvent as bP, type ToolCategoryDefinition as ba, type ToolExecutionContext as bb, type ToolExecutionDoneEvent as bc, type ToolExecutionStartEvent as bd, type ToolModification as be, type ToolResultContent as bf, type ToolUseContent as bg, assertNotDestroyed as bh, calculateEntrySize as bi, defaultDescribeCall as bj, forPlan as bk, forTasks as bl, getToolCallDescription as bm, isAudioChunkError as bn, isAudioChunkReady as bo, isAudioStreamComplete as bp, isErrorEvent as bq, isOutputTextDelta as br, isReasoningDelta as bs, isReasoningDone as bt, isResponseComplete as bu, isSimpleScope as bv, isStoreHandler as bw, isStreamEvent as bx, isTaskAwareScope as by, isTerminalMemoryStatus as bz, type ToolFunction as c, type IDisposable as d, type ToolContext as e, type ToolPermissionConfig as f, type ContextBudget as g, type IContextPluginNextGen as h, type IStoreHandler as i, type MemoryPriority as j, type StoreGetResult as k, type StoreSetResult as l, type StoreDeleteResult as m, type StoreListResult as n, type StoreActionResult as o, type MemoryTier as p, type ContextEvents as q, type AuthIdentity as r, type ICompactionStrategy as s, type InputItem as t, type Content as u, type PreparedContext as v, type ToolResult as w, type IHistoryJournal as x, type ConsolidationResult as y, type SerializedContextState as z };