@everworker/oneringai 0.4.8 → 0.5.0

package/dist/{index-13HQuxEB.d.ts → index-hmTj59TM.d.ts}

@@ -515,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 */
@@ -585,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
  */
@@ -1555,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
  */
@@ -1621,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) */
@@ -1632,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).
+ */
+type ContextFeatures = KnownContextFeatures & {
+    [key: string]: boolean | undefined;
+};
+/**
+ * Resolved features — all known keys guaranteed present, plus any extras.
+ * Used internally after merging with DEFAULT_FEATURES.
  */
-declare const DEFAULT_FEATURES: Required<ContextFeatures>;
+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
  */
@@ -1832,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.
@@ -1913,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
@@ -1931,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;
@@ -1942,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;
 
@@ -2546,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
  */
@@ -2573,6 +2886,11 @@ interface AgenticLoopEvents {
     '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;
 /**
@@ -2731,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;
@@ -2787,6 +3106,10 @@ 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
      */
@@ -2801,4 +3124,4 @@ declare class HookManager {
     getDisabledHooks(): string[];
 }
 
-export { type MemoryIndex as $, type AgentContextNextGenConfig as A, type BeforeCompactionCallback as B, type ContextFeatures as C, type AuditEntry as D, ExecutionContext as E, type FunctionToolDefinition as F, type HookName as G, type HookConfig as H, type IContextStorage as I, type ITokenEstimator as J, type ToolCategoryScope as K, type LLMResponse as L, type MemoryEntry as M, type CompactionContext as N, type OutputItem as O, type PriorityCalculator as P, type CompactionResult as Q, type AudioChunkReadyEvent as R, type SerializedContextState as S, type Tool as T, type ContextStorageListOptions as U, type ContextSessionSummary as V, type WorkingMemoryConfig as W, type HistoryEntry as X, type HistoryReadOptions as Y, type StaleEntryInfo as Z, type PriorityContext as _, type MemoryScope as a, type ToolModification as a$, type TaskStatusForMemory as a0, type WorkingMemoryAccess as a1, type TokenUsage as a2, StreamEventType as a3, type TextGenerateOptions as a4, type ModelCapabilities as a5, MessageRole as a6, type AfterToolContext as a7, type AgentEventName as a8, type AgenticLoopEventName as a9, type MemoryEntryInput as aA, type MemoryIndexEntry as aB, type Message as aC, type ModifyingHook as aD, type OutputTextContent as aE, type OutputTextDeltaEvent as aF, type OutputTextDoneEvent as aG, type OversizedInputResult as aH, type PluginConfigs as aI, type ReasoningDeltaEvent as aJ, type ReasoningDoneEvent as aK, type ReasoningItem as aL, type ResponseCompleteEvent as aM, type ResponseCreatedEvent as aN, type ResponseInProgressEvent as aO, type SimpleScope as aP, type TaskAwareScope as aQ, type ThinkingContent as aR, type ToolCallArgumentsDeltaEvent as aS, type ToolCallArgumentsDoneEvent as aT, type ToolCallStartEvent as aU, ToolCallState as aV, ToolCatalogRegistry as aW, type ToolCategoryDefinition as aX, type ToolExecutionContext as aY, type ToolExecutionDoneEvent as aZ, type ToolExecutionStartEvent as a_, type AgenticLoopEvents as aa, type ApprovalResult as ab, type ApproveToolContext as ac, type AudioChunkErrorEvent as ad, type AudioStreamCompleteEvent as ae, type BeforeToolContext as af, type BuiltInTool as ag, CONTEXT_SESSION_FORMAT_VERSION as ah, type ToolRegistryEntry as ai, type CatalogToolEntry as aj, type CompactionItem as ak, type ConnectorCategoryInfo as al, ContentType as am, DEFAULT_CONFIG as an, DEFAULT_FEATURES as ao, DEFAULT_MEMORY_CONFIG as ap, type ErrorEvent as aq, type ExecutionConfig as ar, type HistoryEntryType as as, type Hook as at, HookManager as au, type InputImageContent as av, type InputTextContent as aw, type IterationCompleteEvent$1 as ax, type JSONSchema as ay, MEMORY_PRIORITY_VALUES as az, type ToolFunction as b, type ToolResultContent as b0, type ToolUseContent as b1, calculateEntrySize as b2, defaultDescribeCall as b3, forPlan as b4, forTasks as b5, getToolCallDescription as b6, isAudioChunkError as b7, isAudioChunkReady as b8, isAudioStreamComplete as b9, isErrorEvent as ba, isOutputTextDelta as bb, isReasoningDelta as bc, isReasoningDone as bd, isResponseComplete as be, isSimpleScope as bf, isStreamEvent as bg, isTaskAwareScope as bh, isTerminalMemoryStatus as bi, isToolCallArgumentsDelta as bj, isToolCallArgumentsDone as bk, isToolCallStart as bl, scopeEquals as bm, scopeMatches as bn, type ExecutionCompleteEvent as bo, type ExecutionStartEvent as bp, type LLMRequestEvent as bq, type LLMResponseEvent as br, type ToolCompleteEvent as bs, type ToolStartEvent as bt, 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 IHistoryJournal as q, type ConsolidationResult as r, type StoredContextSession as s, type ITextProvider as t, type ContextSessionMetadata as u, type StreamEvent as v, type HistoryMode as w, type AgentEvents as x, type AgentResponse as y, type ExecutionMetrics 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 };