@everworker/oneringai 0.4.6 → 0.4.8

package/dist/index.d.ts

@@ -1,12 +1,13 @@
 import { I as IConnectorRegistry, a as IConnectorAccessPolicy, C as ConnectorAccessContext, b as Connector, c as ConnectorConfig, d as ITokenStorage, e as IProvider, f as ConnectorFetchOptions, P as ProviderCapabilities, S as StoredToken$1, g as ConnectorAuth, h as ConnectorConfigResult } from './IProvider-CxDUGl6n.js';
 export { A as APIKeyConnectorAuth, D as DEFAULT_BASE_DELAY_MS, i as DEFAULT_CONNECTOR_TIMEOUT, j as DEFAULT_MAX_DELAY_MS, k as DEFAULT_MAX_RETRIES, l as DEFAULT_RETRYABLE_STATUSES, J as JWTConnectorAuth, O as OAuthConnectorAuth } from './IProvider-CxDUGl6n.js';
-import { C as ContextFeatures, M as MemoryEntry, a as MemoryScope, I as IContextStorage, T as Tool, b as ToolFunction, c as ToolContext, d as ToolPermissionConfig$1, e as ContextBudget$1, f as ToolCall, g as IContextPluginNextGen, W as WorkingMemoryConfig, P as PriorityCalculator, h as MemoryPriority, i as MemoryTier, j as ContextEvents, A as AgentContextNextGenConfig, k as AuthIdentity, l as ICompactionStrategy, B as BeforeCompactionCallback, m as InputItem, n as Content, o as PreparedContext, O as OutputItem, p as ToolResult, q as ConsolidationResult, S as SerializedContextState, r as StoredContextSession, s as ITextProvider, t as ContextSessionMetadata, F as FunctionToolDefinition, L as LLMResponse, u as StreamEvent, H as HookConfig, v as HistoryMode, w as AgentEvents, x as AgentResponse, E as ExecutionContext, y as ExecutionMetrics, z as AuditEntry, D as HookName, G as ITokenEstimator$1, J as ToolCategoryScope, K as CompactionContext, N as CompactionResult, Q as StaleEntryInfo, R as PriorityContext, U as MemoryIndex, V as TaskStatusForMemory, X as WorkingMemoryAccess, Y as ContextStorageListOptions, Z as ContextSessionSummary, _ as TokenUsage, $ as StreamEventType, a0 as TextGenerateOptions, a1 as ModelCapabilities, a2 as MessageRole } from './index-oBtp-8Qn.js';
-export { a3 as AfterToolContext, a4 as AgentEventName, a5 as AgenticLoopEventName, a6 as AgenticLoopEvents, a7 as ApprovalResult, a8 as ApproveToolContext, a9 as BeforeToolContext, aa as BuiltInTool, ab as CONTEXT_SESSION_FORMAT_VERSION, ac as CatalogRegistryEntry, ad as CatalogToolEntry, ae as CompactionItem, af as ConnectorCategoryInfo, ag as ContentType, ah as DEFAULT_CONFIG, ai as DEFAULT_FEATURES, aj as DEFAULT_MEMORY_CONFIG, ak as ErrorEvent, al as ExecutionConfig, am as Hook, an as HookManager, ao as InputImageContent, ap as InputTextContent, aq as IterationCompleteEvent, ar as JSONSchema, as as MEMORY_PRIORITY_VALUES, at as MemoryEntryInput, au as MemoryIndexEntry, av as Message, aw as ModifyingHook, ax as OutputTextContent, ay as OutputTextDeltaEvent, az as OutputTextDoneEvent, aA as OversizedInputResult, aB as PluginConfigs, aC as ReasoningDeltaEvent, aD as ReasoningDoneEvent, aE as ReasoningItem, aF as ResponseCompleteEvent, aG as ResponseCreatedEvent, aH as ResponseInProgressEvent, aI as SimpleScope, aJ as TaskAwareScope, aK as ThinkingContent, aL as ToolCallArgumentsDeltaEvent, aM as ToolCallArgumentsDoneEvent, aN as ToolCallStartEvent, aO as ToolCallState, aP as ToolCatalogRegistry, aQ as ToolCategoryDefinition, aR as ToolExecutionContext, aS as ToolExecutionDoneEvent, aT as ToolExecutionStartEvent, aU as ToolModification, aV as ToolResultContent, aW as ToolUseContent, aX as calculateEntrySize, aY as defaultDescribeCall, aZ as forPlan, a_ as forTasks, a$ as getToolCallDescription, b0 as isErrorEvent, b1 as isOutputTextDelta, b2 as isReasoningDelta, b3 as isReasoningDone, b4 as isResponseComplete, b5 as isSimpleScope, b6 as isStreamEvent, b7 as isTaskAwareScope, b8 as isTerminalMemoryStatus, b9 as isToolCallArgumentsDelta, ba as isToolCallArgumentsDone, bb as isToolCallStart, bc as scopeEquals, bd as scopeMatches } from './index-oBtp-8Qn.js';
+import { C as ContextFeatures, M as MemoryEntry, a as MemoryScope, I as IContextStorage, T as Tool, b as ToolFunction, c as ToolContext, d as ToolPermissionConfig$1, e as ContextBudget$1, f as ToolCall, g as IContextPluginNextGen, W as WorkingMemoryConfig, P as PriorityCalculator, h as MemoryPriority, i as MemoryTier, j as ContextEvents, A as AgentContextNextGenConfig, k as AuthIdentity, l as ICompactionStrategy, B as BeforeCompactionCallback, m as InputItem, n as Content, o as PreparedContext, O as OutputItem, p as ToolResult, q as IHistoryJournal, r as ConsolidationResult, S as SerializedContextState, s as StoredContextSession, t as ITextProvider, u as ContextSessionMetadata, F as FunctionToolDefinition, L as LLMResponse, v as StreamEvent, H as HookConfig, w as HistoryMode, x as AgentEvents, y as AgentResponse, E as ExecutionContext, z as ExecutionMetrics, D as AuditEntry, G as HookName, J as ITokenEstimator$1, K as ToolCategoryScope, N as CompactionContext, Q as CompactionResult, R as AudioChunkReadyEvent, U as ContextStorageListOptions, V as ContextSessionSummary, X as HistoryEntry, Y as HistoryReadOptions, Z as StaleEntryInfo, _ as PriorityContext, $ as MemoryIndex, a0 as TaskStatusForMemory, a1 as WorkingMemoryAccess, a2 as TokenUsage, a3 as StreamEventType, a4 as TextGenerateOptions, a5 as ModelCapabilities, a6 as MessageRole } from './index-13HQuxEB.js';
+export { a7 as AfterToolContext, a8 as AgentEventName, a9 as AgenticLoopEventName, aa as AgenticLoopEvents, ab as ApprovalResult, ac as ApproveToolContext, ad as AudioChunkErrorEvent, ae as AudioStreamCompleteEvent, af as BeforeToolContext, ag as BuiltInTool, ah as CONTEXT_SESSION_FORMAT_VERSION, ai as CatalogRegistryEntry, aj as CatalogToolEntry, ak as CompactionItem, al as ConnectorCategoryInfo, am as ContentType, an as DEFAULT_CONFIG, ao as DEFAULT_FEATURES, ap as DEFAULT_MEMORY_CONFIG, aq as ErrorEvent, ar as ExecutionConfig, as as HistoryEntryType, at as Hook, au as HookManager, av as InputImageContent, aw as InputTextContent, ax as IterationCompleteEvent, ay as JSONSchema, az as MEMORY_PRIORITY_VALUES, aA as MemoryEntryInput, aB as MemoryIndexEntry, aC as Message, aD as ModifyingHook, aE as OutputTextContent, aF as OutputTextDeltaEvent, aG as OutputTextDoneEvent, aH as OversizedInputResult, aI as PluginConfigs, aJ as ReasoningDeltaEvent, aK as ReasoningDoneEvent, aL as ReasoningItem, aM as ResponseCompleteEvent, aN as ResponseCreatedEvent, aO as ResponseInProgressEvent, aP as SimpleScope, aQ as TaskAwareScope, aR as ThinkingContent, aS as ToolCallArgumentsDeltaEvent, aT as ToolCallArgumentsDoneEvent, aU as ToolCallStartEvent, aV as ToolCallState, aW as ToolCatalogRegistry, aX as ToolCategoryDefinition, aY as ToolExecutionContext, aZ as ToolExecutionDoneEvent, a_ as ToolExecutionStartEvent, a$ as ToolModification, b0 as ToolResultContent, b1 as ToolUseContent, b2 as calculateEntrySize, b3 as defaultDescribeCall, b4 as forPlan, b5 as forTasks, b6 as getToolCallDescription, b7 as isAudioChunkError, b8 as isAudioChunkReady, b9 as isAudioStreamComplete, ba as isErrorEvent, bb as isOutputTextDelta, bc as isReasoningDelta, bd as isReasoningDone, be as isResponseComplete, bf as isSimpleScope, bg as isStreamEvent, bh as isTaskAwareScope, bi as isTerminalMemoryStatus, bj as isToolCallArgumentsDelta, bk as isToolCallArgumentsDone, bl as isToolCallStart, bm as scopeEquals, bn as scopeMatches } from './index-13HQuxEB.js';
 import { EventEmitter } from 'eventemitter3';
 import { V as Vendor } from './Vendor-DYh_bzwo.js';
 export { a as VENDORS, i as isVendor } from './Vendor-DYh_bzwo.js';
 import { A as AudioFormat, I as IBaseModelDescription, V as VendorOptionSchema, a as IImageProvider } from './ImageModel-1uP-2vk7.js';
 export { b as AspectRatio, c as IImageModelDescription, d as IMAGE_MODELS, e as IMAGE_MODEL_REGISTRY, f as ISourceLinks, g as ImageEditOptions, h as ImageGenerateOptions, i as ImageGeneration, j as ImageGenerationCreateOptions, k as ImageModelCapabilities, l as ImageModelPricing, m as ImageResponse, n as ImageVariationOptions, O as OutputFormat, Q as QualityLevel, S as SimpleGenerateOptions, o as calculateImageCost, p as getActiveImageModels, q as getImageModelInfo, r as getImageModelsByVendor, s as getImageModelsWithFeature } from './ImageModel-1uP-2vk7.js';
+import { EventEmitter as EventEmitter$1 } from 'events';
 import { ServiceCategory } from './shared/index.js';
 export { ILLMDescription, LLM_MODELS, MODEL_REGISTRY, SERVICE_DEFINITIONS, SERVICE_INFO, SERVICE_URL_PATTERNS, ServiceDefinition, ServiceInfo, ServiceType, Services, calculateCost, detectServiceFromURL, getActiveModels, getAllServiceIds, getModelInfo, getModelsByVendor, getServiceDefinition, getServiceInfo, getServicesByCategory, isKnownService } from './shared/index.js';
 
@@ -1481,6 +1482,10 @@ declare class StorageRegistry {
      * Otherwise, calls `defaultFactory()`, caches the result, and returns it.
      */
     static resolve<K extends keyof StorageConfig>(key: K, defaultFactory: () => StorageConfig[K]): StorageConfig[K];
+    /**
+     * Remove a single storage backend.
+     */
+    static remove(key: keyof StorageConfig): boolean;
     /**
      * Check if a storage backend has been configured.
      */
@@ -1687,7 +1692,7 @@ declare class CircuitBreaker<T = any> extends EventEmitter<CircuitBreakerEvents>
      */
     private transitionTo;
     /**
-     * Remove failures outside the time window
+     * Remove failures outside the time window and cap array size
      */
     private pruneOldFailures;
     /**
@@ -3106,6 +3111,20 @@ declare class AgentContextNextGen extends EventEmitter<ContextEvents> {
     private _cachedBudget;
     /** Callback for beforeCompaction hook (set by Agent) */
     private _beforeCompactionCallback;
+    /**
+     * Monotonically increasing turn counter for history journal.
+     * A "turn" increments on each user message.
+     */
+    private _turnIndex;
+    /**
+     * Pre-sessionId history buffer.
+     * Entries are buffered here until the first save() establishes a sessionId,
+     * at which point the buffer is flushed to the journal.
+     * No extra memory cost — these items are already in _conversation.
+     */
+    private _historyBuffer;
+    /** Filter for journal entry types. When set, only matching types are journaled. */
+    private readonly _journalFilter;
     /**
      * Create a new AgentContextNextGen instance.
      */
@@ -3260,6 +3279,14 @@ declare class AgentContextNextGen extends EventEmitter<ContextEvents> {
      * Get current input (read-only).
      */
     getCurrentInput(): ReadonlyArray<InputItem>;
+    /**
+     * Get the history journal (if storage supports it).
+     *
+     * The journal provides read access to full conversation history,
+     * independent of context compaction. Returns null if storage is not
+     * configured or doesn't support journaling.
+     */
+    get journal(): IHistoryJournal | null;
     /**
      * Get conversation length.
      */
@@ -3442,6 +3469,16 @@ declare class AgentContextNextGen extends EventEmitter<ContextEvents> {
     /**
      * Generate unique ID.
      */
+    /**
+     * Append items to the history journal.
+     *
+     * If a sessionId is established and storage supports journaling,
+     * appends directly (fire-and-forget, non-blocking).
+     * Otherwise, buffers entries until the first save().
+     *
+     * No extra memory cost for the buffer — items are already in _conversation.
+     */
+    private _journalAppend;
     private generateId;
     /**
      * Assert context is not destroyed.
@@ -4027,6 +4064,17 @@ interface AgentConfig$1 extends BaseAgentConfig {
         toolFailureMode?: 'fail' | 'continue';
         maxConsecutiveErrors?: number;
     };
+    /** Configuration for retrying empty/incomplete LLM responses */
+    emptyResponseRetry?: {
+        /** Enable retry for empty responses (default: true) */
+        enabled?: boolean;
+        /** Max retry attempts (default: 2) */
+        maxRetries?: number;
+        /** Initial backoff delay ms (default: 1000) */
+        initialDelayMs?: number;
+        /** Max backoff delay ms (default: 5000) */
+        maxDelayMs?: number;
+    };
 }
 /**
  * Agent class - represents an AI assistant with tool calling capabilities
@@ -4042,6 +4090,7 @@ interface AgentConfig$1 extends BaseAgentConfig {
 declare class Agent extends BaseAgent<AgentConfig$1, AgentEvents> implements IDisposable {
     private hookManager;
     private executionContext;
+    private _toolRegisteredListener;
     private _paused;
     private _cancelled;
     private _pausePromise;
@@ -6002,6 +6051,29 @@ interface ITextToSpeechProvider extends IProvider {
      */
     listVoices?(): Promise<IVoiceInfo[]>;
 }
+/**
+ * A single chunk of streamed TTS audio
+ */
+interface TTSStreamChunk {
+    /** Audio data for this chunk */
+    audio: Buffer;
+    /** True when this is the last chunk */
+    isFinal: boolean;
+}
+/**
+ * Streaming Text-to-Speech provider interface (opt-in extension)
+ * Providers that support chunked transfer implement this alongside ITextToSpeechProvider.
+ */
+interface IStreamingTextToSpeechProvider extends ITextToSpeechProvider {
+    /**
+     * Check if streaming is supported for the given format
+     */
+    supportsStreaming(format?: AudioFormat): boolean;
+    /**
+     * Stream TTS audio chunks as they arrive from the API
+     */
+    synthesizeStream(options: TTSOptions): AsyncIterableIterator<TTSStreamChunk>;
+}
 /**
  * STT output format types
  */
@@ -6234,6 +6306,15 @@ declare class TextToSpeech {
      * @param options - Optional synthesis parameters
      */
     toFile(text: string, filePath: string, options?: Partial<Omit<TTSOptions, 'model' | 'input'>>): Promise<void>;
+    /**
+     * Check if the underlying provider supports streaming TTS
+     */
+    supportsStreaming(format?: AudioFormat): boolean;
+    /**
+     * Stream TTS audio chunks as they arrive from the API.
+     * Falls back to buffered synthesis yielding a single chunk if provider doesn't support streaming.
+     */
+    synthesizeStream(text: string, options?: Partial<Omit<TTSOptions, 'model' | 'input'>>): AsyncIterableIterator<TTSStreamChunk>;
     /**
      * Get model information for current or specified model
      */
@@ -7088,6 +7169,324 @@ declare class VideoGeneration {
  */
 declare function createVideoProvider(connector: Connector): IVideoProvider;
 
+/**
+ * Types for voice pseudo-streaming capability
+ */
+
+/**
+ * Interface for text chunking strategies used by VoiceStream.
+ * Implementations accumulate streaming text deltas and emit complete
+ * chunks suitable for TTS synthesis.
+ */
+interface IChunkingStrategy {
+    /**
+     * Feed a text delta from the stream.
+     * Returns any completed chunks (sentences/phrases).
+     * Keeps partial text in an internal buffer.
+     */
+    feed(delta: string): string[];
+    /**
+     * Flush remaining buffered text as a final chunk.
+     * Called when the text stream ends.
+     */
+    flush(): string | null;
+    /** Reset internal state for reuse */
+    reset(): void;
+}
+/**
+ * Options for the default SentenceChunkingStrategy
+ */
+interface ChunkingOptions {
+    /** Minimum characters before emitting a chunk. Default: 20 */
+    minChunkLength?: number;
+    /** Maximum characters per chunk. Forces split at clause boundary. Default: 500 */
+    maxChunkLength?: number;
+    /** Skip text inside fenced code blocks. Default: true */
+    skipCodeBlocks?: boolean;
+    /** Strip markdown formatting (bold, italic, links, headings). Default: true */
+    stripMarkdown?: boolean;
+    /** Additional abbreviations to recognize (e.g., ['Corp.', 'Ltd.']) */
+    additionalAbbreviations?: string[];
+}
+/**
+ * Configuration for VoiceStream
+ */
+interface VoiceStreamConfig {
+    /** TTS connector name or instance */
+    ttsConnector: string | Connector;
+    /** TTS model (e.g., 'tts-1-hd', 'gpt-4o-mini-tts') */
+    ttsModel?: string;
+    /** Voice ID (e.g., 'nova', 'alloy') */
+    voice?: string;
+    /** Audio output format. Default: 'mp3' */
+    format?: AudioFormat;
+    /** Speech speed (0.25 to 4.0). Default: 1.0 */
+    speed?: number;
+    /** Custom chunking strategy. Default: SentenceChunkingStrategy */
+    chunkingStrategy?: IChunkingStrategy;
+    /** Options for default chunking strategy (ignored if chunkingStrategy provided) */
+    chunkingOptions?: ChunkingOptions;
+    /** Maximum concurrent TTS synthesis requests. Default: 2 */
+    maxConcurrentTTS?: number;
+    /**
+     * Maximum queued chunks waiting for TTS.
+     * When full, wrap() awaits a free slot (lossless backpressure).
+     * Default: 5
+     */
+    maxQueuedChunks?: number;
+    /** Vendor-specific TTS options passthrough */
+    vendorOptions?: Record<string, unknown>;
+    /**
+     * Enable streaming TTS. When true, audio chunks are yielded as they arrive
+     * from the API instead of buffering the entire response. Best with format 'pcm'.
+     * Default: false
+     */
+    streaming?: boolean;
+}
+/**
+ * Events emitted by VoiceStream via EventEmitter
+ */
+interface VoiceStreamEvents {
+    'audio:ready': (data: {
+        chunkIndex: number;
+        text: string;
+        durationSeconds?: number;
+    }) => void;
+    'audio:error': (data: {
+        chunkIndex: number;
+        text: string;
+        error: Error;
+    }) => void;
+    'audio:complete': (data: {
+        totalChunks: number;
+        totalDurationSeconds?: number;
+    }) => void;
+    'audio:interrupted': (data: {
+        pendingChunks: number;
+    }) => void;
+}
+/**
+ * Callback invoked when the next in-order audio chunk is ready for playback
+ */
+type AudioChunkPlaybackCallback = (event: AudioChunkReadyEvent) => void;
+
+/**
+ * VoiceStream - Voice pseudo-streaming capability
+ *
+ * Wraps an agent's text stream and interleaves audio events by chunking text
+ * into sentences and synthesizing them via TTS in parallel. Produces the
+ * illusion of real-time speech streaming.
+ *
+ * @example
+ * ```typescript
+ * const voice = VoiceStream.create({
+ *   ttsConnector: 'openai',
+ *   ttsModel: 'tts-1-hd',
+ *   voice: 'nova',
+ * });
+ *
+ * for await (const event of voice.wrap(agent.stream('Tell me a story'))) {
+ *   if (event.type === StreamEventType.OUTPUT_TEXT_DELTA) {
+ *     process.stdout.write(event.delta);
+ *   } else if (event.type === StreamEventType.AUDIO_CHUNK_READY) {
+ *     playbackQueue.enqueue(event);
+ *   }
+ * }
+ * ```
+ */
+
+declare class VoiceStream extends EventEmitter$1 implements IDisposable {
+    private tts;
+    private chunker;
+    private format;
+    private speed;
+    private maxConcurrentTTS;
+    private maxQueuedChunks;
+    private vendorOptions?;
+    private streaming;
+    private chunkIndex;
+    private totalCharacters;
+    private totalDuration;
+    private activeJobs;
+    private activeTTSCount;
+    private interrupted;
+    private lastResponseId;
+    private _isDestroyed;
+    private slotWaiters;
+    private audioEventBuffer;
+    private bufferNotify;
+    private queueWaiters;
+    /**
+     * Create a new VoiceStream instance
+     */
+    static create(config: VoiceStreamConfig): VoiceStream;
+    private constructor();
+    /**
+     * Transform an agent text stream into an augmented stream with audio events.
+     * Original text events pass through unchanged; audio events are interleaved.
+     *
+     * The generator yields events in this order:
+     * 1. All original StreamEvents (pass-through)
+     * 2. AudioChunkReady/AudioChunkError events as TTS completes
+     * 3. AudioStreamComplete as the final audio event
+     */
+    wrap(textStream: AsyncIterableIterator<StreamEvent>): AsyncIterableIterator<StreamEvent>;
+    /**
+     * Interrupt audio generation. Cancels pending TTS and flushes queue.
+     * Call this when the user sends a new message mid-speech.
+     * Active HTTP requests cannot be cancelled but their results will be discarded.
+     */
+    interrupt(): void;
+    /**
+     * Reset state for a new stream. Called automatically by wrap().
+     */
+    reset(): void;
+    destroy(): void;
+    get isDestroyed(): boolean;
+    /**
+     * Schedule a text chunk for TTS synthesis.
+     * Awaits a free queue slot if backpressure is active (lossless).
+     */
+    private scheduleTTS;
+    /**
+     * Execute TTS for a single text chunk.
+     * Respects concurrency semaphore.
+     * Branches on streaming mode: yields sub-chunks or a single buffered chunk.
+     */
+    private executeTTS;
+    /**
+     * Drain the audio event buffer, yielding all ready events.
+     */
+    private drainAudioBuffer;
+    /**
+     * Push an audio event and wake up the consumer in wrap()
+     */
+    private pushAudioEvent;
+    /**
+     * Wait until a new event is pushed to the audio buffer
+     */
+    private waitForBufferNotify;
+    private waitForTTSSlot;
+    private releaseTTSSlot;
+    private waitForQueueSlot;
+    private releaseQueueWaiter;
+    private releaseAllWaiters;
+    private cleanup;
+}
+
+/**
+ * Sentence boundary detection for voice pseudo-streaming.
+ * Splits streaming text deltas into speakable chunks.
+ */
+
+/**
+ * Default chunking strategy that splits text at sentence boundaries.
+ *
+ * Handles:
+ * - Sentence terminators (. ? !) followed by whitespace
+ * - Abbreviation exclusion (Dr., Mr., U.S., e.g., etc.)
+ * - Numeric decimals (3.14, $1.50)
+ * - Paragraph breaks (\n\n)
+ * - Fenced code block tracking (``` ... ```)
+ * - Markdown stripping
+ * - Min/max chunk length enforcement
+ */
+declare class SentenceChunkingStrategy implements IChunkingStrategy {
+    private buffer;
+    private inCodeBlock;
+    private codeBlockBuffer;
+    private options;
+    private abbreviations;
+    constructor(options?: ChunkingOptions);
+    feed(delta: string): string[];
+    flush(): string | null;
+    reset(): void;
+    private extractChunks;
+    /**
+     * Track and remove fenced code blocks from the buffer.
+     * Text inside code blocks is discarded (not spoken).
+     */
+    private processCodeBlocks;
+    /**
+     * Find the position right after the next sentence boundary.
+     * Returns -1 if no complete sentence boundary found.
+     */
+    private findSentenceBoundary;
+    /**
+     * Check if the period at position `pos` is part of a known abbreviation.
+     */
+    private isAbbreviation;
+    /**
+     * Check if the period at position `pos` is a decimal point.
+     * e.g., 3.14, $1.50
+     */
+    private isDecimalNumber;
+    /**
+     * Check if the period at position `pos` is part of an ellipsis (...).
+     */
+    private isEllipsis;
+    /**
+     * Split text that exceeds maxChunkLength at clause boundaries.
+     */
+    private splitLongText;
+    /**
+     * Merge chunks that are shorter than minChunkLength with the next chunk.
+     */
+    private mergeSmallChunks;
+    /**
+     * Strip markdown formatting from text for natural speech.
+     */
+    private cleanForSpeech;
+}
+
+/**
+ * AudioPlaybackQueue - Consumer-side helper for ordered audio playback
+ *
+ * TTS chunks may complete out of order (chunk 2 finishes before chunk 1).
+ * This queue buffers audio events and delivers them to the callback
+ * in sequential order by chunk_index.
+ *
+ * @example
+ * ```typescript
+ * const queue = new AudioPlaybackQueue((event) => {
+ *   // Play audio chunk — guaranteed to be in order
+ *   playAudio(Buffer.from(event.audio_base64, 'base64'));
+ * });
+ *
+ * for await (const event of voiceStream.wrap(agent.stream('Hello'))) {
+ *   if (isAudioChunkReady(event)) {
+ *     queue.enqueue(event);
+ *   }
+ * }
+ * ```
+ */
+
+declare class AudioPlaybackQueue {
+    private buffer;
+    private nextPlayIndex;
+    private onReady;
+    constructor(onReady: AudioChunkPlaybackCallback);
+    /**
+     * Enqueue an audio chunk event. If it's the next expected chunk,
+     * it (and any subsequent buffered chunks) are immediately delivered
+     * to the callback in order.
+     */
+    enqueue(event: AudioChunkReadyEvent): void;
+    /**
+     * Reset the queue (e.g., on interruption or new stream).
+     */
+    reset(): void;
+    /**
+     * Number of chunks currently buffered waiting for earlier chunks.
+     */
+    get pendingCount(): number;
+    /**
+     * The next chunk index expected for playback.
+     */
+    get nextExpectedIndex(): number;
+    private drain;
+}
+
 /**
  * SearchProvider - Unified search interface with connector support
  *
@@ -7853,2099 +8252,2277 @@ declare function documentToContent(result: DocumentResult, options?: DocumentToC
 declare function readDocumentAsContent(source: DocumentSource | string, options?: DocumentReadOptions & DocumentToContentOptions): Promise<Content[]>;
 
 /**
- * WorkingMemory class - manages indexed working memory for TaskAgent
- *
- * This is a GENERIC implementation that works across all agent types:
- * - Basic Agent: Uses staticPriorityCalculator with simple scopes
- * - TaskAgent: Uses taskAwarePriorityCalculator with task-aware scopes
- * - UniversalAgent: Can switch calculators based on mode
+ * Agent state entities for TaskAgent
  *
- * The PriorityCalculator strategy pattern allows different agents to have
- * different eviction behaviors without changing the core WorkingMemory logic.
+ * Defines the full agent state needed for persistence and resume.
  */
 
 /**
- * Serialized memory state for persistence
+ * Agent execution status
  */
-interface SerializedMemory {
-    /** Memory format version */
-    version: number;
-    /** Serialized memory entries */
-    entries: SerializedMemoryEntry[];
+type AgentStatus = 'idle' | 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Agent configuration (needed for resume)
+ */
+interface AgentConfig {
+    connectorName: string;
+    model: string;
+    temperature?: number;
+    maxIterations?: number;
+    toolNames: string[];
 }
 /**
- * Serialized memory entry
+ * Conversation message in history
  */
-interface SerializedMemoryEntry {
-    key: string;
-    description: string;
-    value: unknown;
-    scope: MemoryScope;
-    sizeBytes: number;
-    basePriority?: MemoryPriority;
-    pinned?: boolean;
+interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
 }
 /**
- * Eviction strategy type
+ * Agent execution metrics
  */
-type EvictionStrategy = 'lru' | 'size';
-interface WorkingMemoryEvents {
-    stored: {
-        key: string;
-        description: string;
-        scope: MemoryScope;
-    };
-    retrieved: {
-        key: string;
-    };
-    deleted: {
-        key: string;
-    };
-    evicted: {
-        keys: string[];
-        reason: 'lru' | 'size' | 'task_completed';
-    };
-    limit_warning: {
-        utilizationPercent: number;
-    };
-    stale_entries: {
-        entries: StaleEntryInfo[];
-    };
+interface AgentMetrics {
+    totalLLMCalls: number;
+    totalToolCalls: number;
+    totalTokensUsed: number;
+    totalCost: number;
 }
 /**
- * WorkingMemory manages the agent's indexed working memory.
- *
- * Features:
- * - Store/retrieve with descriptions for index
- * - Scoped memory (simple or task-aware)
- * - Priority-based eviction (respects pinned, priority, then LRU)
- * - Pluggable priority calculation via PriorityCalculator strategy
- * - Task completion detection and stale entry notification
- * - Event emission for monitoring
+ * Full agent state - everything needed to resume
  */
-declare class WorkingMemory extends EventEmitter<WorkingMemoryEvents> implements IDisposable {
-    private storage;
-    private config;
-    private priorityCalculator;
-    private priorityContext;
-    private _isDestroyed;
-    /**
-     * Create a WorkingMemory instance
-     *
-     * @param storage - Storage backend for memory entries
-     * @param config - Memory configuration (limits, etc.)
-     * @param priorityCalculator - Strategy for computing effective priority (default: static)
-     */
-    constructor(storage: IMemoryStorage, config?: WorkingMemoryConfig, priorityCalculator?: PriorityCalculator);
-    /**
-     * Set the priority calculator (for switching strategies at runtime)
-     */
-    setPriorityCalculator(calculator: PriorityCalculator): void;
-    /**
-     * Update priority context (e.g., task states for TaskAgent)
-     */
-    setPriorityContext(context: PriorityContext): void;
-    /**
-     * Get the current priority context
-     */
-    getPriorityContext(): PriorityContext;
+interface AgentState {
+    id: string;
+    status: AgentStatus;
+    /** Configuration */
+    config: AgentConfig;
+    /** Current plan */
+    plan: Plan;
+    /** Working memory reference */
+    memoryId: string;
+    /** Conversation history (for context continuity) */
+    conversationHistory: ConversationMessage[];
+    /** Timestamps */
+    createdAt: number;
+    startedAt?: number;
+    suspendedAt?: number;
+    completedAt?: number;
+    lastActivityAt: number;
+    /** Metrics */
+    metrics: AgentMetrics;
+}
+
+/**
+ * Plan storage interface for plan persistence.
+ * Implement for long-running agent support.
+ */
+
+interface IPlanStorage {
     /**
-     * Compute effective priority for an entry using the current calculator
+     * Save or update a plan
      */
-    private computeEffectivePriority;
+    savePlan(plan: Plan): Promise<void>;
     /**
-     * Get all entries with their computed effective priorities
-     * This is a performance optimization to avoid repeated getAll() + map() calls
+     * Get plan by ID
      */
-    private getEntriesWithPriority;
+    getPlan(planId: string): Promise<Plan | undefined>;
     /**
-     * Get evictable entries sorted by eviction priority
-     * Filters out pinned and critical entries, sorts by priority then by strategy
+     * Update a specific task within a plan
      */
-    private getEvictableEntries;
+    updateTask(planId: string, task: Task): Promise<void>;
     /**
-     * Store a value in working memory
-     *
-     * @param key - Unique key for the entry
-     * @param description - Short description for the index (max 150 chars)
-     * @param value - The data to store
-     * @param options - Optional scope, priority, and pinned settings
+     * Add a new task to a plan (for dynamic task creation)
      */
-    store(key: string, description: string, value: unknown, options?: {
-        scope?: MemoryScope;
-        priority?: MemoryPriority;
-        pinned?: boolean;
-    }): Promise<void>;
+    addTask(planId: string, task: Task): Promise<void>;
     /**
-     * Enforce the maxIndexEntries limit by evicting excess entries
-     * Only evicts if entry count exceeds the configured limit
+     * Delete a plan
      */
-    private enforceEntryCountLimit;
+    deletePlan(planId: string): Promise<void>;
     /**
-     * Get the configured max index entries limit
+     * List plans by status
      */
-    getMaxIndexEntries(): number | undefined;
+    listPlans(filter?: {
+        status?: PlanStatus[];
+    }): Promise<Plan[]>;
     /**
-     * Store a value scoped to specific tasks
-     * Convenience method for task-aware memory
+     * Find plans with tasks waiting on a specific webhook
      */
-    storeForTasks(key: string, description: string, value: unknown, taskIds: string[], options?: {
-        priority?: MemoryPriority;
-        pinned?: boolean;
-    }): Promise<void>;
+    findByWebhookId(webhookId: string): Promise<{
+        plan: Plan;
+        task: Task;
+    } | undefined>;
+}
+
+/**
+ * Agent state storage interface for full agent state persistence.
+ * Required for resume capability.
+ */
+
+interface IAgentStateStorage {
     /**
-     * Store a value scoped to the entire plan
-     * Convenience method for plan-scoped memory
+     * Save agent state
      */
-    storeForPlan(key: string, description: string, value: unknown, options?: {
-        priority?: MemoryPriority;
-        pinned?: boolean;
-    }): Promise<void>;
+    save(state: AgentState): Promise<void>;
     /**
-     * Retrieve a value from working memory
-     *
-     * Note: Access stats update is not strictly atomic. Under very high concurrency,
-     * accessCount may be slightly inaccurate. This is acceptable for memory management
-     * purposes where exact counts are not critical.
+     * Load agent state
      */
-    retrieve(key: string): Promise<unknown>;
+    load(agentId: string): Promise<AgentState | undefined>;
     /**
-     * Retrieve multiple values
+     * Delete agent state
      */
-    retrieveMany(keys: string[]): Promise<Record<string, unknown>>;
+    delete(agentId: string): Promise<void>;
     /**
-     * Delete a value from working memory
+     * List agents by status
      */
-    delete(key: string): Promise<void>;
+    list(filter?: {
+        status?: AgentStatus[];
+    }): Promise<AgentState[]>;
     /**
-     * Check if key exists
+     * Update specific fields (partial update for efficiency)
      */
+    patch(agentId: string, updates: Partial<AgentState>): Promise<void>;
+}
+
+/**
+ * In-memory storage implementations (default, non-persistent)
+ */
+
+/**
+ * In-memory implementation of IMemoryStorage
+ */
+declare class InMemoryStorage implements IMemoryStorage {
+    private store;
+    get(key: string): Promise<MemoryEntry | undefined>;
+    set(key: string, entry: MemoryEntry): Promise<void>;
+    delete(key: string): Promise<void>;
     has(key: string): Promise<boolean>;
+    getAll(): Promise<MemoryEntry[]>;
+    getByScope(scope: MemoryScope): Promise<MemoryEntry[]>;
+    clearScope(scope: MemoryScope): Promise<void>;
+    clear(): Promise<void>;
+    getTotalSize(): Promise<number>;
+}
+/**
+ * In-memory implementation of IPlanStorage
+ */
+declare class InMemoryPlanStorage implements IPlanStorage {
+    private plans;
+    savePlan(plan: Plan): Promise<void>;
+    getPlan(planId: string): Promise<Plan | undefined>;
+    updateTask(planId: string, task: Task): Promise<void>;
+    addTask(planId: string, task: Task): Promise<void>;
+    deletePlan(planId: string): Promise<void>;
+    listPlans(filter?: {
+        status?: PlanStatus[];
+    }): Promise<Plan[]>;
+    findByWebhookId(webhookId: string): Promise<{
+        plan: Plan;
+        task: Task;
+    } | undefined>;
+}
+/**
+ * In-memory implementation of IAgentStateStorage
+ */
+declare class InMemoryAgentStateStorage implements IAgentStateStorage {
+    private agents;
+    save(state: AgentState): Promise<void>;
+    load(agentId: string): Promise<AgentState | undefined>;
+    delete(agentId: string): Promise<void>;
+    list(filter?: {
+        status?: AgentStatus[];
+    }): Promise<AgentState[]>;
+    patch(agentId: string, updates: Partial<AgentState>): Promise<void>;
+}
+/**
+ * Unified agent storage interface
+ */
+interface IAgentStorage {
+    memory: IMemoryStorage;
+    plan: IPlanStorage;
+    agent: IAgentStateStorage;
+}
+/**
+ * Create agent storage with defaults
+ */
+declare function createAgentStorage(options?: {
+    memory?: IMemoryStorage;
+    plan?: IPlanStorage;
+    agent?: IAgentStateStorage;
+}): IAgentStorage;
+
+/**
+ * FilePersistentInstructionsStorage - File-based storage for persistent instructions
+ *
+ * Stores custom agent instructions as a JSON file on disk.
+ * Path: ~/.oneringai/agents/<agentId>/custom_instructions.json
+ * Windows: %APPDATA%/oneringai/agents/<agentId>/custom_instructions.json
+ *
+ * Features:
+ * - Cross-platform path handling
+ * - Safe agent ID sanitization
+ * - Atomic file operations
+ * - Automatic directory creation
+ * - Legacy .md file migration
+ */
+
+/**
+ * Configuration for FilePersistentInstructionsStorage
+ */
+interface FilePersistentInstructionsStorageConfig {
+    /** Agent ID (used to create unique storage path) */
+    agentId: string;
+    /** Override the base directory (default: ~/.oneringai/agents) */
+    baseDirectory?: string;
+    /** Override the filename (default: custom_instructions.json) */
+    filename?: string;
+}
+/**
+ * File-based storage for persistent agent instructions
+ */
+declare class FilePersistentInstructionsStorage implements IPersistentInstructionsStorage {
+    private readonly directory;
+    private readonly filePath;
+    private readonly legacyFilePath;
+    private readonly agentId;
+    constructor(config: FilePersistentInstructionsStorageConfig);
     /**
-     * Promote an entry to persistent scope
-     * Works with both simple and task-aware scopes
+     * Load instruction entries from file.
+     * Falls back to legacy .md file migration if JSON not found.
      */
-    persist(key: string): Promise<void>;
+    load(): Promise<InstructionEntry[] | null>;
     /**
-     * Pin an entry (never evicted)
+     * Save instruction entries to file as JSON.
+     * Creates directory if it doesn't exist.
+     * Cleans up legacy .md file if present.
      */
-    pin(key: string): Promise<void>;
+    save(entries: InstructionEntry[]): Promise<void>;
     /**
-     * Unpin an entry
+     * Delete instructions file (and legacy .md if exists)
      */
-    unpin(key: string, newPriority?: MemoryPriority): Promise<void>;
+    delete(): Promise<void>;
     /**
-     * Set the base priority of an entry
+     * Check if instructions file exists (JSON or legacy .md)
      */
-    setPriority(key: string, priority: MemoryPriority): Promise<void>;
+    exists(): Promise<boolean>;
     /**
-     * Update the scope of an entry without re-storing the value
+     * Get the file path (for display/debugging)
      */
-    updateScope(key: string, scope: MemoryScope): Promise<void>;
+    getPath(): string;
     /**
-     * Add task IDs to an existing task-scoped entry
-     * If entry is not task-scoped, converts it to task-scoped
+     * Get the agent ID
      */
-    addTasksToScope(key: string, taskIds: string[]): Promise<void>;
+    getAgentId(): string;
     /**
-     * Clear all entries of a specific scope
+     * Ensure the directory exists
      */
-    clearScope(scope: MemoryScope): Promise<void>;
+    private ensureDirectory;
     /**
-     * Clear all entries
+     * Remove legacy .md file if it exists
      */
-    clear(): Promise<void>;
-    /**
-     * Get memory index with computed effective priorities
-     * Respects maxIndexEntries limit for context display
+    private removeLegacyFile;
+}
+
+/**
+ * FileContextStorage - File-based storage for AgentContext session persistence
+ *
+ * Stores context sessions as JSON files on disk.
+ * Path: ~/.oneringai/agents/<agentId>/sessions/<sessionId>.json
+ * Windows: %APPDATA%/oneringai/agents/<agentId>/sessions/<sessionId>.json
+ *
+ * Features:
+ * - Cross-platform path handling
+ * - Safe session ID sanitization
+ * - Atomic file operations (write to temp, then rename)
+ * - Automatic directory creation
+ * - Index file for fast listing
+ */
+
+/**
+ * Configuration for FileContextStorage
+ */
+interface FileContextStorageConfig {
+    /** Agent ID (used to create unique storage path) */
+    agentId: string;
+    /** Override the base directory (default: ~/.oneringai/agents) */
+    baseDirectory?: string;
+    /** Pretty-print JSON (default: true for debugging, false in production) */
+    prettyPrint?: boolean;
+}
+/**
+ * File-based storage for AgentContext session persistence
+ */
+declare class FileContextStorage implements IContextStorage {
+    private readonly agentId;
+    private readonly sessionsDirectory;
+    private readonly indexPath;
+    private readonly prettyPrint;
+    private index;
+    /** History journal companion — appends full conversation history as JSONL */
+    readonly journal: IHistoryJournal;
+    constructor(config: FileContextStorageConfig);
+    /**
+     * Save context state to a session file
      */
-    getIndex(): Promise<MemoryIndex>;
+    save(sessionId: string, state: SerializedContextState, metadata?: ContextSessionMetadata): Promise<void>;
     /**
-     * Format index for context injection
+     * Load context state from a session file
      */
-    formatIndex(): Promise<string>;
+    load(sessionId: string): Promise<StoredContextSession | null>;
     /**
-     * Evict entries using specified strategy
-     *
-     * Eviction order:
-     * 1. Never evict pinned entries
-     * 2. Evict low priority first, then normal, then high (never critical)
-     * 3. Within same priority, use strategy (LRU or largest size)
-     *
-     * @param count - Number of entries to evict
-     * @param strategy - Eviction strategy ('lru' or 'size')
-     * @returns Keys of evicted entries
+     * Delete a session
      */
-    evict(count: number, strategy?: EvictionStrategy): Promise<string[]>;
+    delete(sessionId: string): Promise<void>;
     /**
-     * Evict entries using priority-aware LRU algorithm
-     * @deprecated Use evict(count, 'lru') instead
+     * Check if a session exists
      */
-    evictLRU(count: number): Promise<string[]>;
+    exists(sessionId: string): Promise<boolean>;
     /**
-     * Evict largest entries first (priority-aware)
-     * @deprecated Use evict(count, 'size') instead
+     * List all sessions (summaries only)
      */
-    evictBySize(count: number): Promise<string[]>;
+    list(options?: ContextStorageListOptions): Promise<ContextSessionSummary[]>;
     /**
-     * Handle task completion - detect and notify about stale entries
-     *
-     * Call this when a task completes to:
-     * 1. Update priority context with new task state
-     * 2. Detect entries that became stale
-     * 3. Emit event to notify LLM about stale entries
-     *
-     * @param taskId - The completed task ID
-     * @param taskStates - Current task states map
-     * @returns Information about stale entries
+     * Update session metadata without loading full state
      */
-    onTaskComplete(taskId: string, taskStates: Map<string, TaskStatusForMemory>): Promise<StaleEntryInfo[]>;
+    updateMetadata(sessionId: string, metadata: Partial<ContextSessionMetadata>): Promise<void>;
     /**
-     * Evict entries for completed tasks
-     *
-     * Removes entries that were scoped only to completed tasks.
-     * Use after onTaskComplete() if you want automatic cleanup.
-     *
-     * @param taskStates - Current task states map
-     * @returns Keys of evicted entries
+     * Get the storage path (for display/debugging)
+     * @deprecated Use getLocation() instead
      */
-    evictCompletedTaskEntries(taskStates: Map<string, TaskStatusForMemory>): Promise<string[]>;
+    getPath(): string;
     /**
-     * Get limited memory access for tools
-     *
-     * This provides a simplified interface for tools to interact with memory
-     * without exposing the full WorkingMemory API.
+     * Get a human-readable storage location string (for display/debugging)
      */
-    getAccess(): WorkingMemoryAccess;
+    getLocation(): string;
     /**
-     * Store raw data (low priority, first to be evicted)
-     *
-     * Use this for original/unprocessed data that should be summarized.
-     * Raw data is automatically evicted first when memory pressure is high.
-     *
-     * @param key - Key without tier prefix (prefix is added automatically)
-     * @param description - Brief description for the index
-     * @param value - The raw data to store
-     * @param options - Optional scope and task IDs
+     * Get the agent ID
      */
-    storeRaw(key: string, description: string, value: unknown, options?: {
-        taskIds?: string[];
-        scope?: MemoryScope;
-    }): Promise<void>;
+    getAgentId(): string;
     /**
-     * Store a summary derived from raw data (normal priority)
-     *
-     * Use this for processed/summarized data that extracts key information.
-     * Links back to source data for cleanup tracking.
-     *
-     * @param key - Key without tier prefix (prefix is added automatically)
-     * @param description - Brief description for the index
-     * @param value - The summary data
-     * @param derivedFrom - Key(s) this summary was derived from
-     * @param options - Optional scope and task IDs
+     * Rebuild the index by scanning all session files
+     * Useful for recovery or migration
      */
-    storeSummary(key: string, description: string, value: unknown, derivedFrom: string | string[], options?: {
-        taskIds?: string[];
-        scope?: MemoryScope;
-    }): Promise<void>;
+    rebuildIndex(): Promise<void>;
+    private getFilePath;
+    private ensureDirectory;
+    private loadRaw;
+    private loadIndex;
+    private saveIndex;
+    private updateIndex;
+    private removeFromIndex;
+    private storedToIndexEntry;
+}
+/**
+ * Create a FileContextStorage for the given agent
+ *
+ * @param agentId - Agent ID
+ * @param options - Optional configuration
+ * @returns FileContextStorage instance
+ *
+ * @example
+ * ```typescript
+ * const storage = createFileContextStorage('my-agent');
+ * const ctx = AgentContext.create({
+ *   model: 'gpt-4',
+ *   storage,
+ * });
+ *
+ * // Save session
+ * await ctx.save('session-001', { title: 'My Session' });
+ *
+ * // Load session
+ * await ctx.load('session-001');
+ * ```
+ */
+declare function createFileContextStorage(agentId: string, options?: Omit<FileContextStorageConfig, 'agentId'>): FileContextStorage;
+
+/**
+ * FileHistoryJournal - JSONL-based append-only conversation history journal
+ *
+ * Stores history entries as newline-delimited JSON (JSONL) files alongside
+ * session state files. Each line is a self-contained JSON object representing
+ * one HistoryEntry.
+ *
+ * Path: <sessionsDirectory>/<sessionId>.history.jsonl
+ *
+ * Design:
+ * - Append-only writes (fast, no rewrite of existing data)
+ * - Line-based reads with filtering (no need to parse entire file for counts)
+ * - Streaming support via async iteration
+ * - Automatic directory creation on first write
+ *
+ * @example
+ * ```typescript
+ * const journal = new FileHistoryJournal('/path/to/sessions');
+ *
+ * // Append (fast, append-only)
+ * await journal.append('session-1', [{ timestamp: Date.now(), type: 'user', item: msg, turnIndex: 0 }]);
+ *
+ * // Read with filtering
+ * const entries = await journal.read('session-1', { limit: 50, types: ['user', 'assistant'] });
+ *
+ * // Stream large histories
+ * for await (const entry of journal.stream!('session-1')) {
+ *   console.log(entry.type, entry.turnIndex);
+ * }
+ * ```
+ */
+
+/**
+ * File-based history journal using JSONL format.
+ */
+declare class FileHistoryJournal implements IHistoryJournal {
+    private readonly sessionsDirectory;
+    private directoryEnsured;
+    constructor(sessionsDirectory: string);
     /**
-     * Store final findings (high priority, kept longest)
-     *
-     * Use this for conclusions, insights, or final results that should be preserved.
-     * These are the last to be evicted and typically span the entire plan.
-     *
-     * @param key - Key without tier prefix (prefix is added automatically)
-     * @param description - Brief description for the index
-     * @param value - The findings data
-     * @param derivedFrom - Optional key(s) these findings were derived from
-     * @param options - Optional scope, task IDs, and pinned flag
+     * Get the JSONL file path for a session's history.
      */
-    storeFindings(key: string, description: string, value: unknown, _derivedFrom?: string | string[], options?: {
-        taskIds?: string[];
-        scope?: MemoryScope;
-        pinned?: boolean;
-    }): Promise<void>;
+    private journalPath;
     /**
-     * Clean up raw data after summary/findings are created
-     *
-     * Call this after creating summaries to free up memory used by raw data.
-     * Only deletes entries in the 'raw' tier.
-     *
-     * @param derivedFromKeys - Keys to delete (typically from derivedFrom metadata)
-     * @returns Number of entries deleted
+     * Ensure the sessions directory exists (lazy, once per instance).
      */
-    cleanupRawData(derivedFromKeys: string[]): Promise<number>;
+    private ensureDirectory;
     /**
-     * Get all entries by tier
+     * Append entries to the journal file.
      *
-     * @param tier - The tier to filter by
-     * @returns Array of entries in that tier
+     * Uses fs.appendFile which is atomic for small writes on most filesystems.
+     * Each entry is serialized as a single JSON line.
      */
-    getByTier(tier: MemoryTier): Promise<MemoryEntry[]>;
+    append(sessionId: string, entries: HistoryEntry[]): Promise<void>;
     /**
-     * Promote an entry to a higher tier
-     *
-     * Changes the key prefix and updates priority.
-     * Use this when raw data becomes more valuable (e.g., frequently accessed).
+     * Read history entries with optional filtering and pagination.
      *
-     * @param key - Current key (with tier prefix)
-     * @param toTier - Target tier to promote to
-     * @returns New key with updated prefix
+     * For large files, prefer stream() with pagination.
      */
-    promote(key: string, toTier: MemoryTier): Promise<string>;
+    read(sessionId: string, options?: HistoryReadOptions): Promise<HistoryEntry[]>;
     /**
-     * Get tier statistics
+     * Count entries without fully parsing the file.
      *
-     * @returns Count and size by tier
+     * Counts non-empty lines in the JSONL file.
      */
-    getTierStats(): Promise<Record<MemoryTier, {
-        count: number;
-        sizeBytes: number;
-    }>>;
+    count(sessionId: string): Promise<number>;
     /**
-     * Get statistics about memory usage
+     * Delete the journal file for a session.
      */
-    getStats(): Promise<{
-        totalEntries: number;
-        totalSizeBytes: number;
-        utilizationPercent: number;
-        byPriority: Record<MemoryPriority, number>;
-        pinnedCount: number;
-    }>;
+    clear(sessionId: string): Promise<void>;
     /**
-     * Get the configured memory limit
+     * Stream history entries line-by-line using readline.
+     *
+     * Memory-efficient for large histories — only one entry in memory at a time.
      */
-    getLimit(): number;
+    stream(sessionId: string, options?: HistoryReadOptions): AsyncIterable<HistoryEntry>;
     /**
-     * Check if the WorkingMemory instance has been destroyed
+     * Get the file path for a session's journal (for debugging).
      */
-    get isDestroyed(): boolean;
+    getLocation(sessionId: string): string;
     /**
-     * Destroy the WorkingMemory instance
-     * Removes all event listeners and clears internal state
+     * Apply non-pagination filters to an array of entries.
      */
-    destroy(): void;
+    private applyFilters;
     /**
-     * Serialize all memory entries for persistence
-     *
-     * Returns a serializable representation of all memory entries
-     * that can be saved to storage and restored later.
-     *
-     * @returns Serialized memory state
+     * Check if a single entry matches the filter criteria.
      */
-    serialize(): Promise<SerializedMemory>;
-    /**
-     * Restore memory entries from serialized state
-     *
-     * Clears existing memory and repopulates from the serialized state.
-     * Timestamps are reset to current time.
-     *
-     * @param state - Previously serialized memory state
-     */
-    restore(state: SerializedMemory): Promise<void>;
+    private matchesFilters;
 }
 
 /**
- * ExternalDependencyHandler - handles external dependencies
+ * FileAgentDefinitionStorage - File-based storage for agent definitions
+ *
+ * Stores agent definitions as JSON files on disk.
+ * Path: ~/.oneringai/agents/<agentId>/definition.json
+ * Windows: %APPDATA%/oneringai/agents/<agentId>/definition.json
+ *
+ * Features:
+ * - Cross-platform path handling
+ * - Safe agent ID sanitization
+ * - Atomic file operations
+ * - Automatic directory creation
+ * - Index file for fast listing
  */
 
-interface ExternalDependencyEvents {
-    'webhook:received': {
-        webhookId: string;
-        data: unknown;
-    };
-    'poll:success': {
-        taskId: string;
-        data: unknown;
-    };
-    'poll:timeout': {
-        taskId: string;
-    };
-    'scheduled:triggered': {
-        taskId: string;
-    };
-    'manual:completed': {
-        taskId: string;
-        data: unknown;
-    };
+/**
+ * Configuration for FileAgentDefinitionStorage
+ */
+interface FileAgentDefinitionStorageConfig {
+    /** Override the base directory (default: ~/.oneringai/agents) */
+    baseDirectory?: string;
+    /** Pretty-print JSON (default: true) */
+    prettyPrint?: boolean;
 }
 /**
- * Handles external task dependencies
+ * File-based storage for agent definitions
  */
-declare class ExternalDependencyHandler extends EventEmitter<ExternalDependencyEvents> {
-    private activePolls;
-    private activeScheduled;
-    private cancelledPolls;
-    private tools;
-    constructor(tools?: ToolFunction[]);
+declare class FileAgentDefinitionStorage implements IAgentDefinitionStorage {
+    private readonly baseDirectory;
+    private readonly indexPath;
+    private readonly prettyPrint;
+    private index;
+    constructor(config?: FileAgentDefinitionStorageConfig);
     /**
-     * Start handling a task's external dependency
+     * Save an agent definition
      */
-    startWaiting(task: Task): Promise<void>;
+    save(definition: StoredAgentDefinition): Promise<void>;
     /**
-     * Stop waiting on a task's external dependency
+     * Load an agent definition
      */
-    stopWaiting(task: Task): void;
+    load(agentId: string): Promise<StoredAgentDefinition | null>;
     /**
-     * Trigger a webhook
+     * Delete an agent definition
      */
-    triggerWebhook(webhookId: string, data: unknown): Promise<void>;
+    delete(agentId: string): Promise<void>;
     /**
-     * Complete a manual task
+     * Check if an agent definition exists
      */
-    completeManual(taskId: string, data: unknown): Promise<void>;
+    exists(agentId: string): Promise<boolean>;
     /**
-     * Start polling for a task with exponential backoff
+     * List all agent definitions
      */
-    private startPolling;
+    list(options?: AgentDefinitionListOptions): Promise<AgentDefinitionSummary[]>;
     /**
-     * Schedule a task to trigger at a specific time
+     * Update metadata without loading full definition
      */
-    private scheduleTask;
+    updateMetadata(agentId: string, metadata: Partial<AgentDefinitionMetadata>): Promise<void>;
     /**
-     * Cleanup all active dependencies
+     * Get storage path
      */
-    cleanup(): void;
+    getPath(): string;
     /**
-     * Update available tools
+     * Rebuild the index by scanning all agent directories
      */
-    updateTools(tools: ToolFunction[]): void;
+    rebuildIndex(): Promise<void>;
+    private ensureDirectory;
+    private loadRaw;
+    private loadIndex;
+    private saveIndex;
+    private updateIndex;
+    private removeFromIndex;
+    private definitionToIndexEntry;
 }
-
 /**
- * Agent state entities for TaskAgent
- *
- * Defines the full agent state needed for persistence and resume.
+ * Create a FileAgentDefinitionStorage with default configuration
  */
+declare function createFileAgentDefinitionStorage(config?: FileAgentDefinitionStorageConfig): FileAgentDefinitionStorage;
 
 /**
- * Agent execution status
- */
-type AgentStatus = 'idle' | 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled';
-/**
- * Agent configuration (needed for resume)
+ * FileMediaStorage - File-based media storage implementation
+ *
+ * Saves generated media to a configurable directory on the local filesystem.
+ * Default output directory: `os.tmpdir()/oneringai-media/`
  */
-interface AgentConfig {
-    connectorName: string;
-    model: string;
-    temperature?: number;
-    maxIterations?: number;
-    toolNames: string[];
+
+interface FileMediaStorageConfig {
+    /** Directory to store media files. Defaults to `os.tmpdir()/oneringai-media/` */
+    outputDir?: string;
+}
+declare class FileMediaStorage implements IMediaStorage {
+    private outputDir;
+    private initialized;
+    constructor(config?: FileMediaStorageConfig);
+    save(data: Buffer, metadata: MediaStorageMetadata): Promise<MediaStorageResult>;
+    read(location: string): Promise<Buffer | null>;
+    delete(location: string): Promise<void>;
+    exists(location: string): Promise<boolean>;
+    list(options?: MediaStorageListOptions): Promise<MediaStorageEntry[]>;
+    getPath(): string;
+    private generateFilename;
+    private ensureDir;
 }
 /**
- * Conversation message in history
+ * Factory function for creating FileMediaStorage instances
  */
-interface ConversationMessage {
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    timestamp: number;
-}
+declare function createFileMediaStorage(config?: FileMediaStorageConfig): FileMediaStorage;
+
 /**
- * Agent execution metrics
+ * FileCustomToolStorage - File-based storage for custom tool definitions
+ *
+ * Stores custom tools as JSON files on disk with per-user isolation.
+ * Path: ~/.oneringai/users/<userId>/custom-tools/<sanitized-name>.json
+ *
+ * Features:
+ * - Per-user isolation (multi-tenant safe)
+ * - Cross-platform path handling
+ * - Safe name sanitization
+ * - Atomic file operations (write to .tmp then rename)
+ * - Per-user index file for fast listing
+ * - Search support (case-insensitive substring on name + description)
  */
-interface AgentMetrics {
-    totalLLMCalls: number;
-    totalToolCalls: number;
-    totalTokensUsed: number;
-    totalCost: number;
-}
+
 /**
- * Full agent state - everything needed to resume
+ * Configuration for FileCustomToolStorage
  */
-interface AgentState {
-    id: string;
-    status: AgentStatus;
-    /** Configuration */
-    config: AgentConfig;
-    /** Current plan */
-    plan: Plan;
-    /** Working memory reference */
-    memoryId: string;
-    /** Conversation history (for context continuity) */
-    conversationHistory: ConversationMessage[];
-    /** Timestamps */
-    createdAt: number;
-    startedAt?: number;
-    suspendedAt?: number;
-    completedAt?: number;
-    lastActivityAt: number;
-    /** Metrics */
-    metrics: AgentMetrics;
+interface FileCustomToolStorageConfig {
+    /** Override the base directory (default: ~/.oneringai/users) */
+    baseDirectory?: string;
+    /** Pretty-print JSON (default: true) */
+    prettyPrint?: boolean;
 }
-
 /**
- * Plan storage interface for plan persistence.
- * Implement for long-running agent support.
+ * File-based storage for custom tool definitions
+ *
+ * Single instance handles all users. UserId is passed to each method.
  */
-
-interface IPlanStorage {
+declare class FileCustomToolStorage implements ICustomToolStorage {
+    private readonly baseDirectory;
+    private readonly prettyPrint;
+    constructor(config?: FileCustomToolStorageConfig);
     /**
-     * Save or update a plan
+     * Get the directory path for a specific user's custom tools
      */
-    savePlan(plan: Plan): Promise<void>;
+    private getUserDirectory;
     /**
-     * Get plan by ID
+     * Get the index file path for a specific user
      */
-    getPlan(planId: string): Promise<Plan | undefined>;
+    private getUserIndexPath;
     /**
-     * Update a specific task within a plan
+     * Get the tool file path for a specific user
      */
-    updateTask(planId: string, task: Task): Promise<void>;
+    private getToolPath;
     /**
-     * Add a new task to a plan (for dynamic task creation)
+     * Save a custom tool definition
      */
-    addTask(planId: string, task: Task): Promise<void>;
+    save(userId: string | undefined, definition: CustomToolDefinition): Promise<void>;
     /**
-     * Delete a plan
+     * Load a custom tool definition by name
      */
-    deletePlan(planId: string): Promise<void>;
+    load(userId: string | undefined, name: string): Promise<CustomToolDefinition | null>;
     /**
-     * List plans by status
+     * Delete a custom tool definition
      */
-    listPlans(filter?: {
-        status?: PlanStatus[];
-    }): Promise<Plan[]>;
+    delete(userId: string | undefined, name: string): Promise<void>;
     /**
-     * Find plans with tasks waiting on a specific webhook
+     * Check if a custom tool exists
      */
-    findByWebhookId(webhookId: string): Promise<{
-        plan: Plan;
-        task: Task;
-    } | undefined>;
-}
-
-/**
- * Agent state storage interface for full agent state persistence.
- * Required for resume capability.
- */
-
-interface IAgentStateStorage {
+    exists(userId: string | undefined, name: string): Promise<boolean>;
     /**
-     * Save agent state
+     * List custom tools (summaries only)
      */
-    save(state: AgentState): Promise<void>;
+    list(userId: string | undefined, options?: CustomToolListOptions): Promise<CustomToolSummary[]>;
     /**
-     * Load agent state
+     * Update metadata without loading full definition
      */
-    load(agentId: string): Promise<AgentState | undefined>;
+    updateMetadata(userId: string | undefined, name: string, metadata: Record<string, unknown>): Promise<void>;
     /**
-     * Delete agent state
+     * Get storage path for a specific user
      */
-    delete(agentId: string): Promise<void>;
-    /**
-     * List agents by status
-     */
-    list(filter?: {
-        status?: AgentStatus[];
-    }): Promise<AgentState[]>;
-    /**
-     * Update specific fields (partial update for efficiency)
-     */
-    patch(agentId: string, updates: Partial<AgentState>): Promise<void>;
+    getPath(userId: string | undefined): string;
+    private ensureDirectory;
+    private loadIndex;
+    private saveIndex;
+    private updateIndex;
+    private removeFromIndex;
+    private definitionToIndexEntry;
 }
-
 /**
- * In-memory storage implementations (default, non-persistent)
+ * Create a FileCustomToolStorage with default configuration
  */
+declare function createFileCustomToolStorage(config?: FileCustomToolStorageConfig): FileCustomToolStorage;
 
 /**
- * In-memory implementation of IMemoryStorage
- */
-declare class InMemoryStorage implements IMemoryStorage {
-    private store;
-    get(key: string): Promise<MemoryEntry | undefined>;
-    set(key: string, entry: MemoryEntry): Promise<void>;
-    delete(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-    getAll(): Promise<MemoryEntry[]>;
-    getByScope(scope: MemoryScope): Promise<MemoryEntry[]>;
-    clearScope(scope: MemoryScope): Promise<void>;
-    clear(): Promise<void>;
-    getTotalSize(): Promise<number>;
-}
-/**
- * In-memory implementation of IPlanStorage
- */
-declare class InMemoryPlanStorage implements IPlanStorage {
-    private plans;
-    savePlan(plan: Plan): Promise<void>;
-    getPlan(planId: string): Promise<Plan | undefined>;
-    updateTask(planId: string, task: Task): Promise<void>;
-    addTask(planId: string, task: Task): Promise<void>;
-    deletePlan(planId: string): Promise<void>;
-    listPlans(filter?: {
-        status?: PlanStatus[];
-    }): Promise<Plan[]>;
-    findByWebhookId(webhookId: string): Promise<{
-        plan: Plan;
-        task: Task;
-    } | undefined>;
-}
-/**
- * In-memory implementation of IAgentStateStorage
- */
-declare class InMemoryAgentStateStorage implements IAgentStateStorage {
-    private agents;
-    save(state: AgentState): Promise<void>;
-    load(agentId: string): Promise<AgentState | undefined>;
-    delete(agentId: string): Promise<void>;
-    list(filter?: {
-        status?: AgentStatus[];
-    }): Promise<AgentState[]>;
-    patch(agentId: string, updates: Partial<AgentState>): Promise<void>;
-}
-/**
- * Unified agent storage interface
- */
-interface IAgentStorage {
-    memory: IMemoryStorage;
-    plan: IPlanStorage;
-    agent: IAgentStateStorage;
-}
-/**
- * Create agent storage with defaults
+ * FileUserInfoStorage - File-based storage for user information
+ *
+ * Stores user information as a JSON file on disk.
+ * Path: ~/.oneringai/users/<userId>/user_info.json
+ * Windows: %APPDATA%/oneringai/users/<userId>/user_info.json
+ *
+ * Features:
+ * - Cross-platform path handling
+ * - Safe user ID sanitization
+ * - Atomic file operations
+ * - Automatic directory creation
+ * - Multi-user support (one storage instance for all users)
  */
-declare function createAgentStorage(options?: {
-    memory?: IMemoryStorage;
-    plan?: IPlanStorage;
-    agent?: IAgentStateStorage;
-}): IAgentStorage;
 
 /**
- * CheckpointManager - manages agent state checkpointing
+ * Configuration for FileUserInfoStorage
  */
-
-interface CheckpointStrategy {
-    /** Checkpoint after every N tool calls */
-    afterToolCalls?: number;
-    /** Checkpoint after every N LLM calls */
-    afterLLMCalls?: number;
-    /** Checkpoint on time interval */
-    intervalMs?: number;
-    /** Always checkpoint before external wait */
-    beforeExternalWait: boolean;
-    /** Checkpoint mode */
-    mode: 'sync' | 'async';
+interface FileUserInfoStorageConfig {
+    /** Override the base directory (default: ~/.oneringai/users) */
+    baseDirectory?: string;
+    /** Override the filename (default: user_info.json) */
+    filename?: string;
 }
-declare const DEFAULT_CHECKPOINT_STRATEGY: CheckpointStrategy;
 /**
- * Manages state checkpointing for persistence and recovery
+ * File-based storage for user information
+ *
+ * Single instance handles all users. UserId is passed to each method.
  */
-declare class CheckpointManager {
-    private storage;
-    private strategy;
-    private toolCallsSinceCheckpoint;
-    private llmCallsSinceCheckpoint;
-    private intervalTimer?;
-    private pendingCheckpoints;
-    private currentState;
-    constructor(storage: IAgentStorage, strategy?: CheckpointStrategy);
+declare class FileUserInfoStorage implements IUserInfoStorage {
+    private readonly baseDirectory;
+    private readonly filename;
+    constructor(config?: FileUserInfoStorageConfig);
     /**
-     * Set the current agent state (for interval checkpointing)
+     * Get the directory path for a specific user
      */
-    setCurrentState(state: AgentState): void;
+    private getUserDirectory;
     /**
-     * Record a tool call (may trigger checkpoint)
+     * Get the file path for a specific user
      */
-    onToolCall(state: AgentState): Promise<void>;
+    private getUserFilePath;
     /**
-     * Record an LLM call (may trigger checkpoint)
+     * Load user info entries from file for a specific user
      */
-    onLLMCall(state: AgentState): Promise<void>;
+    load(userId: string | undefined): Promise<UserInfoEntry[] | null>;
     /**
-     * Force a checkpoint
+     * Save user info entries to file for a specific user
+     * Creates directory if it doesn't exist.
      */
-    checkpoint(state: AgentState, reason: string): Promise<void>;
+    save(userId: string | undefined, entries: UserInfoEntry[]): Promise<void>;
     /**
-     * Perform the actual checkpoint
+     * Delete user info file for a specific user
      */
-    private doCheckpoint;
+    delete(userId: string | undefined): Promise<void>;
     /**
-     * Check if interval-based checkpoint is needed
+     * Check if user info file exists for a specific user
      */
-    private checkIntervalCheckpoint;
+    exists(userId: string | undefined): Promise<boolean>;
     /**
-     * Wait for all pending checkpoints to complete
+     * Get the file path for a specific user (for display/debugging)
      */
-    flush(): Promise<void>;
+    getPath(userId: string | undefined): string;
     /**
-     * Cleanup resources
+     * Ensure the directory exists
      */
-    cleanup(): Promise<void>;
+    private ensureDirectory;
 }
 
 /**
- * PlanningAgent - AI-driven plan generation
+ * FileRoutineDefinitionStorage - File-based storage for routine definitions.
  *
- * Separates planning phase from execution phase.
- * Analyzes goals and generates task graphs with dependencies.
+ * Stores routines as JSON files on disk with per-user isolation.
+ * Path: ~/.oneringai/users/<userId>/routines/<sanitized-id>.json
+ *
+ * Features:
+ * - Per-user isolation (multi-tenant safe)
+ * - Cross-platform path handling
+ * - Safe ID sanitization
+ * - Atomic file operations (write to .tmp then rename)
+ * - Per-user index file for fast listing/filtering
+ * - Index auto-rebuild if missing
  */
 
 /**
- * PlanningAgent configuration
+ * Configuration for FileRoutineDefinitionStorage
  */
-interface PlanningAgentConfig {
-    /** Connector for LLM access */
-    connector: string | Connector;
-    /** Model to use for planning (can be different/cheaper than execution) */
-    model: string;
-    /** Max planning iterations */
-    maxPlanningIterations?: number;
-    /** Temperature for planning (lower = more deterministic) */
-    planningTemperature?: number;
-    /** Tools available for the plan (used to inform planning) */
-    availableTools?: ToolFunction[];
+interface FileRoutineDefinitionStorageConfig {
+    /** Override the base directory (default: ~/.oneringai/users) */
+    baseDirectory?: string;
+    /** Pretty-print JSON (default: true) */
+    prettyPrint?: boolean;
 }
 /**
- * Generated plan with metadata
+ * File-based storage for routine definitions.
+ *
+ * Single instance handles all users. UserId is passed to each method.
  */
-interface GeneratedPlan {
-    plan: Plan;
-    reasoning: string;
-    estimated_duration?: string;
-    complexity?: 'low' | 'medium' | 'high';
+declare class FileRoutineDefinitionStorage implements IRoutineDefinitionStorage {
+    private readonly baseDirectory;
+    private readonly prettyPrint;
+    constructor(config?: FileRoutineDefinitionStorageConfig);
+    private getUserDirectory;
+    private getIndexPath;
+    private getRoutinePath;
+    save(userId: string | undefined, definition: RoutineDefinition): Promise<void>;
+    load(userId: string | undefined, id: string): Promise<RoutineDefinition | null>;
+    delete(userId: string | undefined, id: string): Promise<void>;
+    exists(userId: string | undefined, id: string): Promise<boolean>;
+    list(userId: string | undefined, options?: {
+        tags?: string[];
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<RoutineDefinition[]>;
+    getPath(userId: string | undefined): string;
+    private ensureDirectory;
+    private loadIndex;
+    private saveIndex;
+    private updateIndex;
+    private removeFromIndex;
+    private definitionToIndexEntry;
+    /**
+     * Rebuild index by scanning directory for .json files (excluding _index.json).
+     * Returns empty index if directory doesn't exist.
+     */
+    private rebuildIndex;
 }
 /**
- * PlanningAgent class
+ * Create a FileRoutineDefinitionStorage with default configuration
  */
-declare class PlanningAgent {
-    private agent;
-    private config;
-    private currentTasks;
-    private planningComplete;
-    private constructor();
-    /**
-     * Create a new PlanningAgent
-     */
-    static create(config: PlanningAgentConfig): PlanningAgent;
-    /**
-     * Create planning tools bound to this PlanningAgent instance
-     */
-    private createBoundPlanningTools;
-    /**
-     * Generate a plan from a goal
-     */
-    generatePlan(input: {
-        goal: string;
-        context?: string;
-        constraints?: string[];
-    }): Promise<GeneratedPlan>;
-    /**
-     * Validate and refine an existing plan
-     */
-    refinePlan(plan: Plan, feedback: string): Promise<GeneratedPlan>;
-    /**
-     * Build planning prompt from input
-     */
-    private buildPlanningPrompt;
-    /**
-     * Estimate plan complexity
-     */
-    private estimateComplexity;
-    /**
-     * Get current tasks (for tool access)
-     */
-    getCurrentTasks(): TaskInput[];
+declare function createFileRoutineDefinitionStorage(config?: FileRoutineDefinitionStorageConfig): FileRoutineDefinitionStorage;
+
+/**
+ * FileRoutineExecutionStorage - File-based storage for routine execution records.
+ *
+ * Stores executions as JSON files on disk with per-user isolation.
+ * Path: ~/.oneringai/users/<userId>/routine-executions/<executionId>.json
+ *
+ * Features:
+ * - Per-user isolation (multi-tenant safe)
+ * - Cross-platform path handling
+ * - Safe ID sanitization
+ * - Atomic file operations (write to .tmp then rename)
+ * - Per-user index file for fast listing/filtering
+ * - Index auto-rebuild if missing
+ * - Automatic pruning of old completed/failed records (maxRecords)
+ */
+
+/**
+ * Configuration for FileRoutineExecutionStorage
+ */
+interface FileRoutineExecutionStorageConfig {
+    /** Override the base directory (default: ~/.oneringai/users) */
+    baseDirectory?: string;
+    /** Pretty-print JSON (default: true) */
+    prettyPrint?: boolean;
+    /** Maximum number of execution records per user (default: 100). Oldest completed/failed are pruned on insert. */
+    maxRecords?: number;
+}
+/**
+ * File-based storage for routine execution records.
+ *
+ * Single instance handles all users. UserId is passed to each method.
+ */
+declare class FileRoutineExecutionStorage implements IRoutineExecutionStorage {
+    private readonly baseDirectory;
+    private readonly prettyPrint;
+    private readonly maxRecords;
+    constructor(config?: FileRoutineExecutionStorageConfig);
+    private getUserDirectory;
+    private getIndexPath;
+    private getExecutionPath;
+    private executionUserMap;
+    insert(userId: string | undefined, record: RoutineExecutionRecord): Promise<string>;
+    update(id: string, updates: Partial<Pick<RoutineExecutionRecord, 'status' | 'progress' | 'error' | 'completedAt' | 'lastActivityAt'>>): Promise<void>;
+    pushStep(id: string, step: RoutineExecutionStep): Promise<void>;
+    updateTask(id: string, taskName: string, updates: Partial<RoutineTaskSnapshot>): Promise<void>;
+    load(id: string): Promise<RoutineExecutionRecord | null>;
+    list(userId: string | undefined, options?: {
+        routineId?: string;
+        status?: RoutineExecutionStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<RoutineExecutionRecord[]>;
+    hasRunning(userId: string | undefined, routineId: string): Promise<boolean>;
+    getPath(userId: string | undefined): string;
+    private ensureDirectory;
+    private atomicWrite;
+    private readStoredExecution;
     /**
-     * Add task (called by planning tools)
+     * Load a record directly by userId + executionId (used by list()).
      */
-    addTask(task: TaskInput): void;
+    private loadByUserAndId;
     /**
-     * Update task (called by planning tools)
+     * Resolve the file path for an execution ID.
+     * Uses in-memory cache first, then falls back to scanning user directories.
      */
-    updateTask(name: string, updates: Partial<TaskInput>): void;
+    private resolveExecutionFile;
+    private loadIndex;
+    private saveIndex;
+    private updateIndex;
+    private recordToIndexEntry;
     /**
-     * Remove task (called by planning tools)
+     * Prune old completed/failed records if count exceeds maxRecords.
+     * Running/paused/pending records are never pruned.
      */
-    removeTask(name: string): void;
+    private pruneOldRecords;
     /**
-     * Mark planning as complete
+     * Rebuild index by scanning directory for .json files (excluding _index.json).
+     * Returns empty index if directory doesn't exist.
      */
-    finalizePlanning(): void;
+    private rebuildIndex;
 }
 /**
- * Simple plan generation without tools (fallback)
+ * Create a FileRoutineExecutionStorage with default configuration
  */
-declare function generateSimplePlan(goal: string, context?: string): Promise<Plan>;
+declare function createFileRoutineExecutionStorage(config?: FileRoutineExecutionStorageConfig): FileRoutineExecutionStorage;
 
 /**
- * ResearchAgent Types
+ * WorkingMemory class - manages indexed working memory for TaskAgent
  *
- * Generic interfaces for research sources that work with any data provider:
- * - Web search (Serper, Brave, Tavily)
- * - Vector databases (Pinecone, Weaviate, Qdrant)
- * - File systems (local, S3, GCS)
- * - APIs (REST, GraphQL)
- * - Databases (SQL, MongoDB)
- */
-/**
- * A single search result from any source
- */
-interface SourceResult {
-    /** Unique identifier for this result */
-    id: string;
-    /** Human-readable title */
-    title: string;
-    /** Brief description or snippet */
-    snippet: string;
-    /** Reference for fetching full content (URL, path, ID, etc.) */
-    reference: string;
-    /** Relevance score (0-1, higher is better) */
-    relevance?: number;
-    /** Source-specific metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Response from a search operation
+ * This is a GENERIC implementation that works across all agent types:
+ * - Basic Agent: Uses staticPriorityCalculator with simple scopes
+ * - TaskAgent: Uses taskAwarePriorityCalculator with task-aware scopes
+ * - UniversalAgent: Can switch calculators based on mode
+ *
+ * The PriorityCalculator strategy pattern allows different agents to have
+ * different eviction behaviors without changing the core WorkingMemory logic.
  */
-interface SearchResponse {
-    /** Whether the search succeeded */
-    success: boolean;
-    /** Original query */
-    query: string;
-    /** Results found */
-    results: SourceResult[];
-    /** Total results available (may be more than returned) */
-    totalResults?: number;
-    /** Error message if failed */
-    error?: string;
-    /** Source-specific metadata */
-    metadata?: Record<string, unknown>;
-}
+
 /**
- * Fetched content from a source
+ * Serialized memory state for persistence
  */
-interface FetchedContent {
-    /** Whether fetch succeeded */
-    success: boolean;
-    /** Reference that was fetched */
-    reference: string;
-    /** The actual content */
-    content: unknown;
-    /** Content type hint (text, html, json, binary, etc.) */
-    contentType?: string;
-    /** Size in bytes */
-    sizeBytes?: number;
-    /** Error message if failed */
-    error?: string;
-    /** Source-specific metadata */
-    metadata?: Record<string, unknown>;
+interface SerializedMemory {
+    /** Memory format version */
+    version: number;
+    /** Serialized memory entries */
+    entries: SerializedMemoryEntry[];
 }
 /**
- * Options for search operations
+ * Serialized memory entry
  */
-interface SearchOptions {
-    /** Maximum results to return */
-    maxResults?: number;
-    /** Minimum relevance score (0-1) */
-    minRelevance?: number;
-    /** Source-specific options */
-    sourceOptions?: Record<string, unknown>;
+interface SerializedMemoryEntry {
+    key: string;
+    description: string;
+    value: unknown;
+    scope: MemoryScope;
+    sizeBytes: number;
+    basePriority?: MemoryPriority;
+    pinned?: boolean;
 }
 /**
- * Options for fetch operations
+ * Eviction strategy type
  */
-interface FetchOptions {
-    /** Maximum content size to fetch (bytes) */
-    maxSize?: number;
-    /** Timeout in milliseconds */
-    timeoutMs?: number;
-    /** Source-specific options */
-    sourceOptions?: Record<string, unknown>;
+type EvictionStrategy = 'lru' | 'size';
+interface WorkingMemoryEvents {
+    stored: {
+        key: string;
+        description: string;
+        scope: MemoryScope;
+    };
+    retrieved: {
+        key: string;
+    };
+    deleted: {
+        key: string;
+    };
+    evicted: {
+        keys: string[];
+        reason: 'lru' | 'size' | 'task_completed';
+    };
+    limit_warning: {
+        utilizationPercent: number;
+    };
+    stale_entries: {
+        entries: StaleEntryInfo[];
+    };
 }
 /**
- * Generic research source interface
+ * WorkingMemory manages the agent's indexed working memory.
  *
- * Implement this interface to add any data source to ResearchAgent:
- * - Web: search queries, fetch URLs
- * - Vector DB: similarity search, fetch documents
- * - File system: glob patterns, read files
- * - API: query endpoints, fetch resources
+ * Features:
+ * - Store/retrieve with descriptions for index
+ * - Scoped memory (simple or task-aware)
+ * - Priority-based eviction (respects pinned, priority, then LRU)
+ * - Pluggable priority calculation via PriorityCalculator strategy
+ * - Task completion detection and stale entry notification
+ * - Event emission for monitoring
  */
-interface IResearchSource {
-    /** Unique name for this source */
-    readonly name: string;
-    /** Human-readable description */
-    readonly description: string;
-    /** Type of source (for categorization) */
-    readonly type: 'web' | 'vector' | 'file' | 'api' | 'database' | 'custom';
+declare class WorkingMemory extends EventEmitter<WorkingMemoryEvents> implements IDisposable {
+    private storage;
+    private config;
+    private priorityCalculator;
+    private priorityContext;
+    private _isDestroyed;
     /**
-     * Search this source for relevant results
+     * Create a WorkingMemory instance
      *
-     * @param query - Search query (interpreted by source)
-     * @param options - Search options
-     * @returns Search response with results
+     * @param storage - Storage backend for memory entries
+     * @param config - Memory configuration (limits, etc.)
+     * @param priorityCalculator - Strategy for computing effective priority (default: static)
      */
-    search(query: string, options?: SearchOptions): Promise<SearchResponse>;
+    constructor(storage: IMemoryStorage, config?: WorkingMemoryConfig, priorityCalculator?: PriorityCalculator);
     /**
-     * Fetch full content for a result
-     *
-     * @param reference - Reference from SourceResult
-     * @param options - Fetch options
-     * @returns Fetched content
+     * Set the priority calculator (for switching strategies at runtime)
      */
-    fetch(reference: string, options?: FetchOptions): Promise<FetchedContent>;
+    setPriorityCalculator(calculator: PriorityCalculator): void;
     /**
-     * Optional: Check if source is available/configured
+     * Update priority context (e.g., task states for TaskAgent)
      */
-    isAvailable?(): Promise<boolean>;
+    setPriorityContext(context: PriorityContext): void;
     /**
-     * Optional: Get source capabilities
+     * Get the current priority context
      */
-    getCapabilities?(): SourceCapabilities;
-}
-/**
- * Source capabilities for discovery
- */
-interface SourceCapabilities {
-    /** Whether source supports search */
-    canSearch: boolean;
-    /** Whether source supports fetch */
-    canFetch: boolean;
-    /** Whether results include relevance scores */
-    hasRelevanceScores: boolean;
-    /** Maximum results per search */
-    maxResultsPerSearch?: number;
-    /** Supported content types */
-    contentTypes?: string[];
-}
-/**
- * Research finding stored in memory
- */
-interface ResearchFinding {
-    /** Source that provided this finding */
-    source: string;
-    /** Original query that found this */
-    query: string;
-    /** Key insight or summary */
-    summary: string;
-    /** Supporting details */
-    details?: string;
-    /** References used */
-    references: string[];
-    /** Confidence level (0-1) */
-    confidence?: number;
-    /** When this was found */
-    timestamp: number;
-}
-/**
- * Research plan for systematic research
- */
-interface ResearchPlan {
-    /** Research goal/question */
-    goal: string;
-    /** Queries to execute */
-    queries: ResearchQuery[];
-    /** Sources to use (empty = all available) */
-    sources?: string[];
-    /** Maximum results per query */
-    maxResultsPerQuery?: number;
-    /** Maximum total findings */
-    maxTotalFindings?: number;
-}
-/**
- * A query in the research plan
- */
-interface ResearchQuery {
-    /** Query string */
-    query: string;
-    /** Specific sources for this query (empty = all) */
-    sources?: string[];
-    /** Priority (higher = more important) */
-    priority?: number;
-}
-/**
- * Research execution result
- */
-interface ResearchResult {
-    /** Whether research completed successfully */
-    success: boolean;
-    /** Original goal */
-    goal: string;
-    /** Queries executed */
-    queriesExecuted: number;
-    /** Results found */
-    resultsFound: number;
-    /** Results processed */
-    resultsProcessed: number;
-    /** Findings generated */
-    findingsCount: number;
-    /** Final synthesis (if generated) */
-    synthesis?: string;
-    /** Error if failed */
-    error?: string;
-    /** Execution metrics */
-    metrics?: {
-        totalDurationMs: number;
-        searchDurationMs: number;
-        processDurationMs: number;
-        synthesizeDurationMs: number;
-    };
-}
-/**
- * Research progress event
- */
-interface ResearchProgress {
-    phase: 'searching' | 'processing' | 'synthesizing' | 'complete';
-    currentQuery?: string;
-    currentSource?: string;
-    queriesCompleted: number;
-    totalQueries: number;
-    resultsProcessed: number;
-    totalResults: number;
-    findingsGenerated: number;
-}
-
-/**
- * Core types for context management system
- */
-/**
- * Context component that can be compacted
- */
-interface IContextComponent {
-    /** Unique name for this component */
-    name: string;
-    /** The actual content (string or structured data) */
-    content: string | unknown;
-    /** Priority for compaction (higher = compact first) */
-    priority: number;
-    /** Whether this component can be compacted */
-    compactable: boolean;
-    /** Additional metadata for compaction strategies */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Context budget information
- */
-interface ContextBudget {
-    /** Total available tokens */
-    total: number;
-    /** Reserved tokens for response */
-    reserved: number;
-    /** Currently used tokens */
-    used: number;
-    /** Available tokens remaining */
-    available: number;
-    /** Utilization percentage (used / (total - reserved)) */
-    utilizationPercent: number;
-    /** Budget status */
-    status: 'ok' | 'warning' | 'critical';
-    /** Token breakdown by component */
-    breakdown: Record<string, number>;
-}
-/**
- * Context manager configuration
- */
-interface ContextManagerConfig {
-    /** Maximum context tokens for the model */
-    maxContextTokens: number;
-    /** Threshold to trigger compaction (0.0 - 1.0) */
-    compactionThreshold: number;
-    /** Hard limit - must compact before this (0.0 - 1.0) */
-    hardLimit: number;
-    /** Reserve space for response (0.0 - 1.0) */
-    responseReserve: number;
-    /** Token estimator to use */
-    estimator: 'approximate' | 'tiktoken' | ITokenEstimator;
-    /** Enable automatic compaction */
-    autoCompact: boolean;
-    /** Strategy to use */
-    strategy?: 'proactive' | 'aggressive' | 'lazy' | 'rolling-window' | 'adaptive' | IContextStrategy;
-    /** Strategy-specific options */
-    strategyOptions?: Record<string, unknown>;
-}
-/**
- * Default configuration
- */
-declare const DEFAULT_CONTEXT_CONFIG: ContextManagerConfig;
-/**
- * Content type for more accurate token estimation
- * Named differently from TokenContentType in Content.ts to avoid conflicts
- */
-type TokenContentType = 'code' | 'prose' | 'mixed';
-/**
- * Abstract interface for token estimation
- */
-interface ITokenEstimator {
+    getPriorityContext(): PriorityContext;
     /**
-     * Estimate token count for text
+     * Compute effective priority for an entry using the current calculator
+     */
+    private computeEffectivePriority;
+    /**
+     * Get all entries with their computed effective priorities
+     * This is a performance optimization to avoid repeated getAll() + map() calls
+     */
+    private getEntriesWithPriority;
+    /**
+     * Get evictable entries sorted by eviction priority
+     * Filters out pinned and critical entries, sorts by priority then by strategy
+     */
+    private getEvictableEntries;
+    /**
+     * Store a value in working memory
      *
-     * @param text - The text to estimate
-     * @param contentType - Type of content for more accurate estimation:
-     *   - 'code': Code is typically denser (~3 chars/token)
-     *   - 'prose': Natural language text (~4 chars/token)
-     *   - 'mixed': Mix of code and prose (~3.5 chars/token)
+     * @param key - Unique key for the entry
+     * @param description - Short description for the index (max 150 chars)
+     * @param value - The data to store
+     * @param options - Optional scope, priority, and pinned settings
      */
-    estimateTokens(text: string, contentType?: TokenContentType): number;
+    store(key: string, description: string, value: unknown, options?: {
+        scope?: MemoryScope;
+        priority?: MemoryPriority;
+        pinned?: boolean;
+    }): Promise<void>;
     /**
-     * Estimate tokens for structured data
+     * Enforce the maxIndexEntries limit by evicting excess entries
+     * Only evicts if entry count exceeds the configured limit
      */
-    estimateDataTokens(data: unknown, contentType?: TokenContentType): number;
+    private enforceEntryCountLimit;
     /**
-     * Estimate tokens for an image.
-     * @param width - Image width in pixels (if known)
-     * @param height - Image height in pixels (if known)
-     * @param detail - Image detail level: 'low', 'high', or 'auto'
+     * Get the configured max index entries limit
      */
-    estimateImageTokens?(width?: number, height?: number, detail?: string): number;
-}
-/**
- * Abstract interface for compaction strategies
- */
-interface IContextCompactor {
-    /** Compactor name */
-    readonly name: string;
-    /** Priority order (lower = run first) */
-    readonly priority: number;
+    getMaxIndexEntries(): number | undefined;
     /**
-     * Check if this compactor can handle the component
+     * Store a value scoped to specific tasks
+     * Convenience method for task-aware memory
+     */
+    storeForTasks(key: string, description: string, value: unknown, taskIds: string[], options?: {
+        priority?: MemoryPriority;
+        pinned?: boolean;
+    }): Promise<void>;
+    /**
+     * Store a value scoped to the entire plan
+     * Convenience method for plan-scoped memory
+     */
+    storeForPlan(key: string, description: string, value: unknown, options?: {
+        priority?: MemoryPriority;
+        pinned?: boolean;
+    }): Promise<void>;
+    /**
+     * Retrieve a value from working memory
+     *
+     * Note: Access stats update is not strictly atomic. Under very high concurrency,
+     * accessCount may be slightly inaccurate. This is acceptable for memory management
+     * purposes where exact counts are not critical.
+     */
+    retrieve(key: string): Promise<unknown>;
+    /**
+     * Retrieve multiple values
+     */
+    retrieveMany(keys: string[]): Promise<Record<string, unknown>>;
+    /**
+     * Delete a value from working memory
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Check if key exists
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Promote an entry to persistent scope
+     * Works with both simple and task-aware scopes
+     */
+    persist(key: string): Promise<void>;
+    /**
+     * Pin an entry (never evicted)
+     */
+    pin(key: string): Promise<void>;
+    /**
+     * Unpin an entry
+     */
+    unpin(key: string, newPriority?: MemoryPriority): Promise<void>;
+    /**
+     * Set the base priority of an entry
+     */
+    setPriority(key: string, priority: MemoryPriority): Promise<void>;
+    /**
+     * Update the scope of an entry without re-storing the value
+     */
+    updateScope(key: string, scope: MemoryScope): Promise<void>;
+    /**
+     * Add task IDs to an existing task-scoped entry
+     * If entry is not task-scoped, converts it to task-scoped
+     */
+    addTasksToScope(key: string, taskIds: string[]): Promise<void>;
+    /**
+     * Clear all entries of a specific scope
+     */
+    clearScope(scope: MemoryScope): Promise<void>;
+    /**
+     * Clear all entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get memory index with computed effective priorities
+     * Respects maxIndexEntries limit for context display
+     */
+    getIndex(): Promise<MemoryIndex>;
+    /**
+     * Format index for context injection
+     */
+    formatIndex(): Promise<string>;
+    /**
+     * Evict entries using specified strategy
+     *
+     * Eviction order:
+     * 1. Never evict pinned entries
+     * 2. Evict low priority first, then normal, then high (never critical)
+     * 3. Within same priority, use strategy (LRU or largest size)
+     *
+     * @param count - Number of entries to evict
+     * @param strategy - Eviction strategy ('lru' or 'size')
+     * @returns Keys of evicted entries
+     */
+    evict(count: number, strategy?: EvictionStrategy): Promise<string[]>;
+    /**
+     * Evict entries using priority-aware LRU algorithm
+     * @deprecated Use evict(count, 'lru') instead
+     */
+    evictLRU(count: number): Promise<string[]>;
+    /**
+     * Evict largest entries first (priority-aware)
+     * @deprecated Use evict(count, 'size') instead
+     */
+    evictBySize(count: number): Promise<string[]>;
+    /**
+     * Handle task completion - detect and notify about stale entries
+     *
+     * Call this when a task completes to:
+     * 1. Update priority context with new task state
+     * 2. Detect entries that became stale
+     * 3. Emit event to notify LLM about stale entries
+     *
+     * @param taskId - The completed task ID
+     * @param taskStates - Current task states map
+     * @returns Information about stale entries
+     */
+    onTaskComplete(taskId: string, taskStates: Map<string, TaskStatusForMemory>): Promise<StaleEntryInfo[]>;
+    /**
+     * Evict entries for completed tasks
+     *
+     * Removes entries that were scoped only to completed tasks.
+     * Use after onTaskComplete() if you want automatic cleanup.
+     *
+     * @param taskStates - Current task states map
+     * @returns Keys of evicted entries
+     */
+    evictCompletedTaskEntries(taskStates: Map<string, TaskStatusForMemory>): Promise<string[]>;
+    /**
+     * Get limited memory access for tools
+     *
+     * This provides a simplified interface for tools to interact with memory
+     * without exposing the full WorkingMemory API.
+     */
+    getAccess(): WorkingMemoryAccess;
+    /**
+     * Store raw data (low priority, first to be evicted)
+     *
+     * Use this for original/unprocessed data that should be summarized.
+     * Raw data is automatically evicted first when memory pressure is high.
+     *
+     * @param key - Key without tier prefix (prefix is added automatically)
+     * @param description - Brief description for the index
+     * @param value - The raw data to store
+     * @param options - Optional scope and task IDs
+     */
+    storeRaw(key: string, description: string, value: unknown, options?: {
+        taskIds?: string[];
+        scope?: MemoryScope;
+    }): Promise<void>;
+    /**
+     * Store a summary derived from raw data (normal priority)
+     *
+     * Use this for processed/summarized data that extracts key information.
+     * Links back to source data for cleanup tracking.
+     *
+     * @param key - Key without tier prefix (prefix is added automatically)
+     * @param description - Brief description for the index
+     * @param value - The summary data
+     * @param derivedFrom - Key(s) this summary was derived from
+     * @param options - Optional scope and task IDs
+     */
+    storeSummary(key: string, description: string, value: unknown, derivedFrom: string | string[], options?: {
+        taskIds?: string[];
+        scope?: MemoryScope;
+    }): Promise<void>;
+    /**
+     * Store final findings (high priority, kept longest)
+     *
+     * Use this for conclusions, insights, or final results that should be preserved.
+     * These are the last to be evicted and typically span the entire plan.
+     *
+     * @param key - Key without tier prefix (prefix is added automatically)
+     * @param description - Brief description for the index
+     * @param value - The findings data
+     * @param derivedFrom - Optional key(s) these findings were derived from
+     * @param options - Optional scope, task IDs, and pinned flag
+     */
+    storeFindings(key: string, description: string, value: unknown, _derivedFrom?: string | string[], options?: {
+        taskIds?: string[];
+        scope?: MemoryScope;
+        pinned?: boolean;
+    }): Promise<void>;
+    /**
+     * Clean up raw data after summary/findings are created
+     *
+     * Call this after creating summaries to free up memory used by raw data.
+     * Only deletes entries in the 'raw' tier.
+     *
+     * @param derivedFromKeys - Keys to delete (typically from derivedFrom metadata)
+     * @returns Number of entries deleted
+     */
+    cleanupRawData(derivedFromKeys: string[]): Promise<number>;
+    /**
+     * Get all entries by tier
+     *
+     * @param tier - The tier to filter by
+     * @returns Array of entries in that tier
+     */
+    getByTier(tier: MemoryTier): Promise<MemoryEntry[]>;
+    /**
+     * Promote an entry to a higher tier
+     *
+     * Changes the key prefix and updates priority.
+     * Use this when raw data becomes more valuable (e.g., frequently accessed).
+     *
+     * @param key - Current key (with tier prefix)
+     * @param toTier - Target tier to promote to
+     * @returns New key with updated prefix
      */
-    canCompact(component: IContextComponent): boolean;
+    promote(key: string, toTier: MemoryTier): Promise<string>;
     /**
-     * Compact the component to target size
+     * Get tier statistics
+     *
+     * @returns Count and size by tier
      */
-    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
+    getTierStats(): Promise<Record<MemoryTier, {
+        count: number;
+        sizeBytes: number;
+    }>>;
     /**
-     * Estimate savings from compaction
+     * Get statistics about memory usage
      */
-    estimateSavings(component: IContextComponent): number;
-}
-/**
- * Context management strategy - defines the overall approach to managing context
- */
-interface IContextStrategy {
-    /** Strategy name */
-    readonly name: string;
+    getStats(): Promise<{
+        totalEntries: number;
+        totalSizeBytes: number;
+        utilizationPercent: number;
+        byPriority: Record<MemoryPriority, number>;
+        pinnedCount: number;
+    }>;
     /**
-     * Decide if compaction is needed based on current budget
+     * Get the configured memory limit
      */
-    shouldCompact(budget: ContextBudget, config: ContextManagerConfig): boolean;
+    getLimit(): number;
     /**
-     * Execute compaction using available compactors
+     * Check if the WorkingMemory instance has been destroyed
      */
-    compact(components: IContextComponent[], budget: ContextBudget, compactors: IContextCompactor[], estimator: ITokenEstimator): Promise<{
-        components: IContextComponent[];
-        log: string[];
-        tokensFreed: number;
-    }>;
+    get isDestroyed(): boolean;
     /**
-     * Optional: Prepare components before budget calculation
-     * Use this for strategies that pre-process context (e.g., rolling window)
+     * Destroy the WorkingMemory instance
+     * Removes all event listeners and clears internal state
      */
-    prepareComponents?(components: IContextComponent[]): Promise<IContextComponent[]>;
+    destroy(): void;
     /**
-     * Optional: Post-process after compaction
-     * Use this for strategies that need cleanup or optimization
+     * Serialize all memory entries for persistence
+     *
+     * Returns a serializable representation of all memory entries
+     * that can be saved to storage and restored later.
+     *
+     * @returns Serialized memory state
      */
-    postProcess?(components: IContextComponent[], budget: ContextBudget): Promise<IContextComponent[]>;
+    serialize(): Promise<SerializedMemory>;
     /**
-     * Optional: Get strategy-specific metrics
+     * Restore memory entries from serialized state
+     *
+     * Clears existing memory and repopulates from the serialized state.
+     * Timestamps are reset to current time.
+     *
+     * @param state - Previously serialized memory state
      */
-    getMetrics?(): Record<string, unknown>;
-}
-
-/**
- * Truncate Compactor
- *
- * Truncates content to target size by:
- * - For strings: Cut to character limit
- * - For arrays: Keep most recent items
- */
-
-declare class TruncateCompactor implements IContextCompactor {
-    private estimator;
-    readonly name = "truncate";
-    readonly priority = 10;
-    constructor(estimator: ITokenEstimator);
-    canCompact(component: IContextComponent): boolean;
-    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
-    estimateSavings(component: IContextComponent): number;
-    private truncateString;
-    private truncateArray;
+    restore(state: SerializedMemory): Promise<void>;
 }
 
 /**
- * Summarize Compactor
- *
- * Uses LLM to create intelligent summaries of context components before compaction.
- * This preserves the semantic meaning of content while reducing token count.
- *
- * Supports different summarization strategies based on content type:
- * - Conversation history: Preserves decisions, facts, and preferences
- * - Tool outputs (search/scrape): Preserves key findings, sources, and data
+ * ExternalDependencyHandler - handles external dependencies
  */
 
-/**
- * Configuration for the SummarizeCompactor
- */
-interface SummarizeCompactorConfig {
-    /** Text provider for LLM-based summarization */
-    textProvider: ITextProvider;
-    /** Model to use for summarization (optional - uses provider default) */
-    model?: string;
-    /** Maximum tokens for the summary (default: 500) */
-    maxSummaryTokens?: number;
-    /** Preserve markdown structure like headings and lists (default: true) */
-    preserveStructure?: boolean;
-    /** Fall back to truncation if LLM summarization fails (default: true) */
-    fallbackToTruncate?: boolean;
-    /** Temperature for summarization (default: 0.3 for deterministic output) */
-    temperature?: number;
+interface ExternalDependencyEvents {
+    'webhook:received': {
+        webhookId: string;
+        data: unknown;
+    };
+    'poll:success': {
+        taskId: string;
+        data: unknown;
+    };
+    'poll:timeout': {
+        taskId: string;
+    };
+    'scheduled:triggered': {
+        taskId: string;
+    };
+    'manual:completed': {
+        taskId: string;
+        data: unknown;
+    };
 }
 /**
- * SummarizeCompactor - LLM-based context compaction
- *
- * Uses AI to intelligently summarize content, preserving semantic meaning
- * while significantly reducing token count.
+ * Handles external task dependencies
  */
-declare class SummarizeCompactor implements IContextCompactor {
-    readonly name = "summarize";
-    readonly priority = 5;
-    private config;
-    private estimator;
-    constructor(estimator: ITokenEstimator, config: SummarizeCompactorConfig);
+declare class ExternalDependencyHandler extends EventEmitter<ExternalDependencyEvents> {
+    private activePolls;
+    private activeScheduled;
+    private cancelledPolls;
+    private tools;
+    constructor(tools?: ToolFunction[]);
     /**
-     * Check if this compactor can handle the component
+     * Start handling a task's external dependency
      */
-    canCompact(component: IContextComponent): boolean;
+    startWaiting(task: Task): Promise<void>;
     /**
-     * Compact the component by summarizing its content
+     * Stop waiting on a task's external dependency
      */
-    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
+    stopWaiting(task: Task): void;
     /**
-     * Estimate how many tokens could be saved by summarization
+     * Trigger a webhook
      */
-    estimateSavings(component: IContextComponent): number;
+    triggerWebhook(webhookId: string, data: unknown): Promise<void>;
     /**
-     * Perform LLM-based summarization
+     * Complete a manual task
      */
-    private summarize;
+    completeManual(taskId: string, data: unknown): Promise<void>;
     /**
-     * Fallback to simple truncation when LLM fails
+     * Start polling for a task with exponential backoff
      */
-    private truncateFallback;
+    private startPolling;
     /**
-     * Detect content type from component metadata or name
+     * Schedule a task to trigger at a specific time
      */
-    private detectContentType;
+    private scheduleTask;
     /**
-     * Convert content to string for processing
+     * Cleanup all active dependencies
      */
-    private stringifyContent;
+    cleanup(): void;
+    /**
+     * Update available tools
+     */
+    updateTools(tools: ToolFunction[]): void;
 }
 
 /**
- * Memory Eviction Compactor
- *
- * Evicts LRU entries from memory index
- * Works with memory components that have eviction metadata
+ * CheckpointManager - manages agent state checkpointing
  */
 
-declare class MemoryEvictionCompactor implements IContextCompactor {
-    private estimator;
-    readonly name = "memory-eviction";
-    readonly priority = 8;
-    constructor(estimator: ITokenEstimator);
-    canCompact(component: IContextComponent): boolean;
-    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
-    estimateSavings(component: IContextComponent): number;
+interface CheckpointStrategy {
+    /** Checkpoint after every N tool calls */
+    afterToolCalls?: number;
+    /** Checkpoint after every N LLM calls */
+    afterLLMCalls?: number;
+    /** Checkpoint on time interval */
+    intervalMs?: number;
+    /** Always checkpoint before external wait */
+    beforeExternalWait: boolean;
+    /** Checkpoint mode */
+    mode: 'sync' | 'async';
 }
-
+declare const DEFAULT_CHECKPOINT_STRATEGY: CheckpointStrategy;
 /**
- * Approximate Token Estimator
- *
- * Uses content-type aware heuristics:
- * - Code: ~3 chars/token (more symbols, shorter words)
- * - Prose: ~4 chars/token (natural language)
- * - Mixed: ~3.5 chars/token
- *
- * Fast and good enough for most use cases.
+ * Manages state checkpointing for persistence and recovery
  */
-
-declare class ApproximateTokenEstimator implements ITokenEstimator {
+declare class CheckpointManager {
+    private storage;
+    private strategy;
+    private toolCallsSinceCheckpoint;
+    private llmCallsSinceCheckpoint;
+    private intervalTimer?;
+    private pendingCheckpoints;
+    private currentState;
+    constructor(storage: IAgentStorage, strategy?: CheckpointStrategy);
     /**
-     * Estimate tokens for text with content-type awareness
-     *
-     * @param text - The text to estimate tokens for
-     * @param contentType - Type of content:
-     *   - 'code': Code is typically denser (~3 chars/token)
-     *   - 'prose': Natural language text (~4 chars/token)
-     *   - 'mixed': Mix of code and prose (~3.5 chars/token)
+     * Set the current agent state (for interval checkpointing)
      */
-    estimateTokens(text: string, contentType?: TokenContentType): number;
+    setCurrentState(state: AgentState): void;
+    /**
+     * Record a tool call (may trigger checkpoint)
+     */
+    onToolCall(state: AgentState): Promise<void>;
+    /**
+     * Record an LLM call (may trigger checkpoint)
+     */
+    onLLMCall(state: AgentState): Promise<void>;
+    /**
+     * Force a checkpoint
+     */
+    checkpoint(state: AgentState, reason: string): Promise<void>;
+    /**
+     * Perform the actual checkpoint
+     */
+    private doCheckpoint;
+    /**
+     * Check if interval-based checkpoint is needed
+     */
+    private checkIntervalCheckpoint;
     /**
-     * Estimate tokens for structured data (always uses 'mixed' estimation)
+     * Wait for all pending checkpoints to complete
      */
-    estimateDataTokens(data: unknown, contentType?: TokenContentType): number;
+    flush(): Promise<void>;
     /**
-     * Estimate tokens for an image using tile-based model (matches OpenAI pricing).
-     *
-     * - detail='low': 85 tokens
-     * - detail='high' with known dimensions: 85 + 170 per 512×512 tile
-     * - Unknown dimensions: 1000 tokens (conservative default)
+     * Cleanup resources
      */
-    estimateImageTokens(width?: number, height?: number, detail?: string): number;
+    cleanup(): Promise<void>;
 }
 
 /**
- * Token estimators
- */
-
-/**
- * Create token estimator from name
- */
-declare function createEstimator(name: string): ITokenEstimator;
-
-/**
- * IHistoryManager - Interface for conversation history management
+ * PlanningAgent - AI-driven plan generation
  *
- * Follows the same pattern as IMemoryStorage for pluggable implementations.
- * Users can implement this interface to use Redis, PostgreSQL, file storage, etc.
+ * Separates planning phase from execution phase.
+ * Analyzes goals and generates task graphs with dependencies.
  */
 
 /**
- * A single message in conversation history
- */
-interface HistoryMessage {
-    id: string;
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Events emitted by IHistoryManager implementations
- */
-interface HistoryManagerEvents {
-    'message:added': {
-        message: HistoryMessage;
-    };
-    'message:removed': {
-        messageId: string;
-    };
-    'history:cleared': {
-        reason?: string;
-    };
-    'history:compacted': {
-        removedCount: number;
-        strategy: string;
-    };
-    'history:restored': {
-        messageCount: number;
-    };
-}
-/**
- * Configuration for history management
+ * PlanningAgent configuration
  */
-interface IHistoryManagerConfig {
-    /** Maximum messages to keep (for sliding window) */
-    maxMessages?: number;
-    /** Maximum tokens to keep (estimated) */
-    maxTokens?: number;
-    /** Compaction strategy when limits are reached */
-    compactionStrategy?: 'truncate' | 'summarize' | 'sliding-window';
-    /** Number of recent messages to always preserve */
-    preserveRecentCount?: number;
+interface PlanningAgentConfig {
+    /** Connector for LLM access */
+    connector: string | Connector;
+    /** Model to use for planning (can be different/cheaper than execution) */
+    model: string;
+    /** Max planning iterations */
+    maxPlanningIterations?: number;
+    /** Temperature for planning (lower = more deterministic) */
+    planningTemperature?: number;
+    /** Tools available for the plan (used to inform planning) */
+    availableTools?: ToolFunction[];
 }
 /**
- * Serialized history state for persistence
+ * Generated plan with metadata
  */
-interface SerializedHistoryState {
-    version: number;
-    messages: HistoryMessage[];
-    summaries?: Array<{
-        content: string;
-        coversCount: number;
-        timestamp: number;
-    }>;
-    metadata?: Record<string, unknown>;
+interface GeneratedPlan {
+    plan: Plan;
+    reasoning: string;
+    estimated_duration?: string;
+    complexity?: 'low' | 'medium' | 'high';
 }
 /**
- * Interface for history storage backends
- * Implement this to use custom storage (Redis, PostgreSQL, file, etc.)
+ * PlanningAgent class
  */
-interface IHistoryStorage {
-    /**
-     * Store a message
-     */
-    addMessage(message: HistoryMessage): Promise<void>;
-    /**
-     * Get all messages
-     */
-    getMessages(): Promise<HistoryMessage[]>;
-    /**
-     * Get recent N messages
-     */
-    getRecentMessages(count: number): Promise<HistoryMessage[]>;
-    /**
-     * Remove a message by ID
-     */
-    removeMessage(id: string): Promise<void>;
+declare class PlanningAgent {
+    private agent;
+    private config;
+    private currentTasks;
+    private planningComplete;
+    private constructor();
     /**
-     * Remove messages older than timestamp
+     * Create a new PlanningAgent
      */
-    removeOlderThan(timestamp: number): Promise<number>;
+    static create(config: PlanningAgentConfig): PlanningAgent;
     /**
-     * Clear all messages
+     * Create planning tools bound to this PlanningAgent instance
      */
-    clear(): Promise<void>;
+    private createBoundPlanningTools;
     /**
-     * Get message count
+     * Generate a plan from a goal
      */
-    getCount(): Promise<number>;
+    generatePlan(input: {
+        goal: string;
+        context?: string;
+        constraints?: string[];
+    }): Promise<GeneratedPlan>;
     /**
-     * Get serialized state for session persistence
+     * Validate and refine an existing plan
      */
-    getState(): Promise<SerializedHistoryState>;
+    refinePlan(plan: Plan, feedback: string): Promise<GeneratedPlan>;
     /**
-     * Restore from serialized state
+     * Build planning prompt from input
      */
-    restoreState(state: SerializedHistoryState): Promise<void>;
-}
-/**
- * Interface for history manager
- * Manages conversation history with compaction and persistence support
- */
-interface IHistoryManager extends EventEmitter<HistoryManagerEvents> {
+    private buildPlanningPrompt;
     /**
-     * Add a message to history
+     * Estimate plan complexity
      */
-    addMessage(role: 'user' | 'assistant' | 'system', content: string, metadata?: Record<string, unknown>): Promise<HistoryMessage>;
+    private estimateComplexity;
     /**
-     * Get all messages (may include summaries as system messages)
+     * Get current tasks (for tool access)
      */
-    getMessages(): Promise<HistoryMessage[]>;
+    getCurrentTasks(): TaskInput[];
     /**
-     * Get recent messages only
+     * Add task (called by planning tools)
      */
-    getRecentMessages(count?: number): Promise<HistoryMessage[]>;
+    addTask(task: TaskInput): void;
     /**
-     * Get formatted history for LLM context
+     * Update task (called by planning tools)
      */
-    formatForContext(options?: {
-        maxTokens?: number;
-        includeMetadata?: boolean;
-    }): Promise<string>;
+    updateTask(name: string, updates: Partial<TaskInput>): void;
     /**
-     * Compact history (apply compaction strategy)
+     * Remove task (called by planning tools)
      */
-    compact(): Promise<void>;
+    removeTask(name: string): void;
     /**
-     * Clear all history
+     * Mark planning as complete
      */
-    clear(): Promise<void>;
+    finalizePlanning(): void;
+}
+/**
+ * Simple plan generation without tools (fallback)
+ */
+declare function generateSimplePlan(goal: string, context?: string): Promise<Plan>;
+
+/**
+ * ResearchAgent Types
+ *
+ * Generic interfaces for research sources that work with any data provider:
+ * - Web search (Serper, Brave, Tavily)
+ * - Vector databases (Pinecone, Weaviate, Qdrant)
+ * - File systems (local, S3, GCS)
+ * - APIs (REST, GraphQL)
+ * - Databases (SQL, MongoDB)
+ */
+/**
+ * A single search result from any source
+ */
+interface SourceResult {
+    /** Unique identifier for this result */
+    id: string;
+    /** Human-readable title */
+    title: string;
+    /** Brief description or snippet */
+    snippet: string;
+    /** Reference for fetching full content (URL, path, ID, etc.) */
+    reference: string;
+    /** Relevance score (0-1, higher is better) */
+    relevance?: number;
+    /** Source-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Response from a search operation
+ */
+interface SearchResponse {
+    /** Whether the search succeeded */
+    success: boolean;
+    /** Original query */
+    query: string;
+    /** Results found */
+    results: SourceResult[];
+    /** Total results available (may be more than returned) */
+    totalResults?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Source-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Fetched content from a source
+ */
+interface FetchedContent {
+    /** Whether fetch succeeded */
+    success: boolean;
+    /** Reference that was fetched */
+    reference: string;
+    /** The actual content */
+    content: unknown;
+    /** Content type hint (text, html, json, binary, etc.) */
+    contentType?: string;
+    /** Size in bytes */
+    sizeBytes?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Source-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for search operations
+ */
+interface SearchOptions {
+    /** Maximum results to return */
+    maxResults?: number;
+    /** Minimum relevance score (0-1) */
+    minRelevance?: number;
+    /** Source-specific options */
+    sourceOptions?: Record<string, unknown>;
+}
+/**
+ * Options for fetch operations
+ */
+interface FetchOptions {
+    /** Maximum content size to fetch (bytes) */
+    maxSize?: number;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+    /** Source-specific options */
+    sourceOptions?: Record<string, unknown>;
+}
+/**
+ * Generic research source interface
+ *
+ * Implement this interface to add any data source to ResearchAgent:
+ * - Web: search queries, fetch URLs
+ * - Vector DB: similarity search, fetch documents
+ * - File system: glob patterns, read files
+ * - API: query endpoints, fetch resources
+ */
+interface IResearchSource {
+    /** Unique name for this source */
+    readonly name: string;
+    /** Human-readable description */
+    readonly description: string;
+    /** Type of source (for categorization) */
+    readonly type: 'web' | 'vector' | 'file' | 'api' | 'database' | 'custom';
     /**
-     * Get message count
+     * Search this source for relevant results
+     *
+     * @param query - Search query (interpreted by source)
+     * @param options - Search options
+     * @returns Search response with results
      */
-    getMessageCount(): Promise<number>;
+    search(query: string, options?: SearchOptions): Promise<SearchResponse>;
     /**
-     * Get state for session persistence
+     * Fetch full content for a result
+     *
+     * @param reference - Reference from SourceResult
+     * @param options - Fetch options
+     * @returns Fetched content
      */
-    getState(): Promise<SerializedHistoryState>;
+    fetch(reference: string, options?: FetchOptions): Promise<FetchedContent>;
     /**
-     * Restore from saved state
+     * Optional: Check if source is available/configured
      */
-    restoreState(state: SerializedHistoryState): Promise<void>;
+    isAvailable?(): Promise<boolean>;
     /**
-     * Get current configuration
+     * Optional: Get source capabilities
      */
-    getConfig(): IHistoryManagerConfig;
+    getCapabilities?(): SourceCapabilities;
 }
 /**
- * Default configuration
+ * Source capabilities for discovery
  */
-declare const DEFAULT_HISTORY_MANAGER_CONFIG: Required<IHistoryManagerConfig>;
-
+interface SourceCapabilities {
+    /** Whether source supports search */
+    canSearch: boolean;
+    /** Whether source supports fetch */
+    canFetch: boolean;
+    /** Whether results include relevance scores */
+    hasRelevanceScores: boolean;
+    /** Maximum results per search */
+    maxResultsPerSearch?: number;
+    /** Supported content types */
+    contentTypes?: string[];
+}
 /**
- * InMemoryHistoryStorage - In-memory implementation of IHistoryStorage
- *
- * Default storage backend for conversation history.
- * For production, users can implement IHistoryStorage with Redis, PostgreSQL, etc.
+ * Research finding stored in memory
  */
-
+interface ResearchFinding {
+    /** Source that provided this finding */
+    source: string;
+    /** Original query that found this */
+    query: string;
+    /** Key insight or summary */
+    summary: string;
+    /** Supporting details */
+    details?: string;
+    /** References used */
+    references: string[];
+    /** Confidence level (0-1) */
+    confidence?: number;
+    /** When this was found */
+    timestamp: number;
+}
 /**
- * In-memory history storage implementation
+ * Research plan for systematic research
  */
-declare class InMemoryHistoryStorage implements IHistoryStorage {
-    private messages;
-    private summaries;
-    addMessage(message: HistoryMessage): Promise<void>;
-    getMessages(): Promise<HistoryMessage[]>;
-    getRecentMessages(count: number): Promise<HistoryMessage[]>;
-    removeMessage(id: string): Promise<void>;
-    removeOlderThan(timestamp: number): Promise<number>;
-    clear(): Promise<void>;
-    getCount(): Promise<number>;
-    getState(): Promise<SerializedHistoryState>;
-    restoreState(state: SerializedHistoryState): Promise<void>;
+interface ResearchPlan {
+    /** Research goal/question */
+    goal: string;
+    /** Queries to execute */
+    queries: ResearchQuery[];
+    /** Sources to use (empty = all available) */
+    sources?: string[];
+    /** Maximum results per query */
+    maxResultsPerQuery?: number;
+    /** Maximum total findings */
+    maxTotalFindings?: number;
 }
-
 /**
- * Routine Control Flow — map, fold, until handlers + template resolution
- *
- * Control flow tasks delegate to executeRoutine() recursively with the shared agent,
- * using ICM keys (__map_item, __map_index, etc.) to pass iteration state.
+ * A query in the research plan
  */
-
-/** Well-known ICM/WM keys used by the routine execution framework. */
-declare const ROUTINE_KEYS: {
-    /** Plan overview with task statuses (ICM) */
-    readonly PLAN: "__routine_plan";
-    /** Dependency results location guide (ICM) */
-    readonly DEPS: "__routine_deps";
-    /** Prefix for per-dependency result keys (ICM/WM) */
-    readonly DEP_RESULT_PREFIX: "__dep_result_";
-    /** Current map/fold item (ICM) */
-    readonly MAP_ITEM: "__map_item";
-    /** Current map/fold index, 0-based (ICM) */
-    readonly MAP_INDEX: "__map_index";
-    /** Total items in map/fold (ICM) */
-    readonly MAP_TOTAL: "__map_total";
-    /** Running fold accumulator (ICM) */
-    readonly FOLD_ACCUMULATOR: "__fold_accumulator";
-    /** Prefix for large dep results stored in WM findings tier */
-    readonly WM_DEP_FINDINGS_PREFIX: "findings/__dep_result_";
-    /** Prefix for auto-stored task outputs (set by output contracts) */
-    readonly TASK_OUTPUT_PREFIX: "__task_output_";
-};
-interface ControlFlowResult {
-    completed: boolean;
-    result?: unknown;
-    error?: string;
+interface ResearchQuery {
+    /** Query string */
+    query: string;
+    /** Specific sources for this query (empty = all) */
+    sources?: string[];
+    /** Priority (higher = more important) */
+    priority?: number;
 }
 /**
- * Resolve template placeholders in text.
- *
- * Supported namespaces:
- * - {{param.name}} → inputs[name]
- * - {{map.item}} / {{map.index}} / {{map.total}} → ICM keys
- * - {{fold.accumulator}} → ICM key
- *
- * Non-string values are JSON.stringify'd. Unresolved templates are left as-is.
+ * Research execution result
  */
-declare function resolveTemplates(text: string, inputs: Record<string, unknown>, icmPlugin: InContextMemoryPluginNextGen | null): string;
+interface ResearchResult {
+    /** Whether research completed successfully */
+    success: boolean;
+    /** Original goal */
+    goal: string;
+    /** Queries executed */
+    queriesExecuted: number;
+    /** Results found */
+    resultsFound: number;
+    /** Results processed */
+    resultsProcessed: number;
+    /** Findings generated */
+    findingsCount: number;
+    /** Final synthesis (if generated) */
+    synthesis?: string;
+    /** Error if failed */
+    error?: string;
+    /** Execution metrics */
+    metrics?: {
+        totalDurationMs: number;
+        searchDurationMs: number;
+        processDurationMs: number;
+        synthesizeDurationMs: number;
+    };
+}
 /**
- * Resolve the source array for a map/fold control flow using layered resolution:
- * 1. Determine lookup key(s) from source config
- * 2. Read from ICM/WM with fallback chain
- * 3. Apply JSON path extraction if specified
- * 4. Coerce to array algorithmically (JSON parse, common field names)
- * 5. LLM extraction fallback if still not an array
+ * Research progress event
  */
-declare function resolveFlowSource(flow: {
-    source: ControlFlowSource;
-    maxIterations?: number;
-}, flowType: string, agent: Agent, execution: RoutineExecution | undefined, icmPlugin: InContextMemoryPluginNextGen | null, wmPlugin: WorkingMemoryPluginNextGen | null): Promise<{
-    array: unknown[];
-    maxIter: number;
-} | ControlFlowResult>;
+interface ResearchProgress {
+    phase: 'searching' | 'processing' | 'synthesizing' | 'complete';
+    currentQuery?: string;
+    currentSource?: string;
+    queriesCompleted: number;
+    totalQueries: number;
+    resultsProcessed: number;
+    totalResults: number;
+    findingsGenerated: number;
+}
 
 /**
- * FilePersistentInstructionsStorage - File-based storage for persistent instructions
- *
- * Stores custom agent instructions as a JSON file on disk.
- * Path: ~/.oneringai/agents/<agentId>/custom_instructions.json
- * Windows: %APPDATA%/oneringai/agents/<agentId>/custom_instructions.json
- *
- * Features:
- * - Cross-platform path handling
- * - Safe agent ID sanitization
- * - Atomic file operations
- * - Automatic directory creation
- * - Legacy .md file migration
+ * Core types for context management system
+ */
+/**
+ * Context component that can be compacted
+ */
+interface IContextComponent {
+    /** Unique name for this component */
+    name: string;
+    /** The actual content (string or structured data) */
+    content: string | unknown;
+    /** Priority for compaction (higher = compact first) */
+    priority: number;
+    /** Whether this component can be compacted */
+    compactable: boolean;
+    /** Additional metadata for compaction strategies */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Context budget information
+ */
+interface ContextBudget {
+    /** Total available tokens */
+    total: number;
+    /** Reserved tokens for response */
+    reserved: number;
+    /** Currently used tokens */
+    used: number;
+    /** Available tokens remaining */
+    available: number;
+    /** Utilization percentage (used / (total - reserved)) */
+    utilizationPercent: number;
+    /** Budget status */
+    status: 'ok' | 'warning' | 'critical';
+    /** Token breakdown by component */
+    breakdown: Record<string, number>;
+}
+/**
+ * Context manager configuration
+ */
+interface ContextManagerConfig {
+    /** Maximum context tokens for the model */
+    maxContextTokens: number;
+    /** Threshold to trigger compaction (0.0 - 1.0) */
+    compactionThreshold: number;
+    /** Hard limit - must compact before this (0.0 - 1.0) */
+    hardLimit: number;
+    /** Reserve space for response (0.0 - 1.0) */
+    responseReserve: number;
+    /** Token estimator to use */
+    estimator: 'approximate' | 'tiktoken' | ITokenEstimator;
+    /** Enable automatic compaction */
+    autoCompact: boolean;
+    /** Strategy to use */
+    strategy?: 'proactive' | 'aggressive' | 'lazy' | 'rolling-window' | 'adaptive' | IContextStrategy;
+    /** Strategy-specific options */
+    strategyOptions?: Record<string, unknown>;
+}
+/**
+ * Default configuration
  */
-
+declare const DEFAULT_CONTEXT_CONFIG: ContextManagerConfig;
 /**
- * Configuration for FilePersistentInstructionsStorage
+ * Content type for more accurate token estimation
+ * Named differently from TokenContentType in Content.ts to avoid conflicts
  */
-interface FilePersistentInstructionsStorageConfig {
-    /** Agent ID (used to create unique storage path) */
-    agentId: string;
-    /** Override the base directory (default: ~/.oneringai/agents) */
-    baseDirectory?: string;
-    /** Override the filename (default: custom_instructions.json) */
-    filename?: string;
-}
+type TokenContentType = 'code' | 'prose' | 'mixed';
 /**
- * File-based storage for persistent agent instructions
+ * Abstract interface for token estimation
  */
-declare class FilePersistentInstructionsStorage implements IPersistentInstructionsStorage {
-    private readonly directory;
-    private readonly filePath;
-    private readonly legacyFilePath;
-    private readonly agentId;
-    constructor(config: FilePersistentInstructionsStorageConfig);
-    /**
-     * Load instruction entries from file.
-     * Falls back to legacy .md file migration if JSON not found.
-     */
-    load(): Promise<InstructionEntry[] | null>;
-    /**
-     * Save instruction entries to file as JSON.
-     * Creates directory if it doesn't exist.
-     * Cleans up legacy .md file if present.
-     */
-    save(entries: InstructionEntry[]): Promise<void>;
-    /**
-     * Delete instructions file (and legacy .md if exists)
-     */
-    delete(): Promise<void>;
-    /**
-     * Check if instructions file exists (JSON or legacy .md)
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Get the file path (for display/debugging)
-     */
-    getPath(): string;
+interface ITokenEstimator {
     /**
-     * Get the agent ID
+     * Estimate token count for text
+     *
+     * @param text - The text to estimate
+     * @param contentType - Type of content for more accurate estimation:
+     *   - 'code': Code is typically denser (~3 chars/token)
+     *   - 'prose': Natural language text (~4 chars/token)
+     *   - 'mixed': Mix of code and prose (~3.5 chars/token)
      */
-    getAgentId(): string;
+    estimateTokens(text: string, contentType?: TokenContentType): number;
     /**
-     * Ensure the directory exists
+     * Estimate tokens for structured data
      */
-    private ensureDirectory;
+    estimateDataTokens(data: unknown, contentType?: TokenContentType): number;
     /**
-     * Remove legacy .md file if it exists
+     * Estimate tokens for an image.
+     * @param width - Image width in pixels (if known)
+     * @param height - Image height in pixels (if known)
+     * @param detail - Image detail level: 'low', 'high', or 'auto'
      */
-    private removeLegacyFile;
-}
-
-/**
- * FileContextStorage - File-based storage for AgentContext session persistence
- *
- * Stores context sessions as JSON files on disk.
- * Path: ~/.oneringai/agents/<agentId>/sessions/<sessionId>.json
- * Windows: %APPDATA%/oneringai/agents/<agentId>/sessions/<sessionId>.json
- *
- * Features:
- * - Cross-platform path handling
- * - Safe session ID sanitization
- * - Atomic file operations (write to temp, then rename)
- * - Automatic directory creation
- * - Index file for fast listing
- */
-
-/**
- * Configuration for FileContextStorage
- */
-interface FileContextStorageConfig {
-    /** Agent ID (used to create unique storage path) */
-    agentId: string;
-    /** Override the base directory (default: ~/.oneringai/agents) */
-    baseDirectory?: string;
-    /** Pretty-print JSON (default: true for debugging, false in production) */
-    prettyPrint?: boolean;
+    estimateImageTokens?(width?: number, height?: number, detail?: string): number;
 }
 /**
- * File-based storage for AgentContext session persistence
+ * Abstract interface for compaction strategies
  */
-declare class FileContextStorage implements IContextStorage {
-    private readonly agentId;
-    private readonly sessionsDirectory;
-    private readonly indexPath;
-    private readonly prettyPrint;
-    private index;
-    constructor(config: FileContextStorageConfig);
-    /**
-     * Save context state to a session file
-     */
-    save(sessionId: string, state: SerializedContextState, metadata?: ContextSessionMetadata): Promise<void>;
-    /**
-     * Load context state from a session file
-     */
-    load(sessionId: string): Promise<StoredContextSession | null>;
+interface IContextCompactor {
+    /** Compactor name */
+    readonly name: string;
+    /** Priority order (lower = run first) */
+    readonly priority: number;
     /**
-     * Delete a session
+     * Check if this compactor can handle the component
      */
-    delete(sessionId: string): Promise<void>;
+    canCompact(component: IContextComponent): boolean;
     /**
-     * Check if a session exists
+     * Compact the component to target size
      */
-    exists(sessionId: string): Promise<boolean>;
+    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
     /**
-     * List all sessions (summaries only)
+     * Estimate savings from compaction
      */
-    list(options?: ContextStorageListOptions): Promise<ContextSessionSummary[]>;
+    estimateSavings(component: IContextComponent): number;
+}
+/**
+ * Context management strategy - defines the overall approach to managing context
+ */
+interface IContextStrategy {
+    /** Strategy name */
+    readonly name: string;
     /**
-     * Update session metadata without loading full state
+     * Decide if compaction is needed based on current budget
      */
-    updateMetadata(sessionId: string, metadata: Partial<ContextSessionMetadata>): Promise<void>;
+    shouldCompact(budget: ContextBudget, config: ContextManagerConfig): boolean;
     /**
-     * Get the storage path (for display/debugging)
-     * @deprecated Use getLocation() instead
+     * Execute compaction using available compactors
      */
-    getPath(): string;
+    compact(components: IContextComponent[], budget: ContextBudget, compactors: IContextCompactor[], estimator: ITokenEstimator): Promise<{
+        components: IContextComponent[];
+        log: string[];
+        tokensFreed: number;
+    }>;
     /**
-     * Get a human-readable storage location string (for display/debugging)
+     * Optional: Prepare components before budget calculation
+     * Use this for strategies that pre-process context (e.g., rolling window)
      */
-    getLocation(): string;
+    prepareComponents?(components: IContextComponent[]): Promise<IContextComponent[]>;
     /**
-     * Get the agent ID
+     * Optional: Post-process after compaction
+     * Use this for strategies that need cleanup or optimization
      */
-    getAgentId(): string;
+    postProcess?(components: IContextComponent[], budget: ContextBudget): Promise<IContextComponent[]>;
     /**
-     * Rebuild the index by scanning all session files
-     * Useful for recovery or migration
+     * Optional: Get strategy-specific metrics
      */
-    rebuildIndex(): Promise<void>;
-    private getFilePath;
-    private ensureDirectory;
-    private loadRaw;
-    private loadIndex;
-    private saveIndex;
-    private updateIndex;
-    private removeFromIndex;
-    private storedToIndexEntry;
+    getMetrics?(): Record<string, unknown>;
 }
+
 /**
- * Create a FileContextStorage for the given agent
- *
- * @param agentId - Agent ID
- * @param options - Optional configuration
- * @returns FileContextStorage instance
- *
- * @example
- * ```typescript
- * const storage = createFileContextStorage('my-agent');
- * const ctx = AgentContext.create({
- *   model: 'gpt-4',
- *   storage,
- * });
- *
- * // Save session
- * await ctx.save('session-001', { title: 'My Session' });
+ * Truncate Compactor
  *
- * // Load session
- * await ctx.load('session-001');
- * ```
+ * Truncates content to target size by:
+ * - For strings: Cut to character limit
+ * - For arrays: Keep most recent items
  */
-declare function createFileContextStorage(agentId: string, options?: Omit<FileContextStorageConfig, 'agentId'>): FileContextStorage;
+
+declare class TruncateCompactor implements IContextCompactor {
+    private estimator;
+    readonly name = "truncate";
+    readonly priority = 10;
+    constructor(estimator: ITokenEstimator);
+    canCompact(component: IContextComponent): boolean;
+    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
+    estimateSavings(component: IContextComponent): number;
+    private truncateString;
+    private truncateArray;
+}
 
 /**
- * FileAgentDefinitionStorage - File-based storage for agent definitions
+ * Summarize Compactor
  *
- * Stores agent definitions as JSON files on disk.
- * Path: ~/.oneringai/agents/<agentId>/definition.json
- * Windows: %APPDATA%/oneringai/agents/<agentId>/definition.json
+ * Uses LLM to create intelligent summaries of context components before compaction.
+ * This preserves the semantic meaning of content while reducing token count.
  *
- * Features:
- * - Cross-platform path handling
- * - Safe agent ID sanitization
- * - Atomic file operations
- * - Automatic directory creation
- * - Index file for fast listing
+ * Supports different summarization strategies based on content type:
+ * - Conversation history: Preserves decisions, facts, and preferences
+ * - Tool outputs (search/scrape): Preserves key findings, sources, and data
  */
 
 /**
- * Configuration for FileAgentDefinitionStorage
+ * Configuration for the SummarizeCompactor
  */
-interface FileAgentDefinitionStorageConfig {
-    /** Override the base directory (default: ~/.oneringai/agents) */
-    baseDirectory?: string;
-    /** Pretty-print JSON (default: true) */
-    prettyPrint?: boolean;
+interface SummarizeCompactorConfig {
+    /** Text provider for LLM-based summarization */
+    textProvider: ITextProvider;
+    /** Model to use for summarization (optional - uses provider default) */
+    model?: string;
+    /** Maximum tokens for the summary (default: 500) */
+    maxSummaryTokens?: number;
+    /** Preserve markdown structure like headings and lists (default: true) */
+    preserveStructure?: boolean;
+    /** Fall back to truncation if LLM summarization fails (default: true) */
+    fallbackToTruncate?: boolean;
+    /** Temperature for summarization (default: 0.3 for deterministic output) */
+    temperature?: number;
 }
 /**
- * File-based storage for agent definitions
+ * SummarizeCompactor - LLM-based context compaction
+ *
+ * Uses AI to intelligently summarize content, preserving semantic meaning
+ * while significantly reducing token count.
  */
-declare class FileAgentDefinitionStorage implements IAgentDefinitionStorage {
-    private readonly baseDirectory;
-    private readonly indexPath;
-    private readonly prettyPrint;
-    private index;
-    constructor(config?: FileAgentDefinitionStorageConfig);
-    /**
-     * Save an agent definition
-     */
-    save(definition: StoredAgentDefinition): Promise<void>;
+declare class SummarizeCompactor implements IContextCompactor {
+    readonly name = "summarize";
+    readonly priority = 5;
+    private config;
+    private estimator;
+    constructor(estimator: ITokenEstimator, config: SummarizeCompactorConfig);
     /**
-     * Load an agent definition
+     * Check if this compactor can handle the component
      */
-    load(agentId: string): Promise<StoredAgentDefinition | null>;
+    canCompact(component: IContextComponent): boolean;
     /**
-     * Delete an agent definition
+     * Compact the component by summarizing its content
      */
-    delete(agentId: string): Promise<void>;
+    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
     /**
-     * Check if an agent definition exists
+     * Estimate how many tokens could be saved by summarization
      */
-    exists(agentId: string): Promise<boolean>;
+    estimateSavings(component: IContextComponent): number;
     /**
-     * List all agent definitions
+     * Perform LLM-based summarization
      */
-    list(options?: AgentDefinitionListOptions): Promise<AgentDefinitionSummary[]>;
+    private summarize;
     /**
-     * Update metadata without loading full definition
+     * Fallback to simple truncation when LLM fails
      */
-    updateMetadata(agentId: string, metadata: Partial<AgentDefinitionMetadata>): Promise<void>;
+    private truncateFallback;
     /**
-     * Get storage path
+     * Detect content type from component metadata or name
      */
-    getPath(): string;
+    private detectContentType;
     /**
-     * Rebuild the index by scanning all agent directories
+     * Convert content to string for processing
      */
-    rebuildIndex(): Promise<void>;
-    private ensureDirectory;
-    private loadRaw;
-    private loadIndex;
-    private saveIndex;
-    private updateIndex;
-    private removeFromIndex;
-    private definitionToIndexEntry;
+    private stringifyContent;
 }
+
 /**
- * Create a FileAgentDefinitionStorage with default configuration
+ * Memory Eviction Compactor
+ *
+ * Evicts LRU entries from memory index
+ * Works with memory components that have eviction metadata
  */
-declare function createFileAgentDefinitionStorage(config?: FileAgentDefinitionStorageConfig): FileAgentDefinitionStorage;
+
+declare class MemoryEvictionCompactor implements IContextCompactor {
+    private estimator;
+    readonly name = "memory-eviction";
+    readonly priority = 8;
+    constructor(estimator: ITokenEstimator);
+    canCompact(component: IContextComponent): boolean;
+    compact(component: IContextComponent, targetTokens: number): Promise<IContextComponent>;
+    estimateSavings(component: IContextComponent): number;
+}
 
 /**
- * FileMediaStorage - File-based media storage implementation
+ * Approximate Token Estimator
  *
- * Saves generated media to a configurable directory on the local filesystem.
- * Default output directory: `os.tmpdir()/oneringai-media/`
+ * Uses content-type aware heuristics:
+ * - Code: ~3 chars/token (more symbols, shorter words)
+ * - Prose: ~4 chars/token (natural language)
+ * - Mixed: ~3.5 chars/token
+ *
+ * Fast and good enough for most use cases.
  */
 
-interface FileMediaStorageConfig {
-    /** Directory to store media files. Defaults to `os.tmpdir()/oneringai-media/` */
-    outputDir?: string;
-}
-declare class FileMediaStorage implements IMediaStorage {
-    private outputDir;
-    private initialized;
-    constructor(config?: FileMediaStorageConfig);
-    save(data: Buffer, metadata: MediaStorageMetadata): Promise<MediaStorageResult>;
-    read(location: string): Promise<Buffer | null>;
-    delete(location: string): Promise<void>;
-    exists(location: string): Promise<boolean>;
-    list(options?: MediaStorageListOptions): Promise<MediaStorageEntry[]>;
-    getPath(): string;
-    private generateFilename;
-    private ensureDir;
+declare class ApproximateTokenEstimator implements ITokenEstimator {
+    /**
+     * Estimate tokens for text with content-type awareness
+     *
+     * @param text - The text to estimate tokens for
+     * @param contentType - Type of content:
+     *   - 'code': Code is typically denser (~3 chars/token)
+     *   - 'prose': Natural language text (~4 chars/token)
+     *   - 'mixed': Mix of code and prose (~3.5 chars/token)
+     */
+    estimateTokens(text: string, contentType?: TokenContentType): number;
+    /**
+     * Estimate tokens for structured data (always uses 'mixed' estimation)
+     */
+    estimateDataTokens(data: unknown, contentType?: TokenContentType): number;
+    /**
+     * Estimate tokens for an image using tile-based model (matches OpenAI pricing).
+     *
+     * - detail='low': 85 tokens
+     * - detail='high' with known dimensions: 85 + 170 per 512×512 tile
+     * - Unknown dimensions: 1000 tokens (conservative default)
+     */
+    estimateImageTokens(width?: number, height?: number, detail?: string): number;
 }
+
 /**
- * Factory function for creating FileMediaStorage instances
+ * Token estimators
  */
-declare function createFileMediaStorage(config?: FileMediaStorageConfig): FileMediaStorage;
 
 /**
- * FileCustomToolStorage - File-based storage for custom tool definitions
- *
- * Stores custom tools as JSON files on disk with per-user isolation.
- * Path: ~/.oneringai/users/<userId>/custom-tools/<sanitized-name>.json
+ * Create token estimator from name
+ */
+declare function createEstimator(name: string): ITokenEstimator;
+
+/**
+ * IHistoryManager - Interface for conversation history management
  *
- * Features:
- * - Per-user isolation (multi-tenant safe)
- * - Cross-platform path handling
- * - Safe name sanitization
- * - Atomic file operations (write to .tmp then rename)
- * - Per-user index file for fast listing
- * - Search support (case-insensitive substring on name + description)
+ * Follows the same pattern as IMemoryStorage for pluggable implementations.
+ * Users can implement this interface to use Redis, PostgreSQL, file storage, etc.
  */
 
 /**
- * Configuration for FileCustomToolStorage
+ * A single message in conversation history
  */
-interface FileCustomToolStorageConfig {
-    /** Override the base directory (default: ~/.oneringai/users) */
-    baseDirectory?: string;
-    /** Pretty-print JSON (default: true) */
-    prettyPrint?: boolean;
+interface HistoryMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
 }
 /**
- * File-based storage for custom tool definitions
- *
- * Single instance handles all users. UserId is passed to each method.
+ * Events emitted by IHistoryManager implementations
  */
-declare class FileCustomToolStorage implements ICustomToolStorage {
-    private readonly baseDirectory;
-    private readonly prettyPrint;
-    constructor(config?: FileCustomToolStorageConfig);
-    /**
-     * Get the directory path for a specific user's custom tools
-     */
-    private getUserDirectory;
+interface HistoryManagerEvents {
+    'message:added': {
+        message: HistoryMessage;
+    };
+    'message:removed': {
+        messageId: string;
+    };
+    'history:cleared': {
+        reason?: string;
+    };
+    'history:compacted': {
+        removedCount: number;
+        strategy: string;
+    };
+    'history:restored': {
+        messageCount: number;
+    };
+}
+/**
+ * Configuration for history management
+ */
+interface IHistoryManagerConfig {
+    /** Maximum messages to keep (for sliding window) */
+    maxMessages?: number;
+    /** Maximum tokens to keep (estimated) */
+    maxTokens?: number;
+    /** Compaction strategy when limits are reached */
+    compactionStrategy?: 'truncate' | 'summarize' | 'sliding-window';
+    /** Number of recent messages to always preserve */
+    preserveRecentCount?: number;
+}
+/**
+ * Serialized history state for persistence
+ */
+interface SerializedHistoryState {
+    version: number;
+    messages: HistoryMessage[];
+    summaries?: Array<{
+        content: string;
+        coversCount: number;
+        timestamp: number;
+    }>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Interface for history storage backends
+ * Implement this to use custom storage (Redis, PostgreSQL, file, etc.)
+ */
+interface IHistoryStorage {
     /**
-     * Get the index file path for a specific user
+     * Store a message
      */
-    private getUserIndexPath;
+    addMessage(message: HistoryMessage): Promise<void>;
     /**
-     * Get the tool file path for a specific user
+     * Get all messages
      */
-    private getToolPath;
+    getMessages(): Promise<HistoryMessage[]>;
     /**
-     * Save a custom tool definition
+     * Get recent N messages
      */
-    save(userId: string | undefined, definition: CustomToolDefinition): Promise<void>;
+    getRecentMessages(count: number): Promise<HistoryMessage[]>;
     /**
-     * Load a custom tool definition by name
+     * Remove a message by ID
      */
-    load(userId: string | undefined, name: string): Promise<CustomToolDefinition | null>;
+    removeMessage(id: string): Promise<void>;
     /**
-     * Delete a custom tool definition
+     * Remove messages older than timestamp
      */
-    delete(userId: string | undefined, name: string): Promise<void>;
+    removeOlderThan(timestamp: number): Promise<number>;
     /**
-     * Check if a custom tool exists
+     * Clear all messages
      */
-    exists(userId: string | undefined, name: string): Promise<boolean>;
+    clear(): Promise<void>;
     /**
-     * List custom tools (summaries only)
+     * Get message count
      */
-    list(userId: string | undefined, options?: CustomToolListOptions): Promise<CustomToolSummary[]>;
+    getCount(): Promise<number>;
     /**
-     * Update metadata without loading full definition
+     * Get serialized state for session persistence
      */
-    updateMetadata(userId: string | undefined, name: string, metadata: Record<string, unknown>): Promise<void>;
+    getState(): Promise<SerializedHistoryState>;
     /**
-     * Get storage path for a specific user
+     * Restore from serialized state
      */
-    getPath(userId: string | undefined): string;
-    private ensureDirectory;
-    private loadIndex;
-    private saveIndex;
-    private updateIndex;
-    private removeFromIndex;
-    private definitionToIndexEntry;
-}
-/**
- * Create a FileCustomToolStorage with default configuration
- */
-declare function createFileCustomToolStorage(config?: FileCustomToolStorageConfig): FileCustomToolStorage;
-
-/**
- * FileUserInfoStorage - File-based storage for user information
- *
- * Stores user information as a JSON file on disk.
- * Path: ~/.oneringai/users/<userId>/user_info.json
- * Windows: %APPDATA%/oneringai/users/<userId>/user_info.json
- *
- * Features:
- * - Cross-platform path handling
- * - Safe user ID sanitization
- * - Atomic file operations
- * - Automatic directory creation
- * - Multi-user support (one storage instance for all users)
- */
-
-/**
- * Configuration for FileUserInfoStorage
- */
-interface FileUserInfoStorageConfig {
-    /** Override the base directory (default: ~/.oneringai/users) */
-    baseDirectory?: string;
-    /** Override the filename (default: user_info.json) */
-    filename?: string;
+    restoreState(state: SerializedHistoryState): Promise<void>;
 }
 /**
- * File-based storage for user information
- *
- * Single instance handles all users. UserId is passed to each method.
+ * Interface for history manager
+ * Manages conversation history with compaction and persistence support
  */
-declare class FileUserInfoStorage implements IUserInfoStorage {
-    private readonly baseDirectory;
-    private readonly filename;
-    constructor(config?: FileUserInfoStorageConfig);
+interface IHistoryManager extends EventEmitter<HistoryManagerEvents> {
     /**
-     * Get the directory path for a specific user
+     * Add a message to history
      */
-    private getUserDirectory;
+    addMessage(role: 'user' | 'assistant' | 'system', content: string, metadata?: Record<string, unknown>): Promise<HistoryMessage>;
     /**
-     * Get the file path for a specific user
+     * Get all messages (may include summaries as system messages)
      */
-    private getUserFilePath;
+    getMessages(): Promise<HistoryMessage[]>;
     /**
-     * Load user info entries from file for a specific user
+     * Get recent messages only
      */
-    load(userId: string | undefined): Promise<UserInfoEntry[] | null>;
+    getRecentMessages(count?: number): Promise<HistoryMessage[]>;
     /**
-     * Save user info entries to file for a specific user
-     * Creates directory if it doesn't exist.
+     * Get formatted history for LLM context
      */
-    save(userId: string | undefined, entries: UserInfoEntry[]): Promise<void>;
+    formatForContext(options?: {
+        maxTokens?: number;
+        includeMetadata?: boolean;
+    }): Promise<string>;
     /**
-     * Delete user info file for a specific user
+     * Compact history (apply compaction strategy)
      */
-    delete(userId: string | undefined): Promise<void>;
+    compact(): Promise<void>;
     /**
-     * Check if user info file exists for a specific user
+     * Clear all history
      */
-    exists(userId: string | undefined): Promise<boolean>;
+    clear(): Promise<void>;
     /**
-     * Get the file path for a specific user (for display/debugging)
+     * Get message count
      */
-    getPath(userId: string | undefined): string;
+    getMessageCount(): Promise<number>;
     /**
-     * Ensure the directory exists
+     * Get state for session persistence
      */
-    private ensureDirectory;
+    getState(): Promise<SerializedHistoryState>;
+    /**
+     * Restore from saved state
+     */
+    restoreState(state: SerializedHistoryState): Promise<void>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): IHistoryManagerConfig;
 }
+/**
+ * Default configuration
+ */
+declare const DEFAULT_HISTORY_MANAGER_CONFIG: Required<IHistoryManagerConfig>;
 
 /**
- * FileRoutineDefinitionStorage - File-based storage for routine definitions.
- *
- * Stores routines as JSON files on disk with per-user isolation.
- * Path: ~/.oneringai/users/<userId>/routines/<sanitized-id>.json
+ * InMemoryHistoryStorage - In-memory implementation of IHistoryStorage
  *
- * Features:
- * - Per-user isolation (multi-tenant safe)
- * - Cross-platform path handling
- * - Safe ID sanitization
- * - Atomic file operations (write to .tmp then rename)
- * - Per-user index file for fast listing/filtering
- * - Index auto-rebuild if missing
+ * Default storage backend for conversation history.
+ * For production, users can implement IHistoryStorage with Redis, PostgreSQL, etc.
  */
 
 /**
- * Configuration for FileRoutineDefinitionStorage
+ * In-memory history storage implementation
  */
-interface FileRoutineDefinitionStorageConfig {
-    /** Override the base directory (default: ~/.oneringai/users) */
-    baseDirectory?: string;
-    /** Pretty-print JSON (default: true) */
-    prettyPrint?: boolean;
+declare class InMemoryHistoryStorage implements IHistoryStorage {
+    private messages;
+    private summaries;
+    addMessage(message: HistoryMessage): Promise<void>;
+    getMessages(): Promise<HistoryMessage[]>;
+    getRecentMessages(count: number): Promise<HistoryMessage[]>;
+    removeMessage(id: string): Promise<void>;
+    removeOlderThan(timestamp: number): Promise<number>;
+    clear(): Promise<void>;
+    getCount(): Promise<number>;
+    getState(): Promise<SerializedHistoryState>;
+    restoreState(state: SerializedHistoryState): Promise<void>;
 }
+
 /**
- * File-based storage for routine definitions.
+ * Routine Control Flow — map, fold, until handlers + template resolution
  *
- * Single instance handles all users. UserId is passed to each method.
+ * Control flow tasks delegate to executeRoutine() recursively with the shared agent,
+ * using ICM keys (__map_item, __map_index, etc.) to pass iteration state.
  */
-declare class FileRoutineDefinitionStorage implements IRoutineDefinitionStorage {
-    private readonly baseDirectory;
-    private readonly prettyPrint;
-    constructor(config?: FileRoutineDefinitionStorageConfig);
-    private getUserDirectory;
-    private getIndexPath;
-    private getRoutinePath;
-    save(userId: string | undefined, definition: RoutineDefinition): Promise<void>;
-    load(userId: string | undefined, id: string): Promise<RoutineDefinition | null>;
-    delete(userId: string | undefined, id: string): Promise<void>;
-    exists(userId: string | undefined, id: string): Promise<boolean>;
-    list(userId: string | undefined, options?: {
-        tags?: string[];
-        search?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<RoutineDefinition[]>;
-    getPath(userId: string | undefined): string;
-    private ensureDirectory;
-    private loadIndex;
-    private saveIndex;
-    private updateIndex;
-    private removeFromIndex;
-    private definitionToIndexEntry;
-    /**
-     * Rebuild index by scanning directory for .json files (excluding _index.json).
-     * Returns empty index if directory doesn't exist.
-     */
-    private rebuildIndex;
+
+/** Well-known ICM/WM keys used by the routine execution framework. */
+declare const ROUTINE_KEYS: {
+    /** Plan overview with task statuses (ICM) */
+    readonly PLAN: "__routine_plan";
+    /** Dependency results location guide (ICM) */
+    readonly DEPS: "__routine_deps";
+    /** Prefix for per-dependency result keys (ICM/WM) */
+    readonly DEP_RESULT_PREFIX: "__dep_result_";
+    /** Current map/fold item (ICM) */
+    readonly MAP_ITEM: "__map_item";
+    /** Current map/fold index, 0-based (ICM) */
+    readonly MAP_INDEX: "__map_index";
+    /** Total items in map/fold (ICM) */
+    readonly MAP_TOTAL: "__map_total";
+    /** Running fold accumulator (ICM) */
+    readonly FOLD_ACCUMULATOR: "__fold_accumulator";
+    /** Prefix for large dep results stored in WM findings tier */
+    readonly WM_DEP_FINDINGS_PREFIX: "findings/__dep_result_";
+    /** Prefix for auto-stored task outputs (set by output contracts) */
+    readonly TASK_OUTPUT_PREFIX: "__task_output_";
+};
+interface ControlFlowResult {
+    completed: boolean;
+    result?: unknown;
+    error?: string;
 }
 /**
- * Create a FileRoutineDefinitionStorage with default configuration
+ * Resolve template placeholders in text.
+ *
+ * Supported namespaces:
+ * - {{param.name}} → inputs[name]
+ * - {{map.item}} / {{map.index}} / {{map.total}} → ICM keys
+ * - {{fold.accumulator}} → ICM key
+ *
+ * Non-string values are JSON.stringify'd. Unresolved templates are left as-is.
  */
-declare function createFileRoutineDefinitionStorage(config?: FileRoutineDefinitionStorageConfig): FileRoutineDefinitionStorage;
+declare function resolveTemplates(text: string, inputs: Record<string, unknown>, icmPlugin: InContextMemoryPluginNextGen | null): string;
+/**
+ * Resolve the source array for a map/fold control flow using layered resolution:
+ * 1. Determine lookup key(s) from source config
+ * 2. Read from ICM/WM with fallback chain
+ * 3. Apply JSON path extraction if specified
+ * 4. Coerce to array algorithmically (JSON parse, common field names)
+ * 5. LLM extraction fallback if still not an array
+ */
+declare function resolveFlowSource(flow: {
+    source: ControlFlowSource;
+    maxIterations?: number;
+}, flowType: string, agent: Agent, execution: RoutineExecution | undefined, icmPlugin: InContextMemoryPluginNextGen | null, wmPlugin: WorkingMemoryPluginNextGen | null): Promise<{
+    array: unknown[];
+    maxIter: number;
+} | ControlFlowResult>;
 
 /**
  * Video Model Registry
@@ -10080,6 +10657,10 @@ declare class StreamState {
     currentIteration: number;
     usage: TokenUsage;
     status: 'in_progress' | 'completed' | 'incomplete' | 'failed';
+    /** Status reported by the provider's RESPONSE_COMPLETE event. Defaults to 'incomplete' (safe if never received). */
+    providerStatus: 'completed' | 'incomplete' | 'failed';
+    /** Raw stop reason from provider (e.g., 'end_turn', 'max_tokens', 'SAFETY') */
+    stopReason?: string;
     startTime: Date;
     endTime?: Date;
     totalChunks: number;
@@ -10197,6 +10778,8 @@ declare class StreamState {
                 reasoning_tokens: number;
             };
         };
+        providerStatus: "completed" | "failed" | "incomplete";
+        stopReason: string | undefined;
     };
     /**
      * Check if stream has any accumulated text
@@ -10232,6 +10815,8 @@ declare class StreamState {
             };
         };
         status: "in_progress" | "completed" | "failed" | "incomplete";
+        providerStatus: "completed" | "failed" | "incomplete";
+        stopReason: string | undefined;
         startTime: Date;
         endTime: Date | undefined;
     };
@@ -11786,6 +12371,8 @@ interface RateLimiterConfig {
     onLimit: 'wait' | 'throw';
     /** Max wait time in ms (for 'wait' mode, default: 60000) */
     maxWaitMs?: number;
+    /** Max queued waiters (default: 500). Rejects new requests when exceeded. */
+    maxQueueSize?: number;
 }
 /**
  * Default rate limiter configuration
@@ -13110,6 +13697,23 @@ interface GitHubPRCommentsResult {
     count?: number;
     error?: string;
 }
+/**
+ * A branch entry
+ */
+interface GitHubBranchEntry {
+    name: string;
+    sha: string;
+    protected: boolean;
+}
+/**
+ * Result from list_branches tool
+ */
+interface GitHubListBranchesResult {
+    success: boolean;
+    branches?: GitHubBranchEntry[];
+    count?: number;
+    error?: string;
+}
 /**
  * Result from create_pr tool
  */
@@ -13155,7 +13759,9 @@ declare function createSearchFilesTool(connector: Connector, userId?: string): T
  * Search for code content across a GitHub repository.
  * Mirrors the local `grep` tool for remote GitHub repos.
  *
- * Uses the GitHub Code Search API with text-match support.
+ * Uses the GitHub Code Search API with text-match support for default branch.
+ * Falls back to tree + blob scanning when a specific branch/ref is requested,
+ * since GitHub's code search API only indexes the default branch.
  *
  * Note: GitHub's code search API has a rate limit of 30 requests/minute.
  */
@@ -13168,6 +13774,8 @@ interface SearchCodeArgs {
     repository?: string;
     /** Search query (keyword or phrase) */
     query: string;
+    /** Branch, tag, or commit SHA. Defaults to the repository's default branch. */
+    ref?: string;
     /** Filter by programming language (e.g., "typescript", "python") */
     language?: string;
     /** Filter by file path (e.g., "src/", "lib/utils") */
@@ -13301,6 +13909,31 @@ interface CreatePRArgs {
  */
 declare function createCreatePRTool(connector: Connector, userId?: string): ToolFunction<CreatePRArgs, GitHubCreatePRResult>;
 
+/**
+ * GitHub List Branches Tool
+ *
+ * List branches in a GitHub repository.
+ * Supports filtering by name pattern and pagination.
+ */
+
+/**
+ * Arguments for the list_branches tool
+ */
+interface ListBranchesArgs {
+    /** Repository in "owner/repo" format or full GitHub URL */
+    repository?: string;
+    /** Filter branches by name prefix or substring (case-insensitive, client-side) */
+    filter?: string;
+    /** Include only protected branches (default: false — list all) */
+    protected_only?: boolean;
+    /** Maximum number of branches to return (default: 100, max: 100) */
+    limit?: number;
+}
+/**
+ * Create a GitHub list_branches tool
+ */
+declare function createListBranchesTool(connector: Connector, userId?: string): ToolFunction<ListBranchesArgs, GitHubListBranchesResult>;
+
 /**
  * Microsoft Graph Tools - Shared Types and Helpers
  *
@@ -14111,7 +14744,7 @@ declare const desktopTools: (ToolFunction<DesktopScreenshotArgs, DesktopScreensh
  * AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
  *
  * Generated by: scripts/generate-tool-registry.ts
- * Generated at: 2026-03-04T17:26:21.729Z
+ * Generated at: 2026-03-12T18:47:09.908Z
  *
  * To regenerate: npm run generate:tools
  */
@@ -14551,8 +15184,10 @@ declare const index_FormatDetector: typeof FormatDetector;
 type index_GenericAPICallArgs = GenericAPICallArgs;
 type index_GenericAPICallResult = GenericAPICallResult;
 type index_GenericAPIToolOptions = GenericAPIToolOptions;
+type index_GitHubBranchEntry = GitHubBranchEntry;
 type index_GitHubCreatePRResult = GitHubCreatePRResult;
 type index_GitHubGetPRResult = GitHubGetPRResult;
+type index_GitHubListBranchesResult = GitHubListBranchesResult;
 type index_GitHubPRCommentEntry = GitHubPRCommentEntry;
 type index_GitHubPRCommentsResult = GitHubPRCommentsResult;
 type index_GitHubPRFilesResult = GitHubPRFilesResult;
@@ -14625,6 +15260,7 @@ declare const index_createGitHubReadFileTool: typeof createGitHubReadFileTool;
 declare const index_createGlobTool: typeof createGlobTool;
 declare const index_createGrepTool: typeof createGrepTool;
 declare const index_createImageGenerationTool: typeof createImageGenerationTool;
+declare const index_createListBranchesTool: typeof createListBranchesTool;
 declare const index_createListDirectoryTool: typeof createListDirectoryTool;
 declare const index_createMeetingTool: typeof createMeetingTool;
 declare const index_createMicrosoftListFilesTool: typeof createMicrosoftListFilesTool;
@@ -14710,7 +15346,7 @@ declare const index_validatePath: typeof validatePath;
 declare const index_webFetch: typeof webFetch;
 declare const index_writeFile: typeof writeFile;
 declare namespace index {
-  export { type index_BashResult as BashResult, type index_ConnectorToolEntry as ConnectorToolEntry, index_ConnectorTools as ConnectorTools, type index_CustomToolMetaToolsOptions as CustomToolMetaToolsOptions, index_DEFAULT_DESKTOP_CONFIG as DEFAULT_DESKTOP_CONFIG, index_DEFAULT_FILESYSTEM_CONFIG as DEFAULT_FILESYSTEM_CONFIG, index_DEFAULT_SHELL_CONFIG as DEFAULT_SHELL_CONFIG, index_DESKTOP_TOOL_NAMES as DESKTOP_TOOL_NAMES, type index_DesktopGetCursorResult as DesktopGetCursorResult, type index_DesktopGetScreenSizeResult as DesktopGetScreenSizeResult, type index_DesktopKeyboardKeyArgs as DesktopKeyboardKeyArgs, type index_DesktopKeyboardKeyResult as DesktopKeyboardKeyResult, type index_DesktopKeyboardTypeArgs as DesktopKeyboardTypeArgs, type index_DesktopKeyboardTypeResult as DesktopKeyboardTypeResult, type index_DesktopMouseClickArgs as DesktopMouseClickArgs, type index_DesktopMouseClickResult as DesktopMouseClickResult, type index_DesktopMouseDragArgs as DesktopMouseDragArgs, type index_DesktopMouseDragResult as DesktopMouseDragResult, type index_DesktopMouseMoveArgs as DesktopMouseMoveArgs, type index_DesktopMouseMoveResult as DesktopMouseMoveResult, type index_DesktopMouseScrollArgs as DesktopMouseScrollArgs, type index_DesktopMouseScrollResult as DesktopMouseScrollResult, type index_DesktopPoint as DesktopPoint, type index_DesktopScreenSize as DesktopScreenSize, type index_DesktopScreenshot as DesktopScreenshot, type index_DesktopScreenshotArgs as DesktopScreenshotArgs, type index_DesktopScreenshotResult as DesktopScreenshotResult, type index_DesktopToolConfig as DesktopToolConfig, type index_DesktopToolName as DesktopToolName, type index_DesktopWindow as DesktopWindow, type index_DesktopWindowFocusArgs as DesktopWindowFocusArgs, type index_DesktopWindowFocusResult as DesktopWindowFocusResult, type index_DesktopWindowListResult as DesktopWindowListResult, type index_DocumentFamily as DocumentFamily, type index_DocumentFormat as DocumentFormat, type index_DocumentImagePiece as DocumentImagePiece, type index_DocumentMetadata as DocumentMetadata, type index_DocumentPiece as DocumentPiece, type index_DocumentReadOptions as DocumentReadOptions, index_DocumentReader as DocumentReader, type index_DocumentReaderConfig as DocumentReaderConfig, type index_DocumentResult as DocumentResult, type index_DocumentSource as DocumentSource, type index_DocumentTextPiece as DocumentTextPiece, type index_DocumentToContentOptions as DocumentToContentOptions, type index_EditFileResult as EditFileResult, FileMediaStorage as FileMediaOutputHandler, type index_FilesystemToolConfig as FilesystemToolConfig, type index_FormatDetectionResult as FormatDetectionResult, index_FormatDetector as FormatDetector, type index_GenericAPICallArgs as GenericAPICallArgs, type index_GenericAPICallResult as GenericAPICallResult, type index_GenericAPIToolOptions as GenericAPIToolOptions, type index_GitHubCreatePRResult as GitHubCreatePRResult, type index_GitHubGetPRResult as GitHubGetPRResult, type index_GitHubPRCommentEntry as GitHubPRCommentEntry, type index_GitHubPRCommentsResult as GitHubPRCommentsResult, type index_GitHubPRFilesResult as GitHubPRFilesResult, type index_GitHubReadFileResult as GitHubReadFileResult, type index_GitHubRepository as GitHubRepository, type index_GitHubSearchCodeResult as GitHubSearchCodeResult, type index_GitHubSearchFilesResult as GitHubSearchFilesResult, type index_GlobResult as GlobResult, type index_GraphDriveItem as GraphDriveItem, type index_GrepMatch as GrepMatch, type index_GrepResult as GrepResult, type index_HydrateOptions as HydrateOptions, type index_IDesktopDriver as IDesktopDriver, type index_IDocumentTransformer as IDocumentTransformer, type index_IFormatHandler as IFormatHandler, type IMediaStorage as IMediaOutputHandler, type index_ImageFilterOptions as ImageFilterOptions, type MediaStorageMetadata as MediaOutputMetadata, type MediaStorageResult as MediaOutputResult, type index_MeetingSlotSuggestion as MeetingSlotSuggestion, type index_MicrosoftCreateMeetingResult as MicrosoftCreateMeetingResult, type index_MicrosoftDraftEmailResult as MicrosoftDraftEmailResult, type index_MicrosoftEditMeetingResult as MicrosoftEditMeetingResult, type index_MicrosoftFindSlotsResult as MicrosoftFindSlotsResult, type index_MicrosoftGetTranscriptResult as MicrosoftGetTranscriptResult, type index_MicrosoftListFilesResult as MicrosoftListFilesResult, type index_MicrosoftReadFileResult as MicrosoftReadFileResult, type index_MicrosoftSearchFilesResult as MicrosoftSearchFilesResult, type index_MicrosoftSendEmailResult as MicrosoftSendEmailResult, type index_MouseButton as MouseButton, index_NutTreeDriver as NutTreeDriver, type index_ReadFileResult as ReadFileResult, type index_SearchResult as SearchResult, type index_ServiceToolFactory as ServiceToolFactory, type index_ShellToolConfig as ShellToolConfig, type index_ToolCategory as ToolCategory, index_ToolRegistry as ToolRegistry, type index_ToolRegistryEntry as ToolRegistryEntry, type index_WriteFileResult as WriteFileResult, index_applyHumanDelay as applyHumanDelay, index_bash as bash, index_createBashTool as createBashTool, index_createCreatePRTool as createCreatePRTool, index_createCustomToolDelete as createCustomToolDelete, index_createCustomToolDraft as createCustomToolDraft, index_createCustomToolList as createCustomToolList, index_createCustomToolLoad as createCustomToolLoad, index_createCustomToolMetaTools as createCustomToolMetaTools, index_createCustomToolSave as createCustomToolSave, index_createCustomToolTest as createCustomToolTest, index_createDesktopGetCursorTool as createDesktopGetCursorTool, index_createDesktopGetScreenSizeTool as createDesktopGetScreenSizeTool, index_createDesktopKeyboardKeyTool as createDesktopKeyboardKeyTool, index_createDesktopKeyboardTypeTool as createDesktopKeyboardTypeTool, index_createDesktopMouseClickTool as createDesktopMouseClickTool, index_createDesktopMouseDragTool as createDesktopMouseDragTool, index_createDesktopMouseMoveTool as createDesktopMouseMoveTool, index_createDesktopMouseScrollTool as createDesktopMouseScrollTool, index_createDesktopScreenshotTool as createDesktopScreenshotTool, index_createDesktopWindowFocusTool as createDesktopWindowFocusTool, index_createDesktopWindowListTool as createDesktopWindowListTool, index_createDraftEmailTool as createDraftEmailTool, index_createEditFileTool as createEditFileTool, index_createEditMeetingTool as createEditMeetingTool, index_createExecuteJavaScriptTool as createExecuteJavaScriptTool, index_createFindMeetingSlotsTool as createFindMeetingSlotsTool, index_createGenerateRoutine as createGenerateRoutine, index_createGetMeetingTranscriptTool as createGetMeetingTranscriptTool, index_createGetPRTool as createGetPRTool, index_createGitHubReadFileTool as createGitHubReadFileTool, index_createGlobTool as createGlobTool, index_createGrepTool as createGrepTool, index_createImageGenerationTool as createImageGenerationTool, index_createListDirectoryTool as createListDirectoryTool, index_createMeetingTool as createMeetingTool, index_createMicrosoftListFilesTool as createMicrosoftListFilesTool, index_createMicrosoftReadFileTool as createMicrosoftReadFileTool, index_createMicrosoftSearchFilesTool as createMicrosoftSearchFilesTool, index_createPRCommentsTool as createPRCommentsTool, index_createPRFilesTool as createPRFilesTool, index_createReadFileTool as createReadFileTool, index_createSearchCodeTool as createSearchCodeTool, index_createSearchFilesTool as createSearchFilesTool, index_createSendEmailTool as createSendEmailTool, index_createSpeechToTextTool as createSpeechToTextTool, index_createTextToSpeechTool as createTextToSpeechTool, index_createVideoTools as createVideoTools, index_createWebScrapeTool as createWebScrapeTool, index_createWebSearchTool as createWebSearchTool, index_createWriteFileTool as createWriteFileTool, index_customToolDelete as customToolDelete, index_customToolDraft as customToolDraft, index_customToolList as customToolList, index_customToolLoad as customToolLoad, index_customToolSave as customToolSave, index_customToolTest as customToolTest, index_desktopGetCursor as desktopGetCursor, index_desktopGetScreenSize as desktopGetScreenSize, index_desktopKeyboardKey as desktopKeyboardKey, index_desktopKeyboardType as desktopKeyboardType, index_desktopMouseClick as desktopMouseClick, index_desktopMouseDrag as desktopMouseDrag, index_desktopMouseMove as desktopMouseMove, index_desktopMouseScroll as desktopMouseScroll, index_desktopScreenshot as desktopScreenshot, index_desktopTools as desktopTools, index_desktopWindowFocus as desktopWindowFocus, index_desktopWindowList as desktopWindowList, index_developerTools as developerTools, index_editFile as editFile, index_encodeSharingUrl as encodeSharingUrl, index_executeInVM as executeInVM, index_executeJavaScript as executeJavaScript, index_expandTilde as expandTilde, index_formatAttendees as formatAttendees, index_formatFileSize as formatFileSize, index_formatRecipients as formatRecipients, index_generateRoutine as generateRoutine, index_getAllBuiltInTools as getAllBuiltInTools, index_getBackgroundOutput as getBackgroundOutput, index_getDesktopDriver as getDesktopDriver, index_getDrivePrefix as getDrivePrefix, index_getMediaOutputHandler as getMediaOutputHandler, index_getMediaStorage as getMediaStorage, index_getToolByName as getToolByName, index_getToolCategories as getToolCategories, index_getToolRegistry as getToolRegistry, index_getToolsByCategory as getToolsByCategory, index_getToolsRequiringConnector as getToolsRequiringConnector, index_getUserPathPrefix as getUserPathPrefix, index_glob as glob, index_grep as grep, index_hydrateCustomTool as hydrateCustomTool, index_isBlockedCommand as isBlockedCommand, index_isExcludedExtension as isExcludedExtension, index_isMicrosoftFileUrl as isMicrosoftFileUrl, index_isTeamsMeetingUrl as isTeamsMeetingUrl, index_isWebUrl as isWebUrl, index_jsonManipulator as jsonManipulator, index_killBackgroundProcess as killBackgroundProcess, index_listDirectory as listDirectory, index_mergeTextPieces as mergeTextPieces, index_microsoftFetch as microsoftFetch, index_normalizeEmails as normalizeEmails, index_parseKeyCombo as parseKeyCombo, index_parseRepository as parseRepository, index_readFile as readFile, index_resetDefaultDriver as resetDefaultDriver, index_resolveFileEndpoints as resolveFileEndpoints, index_resolveMeetingId as resolveMeetingId, index_resolveRepository as resolveRepository, index_setMediaOutputHandler as setMediaOutputHandler, index_setMediaStorage as setMediaStorage, index_toolRegistry as toolRegistry, index_validatePath as validatePath, index_webFetch as webFetch, index_writeFile as writeFile };
+  export { type index_BashResult as BashResult, type index_ConnectorToolEntry as ConnectorToolEntry, index_ConnectorTools as ConnectorTools, type index_CustomToolMetaToolsOptions as CustomToolMetaToolsOptions, index_DEFAULT_DESKTOP_CONFIG as DEFAULT_DESKTOP_CONFIG, index_DEFAULT_FILESYSTEM_CONFIG as DEFAULT_FILESYSTEM_CONFIG, index_DEFAULT_SHELL_CONFIG as DEFAULT_SHELL_CONFIG, index_DESKTOP_TOOL_NAMES as DESKTOP_TOOL_NAMES, type index_DesktopGetCursorResult as DesktopGetCursorResult, type index_DesktopGetScreenSizeResult as DesktopGetScreenSizeResult, type index_DesktopKeyboardKeyArgs as DesktopKeyboardKeyArgs, type index_DesktopKeyboardKeyResult as DesktopKeyboardKeyResult, type index_DesktopKeyboardTypeArgs as DesktopKeyboardTypeArgs, type index_DesktopKeyboardTypeResult as DesktopKeyboardTypeResult, type index_DesktopMouseClickArgs as DesktopMouseClickArgs, type index_DesktopMouseClickResult as DesktopMouseClickResult, type index_DesktopMouseDragArgs as DesktopMouseDragArgs, type index_DesktopMouseDragResult as DesktopMouseDragResult, type index_DesktopMouseMoveArgs as DesktopMouseMoveArgs, type index_DesktopMouseMoveResult as DesktopMouseMoveResult, type index_DesktopMouseScrollArgs as DesktopMouseScrollArgs, type index_DesktopMouseScrollResult as DesktopMouseScrollResult, type index_DesktopPoint as DesktopPoint, type index_DesktopScreenSize as DesktopScreenSize, type index_DesktopScreenshot as DesktopScreenshot, type index_DesktopScreenshotArgs as DesktopScreenshotArgs, type index_DesktopScreenshotResult as DesktopScreenshotResult, type index_DesktopToolConfig as DesktopToolConfig, type index_DesktopToolName as DesktopToolName, type index_DesktopWindow as DesktopWindow, type index_DesktopWindowFocusArgs as DesktopWindowFocusArgs, type index_DesktopWindowFocusResult as DesktopWindowFocusResult, type index_DesktopWindowListResult as DesktopWindowListResult, type index_DocumentFamily as DocumentFamily, type index_DocumentFormat as DocumentFormat, type index_DocumentImagePiece as DocumentImagePiece, type index_DocumentMetadata as DocumentMetadata, type index_DocumentPiece as DocumentPiece, type index_DocumentReadOptions as DocumentReadOptions, index_DocumentReader as DocumentReader, type index_DocumentReaderConfig as DocumentReaderConfig, type index_DocumentResult as DocumentResult, type index_DocumentSource as DocumentSource, type index_DocumentTextPiece as DocumentTextPiece, type index_DocumentToContentOptions as DocumentToContentOptions, type index_EditFileResult as EditFileResult, FileMediaStorage as FileMediaOutputHandler, type index_FilesystemToolConfig as FilesystemToolConfig, type index_FormatDetectionResult as FormatDetectionResult, index_FormatDetector as FormatDetector, type index_GenericAPICallArgs as GenericAPICallArgs, type index_GenericAPICallResult as GenericAPICallResult, type index_GenericAPIToolOptions as GenericAPIToolOptions, type index_GitHubBranchEntry as GitHubBranchEntry, type index_GitHubCreatePRResult as GitHubCreatePRResult, type index_GitHubGetPRResult as GitHubGetPRResult, type index_GitHubListBranchesResult as GitHubListBranchesResult, type index_GitHubPRCommentEntry as GitHubPRCommentEntry, type index_GitHubPRCommentsResult as GitHubPRCommentsResult, type index_GitHubPRFilesResult as GitHubPRFilesResult, type index_GitHubReadFileResult as GitHubReadFileResult, type index_GitHubRepository as GitHubRepository, type index_GitHubSearchCodeResult as GitHubSearchCodeResult, type index_GitHubSearchFilesResult as GitHubSearchFilesResult, type index_GlobResult as GlobResult, type index_GraphDriveItem as GraphDriveItem, type index_GrepMatch as GrepMatch, type index_GrepResult as GrepResult, type index_HydrateOptions as HydrateOptions, type index_IDesktopDriver as IDesktopDriver, type index_IDocumentTransformer as IDocumentTransformer, type index_IFormatHandler as IFormatHandler, type IMediaStorage as IMediaOutputHandler, type index_ImageFilterOptions as ImageFilterOptions, type MediaStorageMetadata as MediaOutputMetadata, type MediaStorageResult as MediaOutputResult, type index_MeetingSlotSuggestion as MeetingSlotSuggestion, type index_MicrosoftCreateMeetingResult as MicrosoftCreateMeetingResult, type index_MicrosoftDraftEmailResult as MicrosoftDraftEmailResult, type index_MicrosoftEditMeetingResult as MicrosoftEditMeetingResult, type index_MicrosoftFindSlotsResult as MicrosoftFindSlotsResult, type index_MicrosoftGetTranscriptResult as MicrosoftGetTranscriptResult, type index_MicrosoftListFilesResult as MicrosoftListFilesResult, type index_MicrosoftReadFileResult as MicrosoftReadFileResult, type index_MicrosoftSearchFilesResult as MicrosoftSearchFilesResult, type index_MicrosoftSendEmailResult as MicrosoftSendEmailResult, type index_MouseButton as MouseButton, index_NutTreeDriver as NutTreeDriver, type index_ReadFileResult as ReadFileResult, type index_SearchResult as SearchResult, type index_ServiceToolFactory as ServiceToolFactory, type index_ShellToolConfig as ShellToolConfig, type index_ToolCategory as ToolCategory, index_ToolRegistry as ToolRegistry, type index_ToolRegistryEntry as ToolRegistryEntry, type index_WriteFileResult as WriteFileResult, index_applyHumanDelay as applyHumanDelay, index_bash as bash, index_createBashTool as createBashTool, index_createCreatePRTool as createCreatePRTool, index_createCustomToolDelete as createCustomToolDelete, index_createCustomToolDraft as createCustomToolDraft, index_createCustomToolList as createCustomToolList, index_createCustomToolLoad as createCustomToolLoad, index_createCustomToolMetaTools as createCustomToolMetaTools, index_createCustomToolSave as createCustomToolSave, index_createCustomToolTest as createCustomToolTest, index_createDesktopGetCursorTool as createDesktopGetCursorTool, index_createDesktopGetScreenSizeTool as createDesktopGetScreenSizeTool, index_createDesktopKeyboardKeyTool as createDesktopKeyboardKeyTool, index_createDesktopKeyboardTypeTool as createDesktopKeyboardTypeTool, index_createDesktopMouseClickTool as createDesktopMouseClickTool, index_createDesktopMouseDragTool as createDesktopMouseDragTool, index_createDesktopMouseMoveTool as createDesktopMouseMoveTool, index_createDesktopMouseScrollTool as createDesktopMouseScrollTool, index_createDesktopScreenshotTool as createDesktopScreenshotTool, index_createDesktopWindowFocusTool as createDesktopWindowFocusTool, index_createDesktopWindowListTool as createDesktopWindowListTool, index_createDraftEmailTool as createDraftEmailTool, index_createEditFileTool as createEditFileTool, index_createEditMeetingTool as createEditMeetingTool, index_createExecuteJavaScriptTool as createExecuteJavaScriptTool, index_createFindMeetingSlotsTool as createFindMeetingSlotsTool, index_createGenerateRoutine as createGenerateRoutine, index_createGetMeetingTranscriptTool as createGetMeetingTranscriptTool, index_createGetPRTool as createGetPRTool, index_createGitHubReadFileTool as createGitHubReadFileTool, index_createGlobTool as createGlobTool, index_createGrepTool as createGrepTool, index_createImageGenerationTool as createImageGenerationTool, index_createListBranchesTool as createListBranchesTool, index_createListDirectoryTool as createListDirectoryTool, index_createMeetingTool as createMeetingTool, index_createMicrosoftListFilesTool as createMicrosoftListFilesTool, index_createMicrosoftReadFileTool as createMicrosoftReadFileTool, index_createMicrosoftSearchFilesTool as createMicrosoftSearchFilesTool, index_createPRCommentsTool as createPRCommentsTool, index_createPRFilesTool as createPRFilesTool, index_createReadFileTool as createReadFileTool, index_createSearchCodeTool as createSearchCodeTool, index_createSearchFilesTool as createSearchFilesTool, index_createSendEmailTool as createSendEmailTool, index_createSpeechToTextTool as createSpeechToTextTool, index_createTextToSpeechTool as createTextToSpeechTool, index_createVideoTools as createVideoTools, index_createWebScrapeTool as createWebScrapeTool, index_createWebSearchTool as createWebSearchTool, index_createWriteFileTool as createWriteFileTool, index_customToolDelete as customToolDelete, index_customToolDraft as customToolDraft, index_customToolList as customToolList, index_customToolLoad as customToolLoad, index_customToolSave as customToolSave, index_customToolTest as customToolTest, index_desktopGetCursor as desktopGetCursor, index_desktopGetScreenSize as desktopGetScreenSize, index_desktopKeyboardKey as desktopKeyboardKey, index_desktopKeyboardType as desktopKeyboardType, index_desktopMouseClick as desktopMouseClick, index_desktopMouseDrag as desktopMouseDrag, index_desktopMouseMove as desktopMouseMove, index_desktopMouseScroll as desktopMouseScroll, index_desktopScreenshot as desktopScreenshot, index_desktopTools as desktopTools, index_desktopWindowFocus as desktopWindowFocus, index_desktopWindowList as desktopWindowList, index_developerTools as developerTools, index_editFile as editFile, index_encodeSharingUrl as encodeSharingUrl, index_executeInVM as executeInVM, index_executeJavaScript as executeJavaScript, index_expandTilde as expandTilde, index_formatAttendees as formatAttendees, index_formatFileSize as formatFileSize, index_formatRecipients as formatRecipients, index_generateRoutine as generateRoutine, index_getAllBuiltInTools as getAllBuiltInTools, index_getBackgroundOutput as getBackgroundOutput, index_getDesktopDriver as getDesktopDriver, index_getDrivePrefix as getDrivePrefix, index_getMediaOutputHandler as getMediaOutputHandler, index_getMediaStorage as getMediaStorage, index_getToolByName as getToolByName, index_getToolCategories as getToolCategories, index_getToolRegistry as getToolRegistry, index_getToolsByCategory as getToolsByCategory, index_getToolsRequiringConnector as getToolsRequiringConnector, index_getUserPathPrefix as getUserPathPrefix, index_glob as glob, index_grep as grep, index_hydrateCustomTool as hydrateCustomTool, index_isBlockedCommand as isBlockedCommand, index_isExcludedExtension as isExcludedExtension, index_isMicrosoftFileUrl as isMicrosoftFileUrl, index_isTeamsMeetingUrl as isTeamsMeetingUrl, index_isWebUrl as isWebUrl, index_jsonManipulator as jsonManipulator, index_killBackgroundProcess as killBackgroundProcess, index_listDirectory as listDirectory, index_mergeTextPieces as mergeTextPieces, index_microsoftFetch as microsoftFetch, index_normalizeEmails as normalizeEmails, index_parseKeyCombo as parseKeyCombo, index_parseRepository as parseRepository, index_readFile as readFile, index_resetDefaultDriver as resetDefaultDriver, index_resolveFileEndpoints as resolveFileEndpoints, index_resolveMeetingId as resolveMeetingId, index_resolveRepository as resolveRepository, index_setMediaOutputHandler as setMediaOutputHandler, index_setMediaStorage as setMediaStorage, index_toolRegistry as toolRegistry, index_validatePath as validatePath, index_webFetch as webFetch, index_writeFile as writeFile };
 }
 
 /**
@@ -14837,4 +15473,4 @@ declare class EventEmitterTrigger implements IDisposable {
     get isDestroyed(): boolean;
 }
 
-export { AGENT_DEFINITION_FORMAT_VERSION, AIError, APPROVAL_STATE_VERSION, Agent, type AgentConfig$1 as AgentConfig, AgentContextNextGen, AgentContextNextGenConfig, type AgentDefinitionListOptions, type AgentDefinitionMetadata, type AgentDefinitionSummary, AgentEvents, type AgentMetrics, type AgentPermissionsConfig, AgentResponse, type AgentSessionConfig, type AgentState, type AgentStatus, type ApprovalCacheEntry, type ApprovalDecision, ApproximateTokenEstimator, AudioFormat, AuditEntry, AuthIdentity, type AuthTemplate, type AuthTemplateField, type BackoffConfig, type BackoffStrategyType, BaseMediaProvider, BasePluginNextGen, BaseProvider, type BaseProviderConfig$1 as BaseProviderConfig, type BaseProviderResponse, BaseTextProvider, type BashResult, type BeforeExecuteResult, BraveProvider, CONNECTOR_CONFIG_VERSION, CUSTOM_TOOL_DEFINITION_VERSION, CheckpointManager, type CheckpointStrategy, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerEvents, type CircuitBreakerMetrics, CircuitOpenError, type CircuitState, type ClipboardImageResult, CompactionContext, CompactionResult, Connector, ConnectorAccessContext, ConnectorAuth, ConnectorConfig, ConnectorConfigResult, ConnectorConfigStore, ConnectorFetchOptions, type ConnectorToolEntry, ConnectorTools, type ConnectorToolsOptions, ConsoleMetrics, ConsolidationResult, Content, ContextBudget$1 as ContextBudget, ContextEvents, ContextFeatures, type ContextManagerConfig, type ContextOverflowBudget, ContextOverflowError, ContextSessionMetadata, ContextSessionSummary, ContextStorageListOptions, type ControlFlowResult, type ControlFlowSource, type ConversationMessage, type CreateConnectorOptions, type CustomToolDefinition, type CustomToolListOptions, type CustomToolMetaToolsOptions, type CustomToolMetadata, type CustomToolSummary, type CustomToolTestCase, DEFAULT_ALLOWLIST, DEFAULT_BACKOFF_CONFIG, DEFAULT_CHECKPOINT_STRATEGY, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_DESKTOP_CONFIG, DEFAULT_FILESYSTEM_CONFIG, DEFAULT_HISTORY_MANAGER_CONFIG, DEFAULT_PERMISSION_CONFIG, DEFAULT_RATE_LIMITER_CONFIG, DEFAULT_SHELL_CONFIG, DESKTOP_TOOL_NAMES, type DefaultAllowlistedTool, DefaultCompactionStrategy, type DefaultCompactionStrategyConfig, DependencyCycleError, type DesktopGetCursorResult, type DesktopGetScreenSizeResult, type DesktopKeyboardKeyArgs, type DesktopKeyboardKeyResult, type DesktopKeyboardTypeArgs, type DesktopKeyboardTypeResult, type DesktopMouseClickArgs, type DesktopMouseClickResult, type DesktopMouseDragArgs, type DesktopMouseDragResult, type DesktopMouseMoveArgs, type DesktopMouseMoveResult, type DesktopMouseScrollArgs, type DesktopMouseScrollResult, type DesktopPoint, type DesktopScreenSize, type DesktopScreenshot, type DesktopScreenshotArgs, type DesktopScreenshotResult, type DesktopToolConfig, type DesktopToolName, type DesktopWindow, type DesktopWindowFocusArgs, type DesktopWindowFocusResult, type DesktopWindowListResult, type DirectCallOptions, type DocumentFamily, type DocumentFormat, type DocumentImagePiece, type DocumentMetadata, type DocumentPiece, type DocumentReadOptions, DocumentReader, type DocumentReaderConfig, type DocumentResult, type DocumentSource, type DocumentTextPiece, type DocumentToContentOptions, type EditFileResult, type ErrorContext, ErrorHandler, type ErrorHandlerConfig, type ErrorHandlerEvents, EventEmitterTrigger, type EvictionStrategy, type ExecuteRoutineOptions, ExecutionContext, ExecutionMetrics, type ExecutionRecorder, type ExecutionRecorderOptions, type ExtendedFetchOptions, type ExternalDependency, type ExternalDependencyEvents, ExternalDependencyHandler, type FetchedContent, FileAgentDefinitionStorage, type FileAgentDefinitionStorageConfig, FileConnectorStorage, type FileConnectorStorageConfig, FileContextStorage, type FileContextStorageConfig, FileCustomToolStorage, type FileCustomToolStorageConfig, FileMediaStorage as FileMediaOutputHandler, FileMediaStorage, type FileMediaStorageConfig, FilePersistentInstructionsStorage, type FilePersistentInstructionsStorageConfig, FileRoutineDefinitionStorage, type FileRoutineDefinitionStorageConfig, FileStorage, type FileStorageConfig, FileUserInfoStorage, type FileUserInfoStorageConfig, type FilesystemToolConfig, type FormatDetectionResult, FormatDetector, FrameworkLogger, FunctionToolDefinition, type GeneratedPlan, type GenericAPICallArgs, type GenericAPICallResult, type GenericAPIToolOptions, type GitHubCreatePRResult, type GitHubGetPRResult, type GitHubPRCommentEntry, type GitHubPRCommentsResult, type GitHubPRFilesResult, type GitHubReadFileResult, type GitHubRepository, type GitHubSearchCodeResult, type GitHubSearchFilesResult, type GlobResult, type GraphDriveItem, type GrepMatch, type GrepResult, type HTTPTransportConfig, type HistoryManagerEvents, type HistoryMessage, HistoryMode, HookConfig, HookName, type HydrateOptions, type IAgentDefinitionStorage, type IAgentStateStorage, type IAgentStorage, type IAsyncDisposable, IBaseModelDescription, type ICapabilityProvider, ICompactionStrategy, IConnectorAccessPolicy, type IConnectorConfigStorage, IConnectorRegistry, type IContextCompactor, type IContextComponent, IContextPluginNextGen, type IContextSnapshot, IContextStorage, type IContextStrategy, type ICustomToolStorage, type IDesktopDriver, type IDisposable, type IDocumentTransformer, type IFormatHandler, type IHistoryManager, type IHistoryManagerConfig, type IHistoryStorage, IImageProvider, type IMCPClient, type IMediaStorage as IMediaOutputHandler, type IMediaStorage, type IMemoryStorage, type IPersistentInstructionsStorage, type IPlanStorage, type IPluginSnapshot, IProvider, type IResearchSource, type IRoutineDefinitionStorage, type IRoutineExecutionStorage, type ISTTModelDescription, type IScheduler, type IScrapeProvider, type ISearchProvider, type ISpeechToTextProvider, type ITTSModelDescription, ITextProvider, type ITextToSpeechProvider, ITokenEstimator$1 as ITokenEstimator, ITokenStorage, type IToolExecutionPipeline, type IToolExecutionPlugin, type IToolExecutor, type IToolSnapshot, type IUserInfoStorage, type IVideoModelDescription, type IVideoProvider, type IViewContextComponent, type IViewContextData, type IVoiceInfo, type ImageFilterOptions, type InContextEntry, type InContextMemoryConfig, InContextMemoryPluginNextGen, type InContextPriority, InMemoryAgentStateStorage, InMemoryHistoryStorage, InMemoryMetrics, InMemoryPlanStorage, InMemoryStorage, InputItem, type InstructionEntry, InvalidConfigError, InvalidToolArgumentsError, type JSONExtractionResult, LLMResponse, type LogEntry, type LogLevel, type LoggerConfig, LoggingPlugin, type LoggingPluginOptions, MCPClient, type MCPClientConnectionState, type MCPClientState, type MCPConfiguration, MCPConnectionError, MCPError, type MCPPrompt, type MCPPromptResult, MCPProtocolError, MCPRegistry, type MCPResource, type MCPResourceContent, MCPResourceError, type MCPServerCapabilities, type MCPServerConfig, MCPTimeoutError, type MCPTool, MCPToolError, type MCPToolResult, type MCPTransportType, type MediaStorageMetadata as MediaOutputMetadata, type MediaStorageResult as MediaOutputResult, type MediaStorageEntry, type MediaStorageListOptions, type MediaStorageMetadata, type MediaStorageResult, type MeetingSlotSuggestion, MemoryConnectorStorage, MemoryEntry, MemoryEvictionCompactor, MemoryIndex, MemoryPriority, MemoryScope, MemoryStorage, MessageBuilder, MessageRole, type MetricTags, type MetricsCollector, type MetricsCollectorType, type MicrosoftCreateMeetingResult, type MicrosoftDraftEmailResult, type MicrosoftEditMeetingResult, type MicrosoftFindSlotsResult, type MicrosoftGetTranscriptResult, type MicrosoftListFilesResult, type MicrosoftReadFileResult, type MicrosoftSearchFilesResult, type MicrosoftSendEmailResult, ModelCapabilities, ModelNotSupportedError, type MouseButton, type EvictionStrategy$1 as NextGenEvictionStrategy, NoOpMetrics, NutTreeDriver, type OAuthConfig, type OAuthFlow, OAuthManager, OutputItem, ParallelTasksError, type PermissionCheckContext, type PermissionCheckResult, type PermissionManagerEvent, type PermissionScope, type PersistentInstructionsConfig, PersistentInstructionsPluginNextGen, type PieceMetadata, type Plan, type PlanConcurrency, type PlanInput, type PlanStatus, PlanningAgent, type PlanningAgentConfig, type PluginExecutionContext, PreparedContext, ProviderAuthError, ProviderCapabilities, ProviderConfigAgent, ProviderContextLengthError, ProviderError, ProviderErrorMapper, ProviderNotFoundError, ProviderRateLimitError, ROUTINE_KEYS, RapidAPIProvider, RateLimitError, type RateLimiterConfig, type RateLimiterMetrics, type ReadFileResult, type FetchOptions as ResearchFetchOptions, type ResearchFinding, type ResearchPlan, type ResearchProgress, type ResearchQuery, type ResearchResult, type SearchOptions as ResearchSearchOptions, type SearchResponse as ResearchSearchResponse, type RiskLevel, type RoutineDefinition, type RoutineDefinitionInput, type RoutineExecution, type RoutineExecutionRecord, type RoutineExecutionStatus, type RoutineExecutionStep, type RoutineParameter, type RoutineStepType, type RoutineTaskResult, type RoutineTaskSnapshot, SIMPLE_ICONS_CDN, type STTModelCapabilities, type STTOptions, type STTOutputFormat$1 as STTOutputFormat, type STTResponse, STT_MODELS, STT_MODEL_REGISTRY, type ScheduleHandle, type ScheduleSpec, ScopedConnectorRegistry, type ScrapeFeature, type ScrapeOptions, ScrapeProvider, type ScrapeProviderConfig, type ScrapeProviderFallbackConfig, type ScrapeResponse, type ScrapeResult, type SearchOptions$1 as SearchOptions, SearchProvider, type SearchProviderConfig, type SearchResponse$1 as SearchResponse, type SearchResult, type SegmentTimestamp, type SerializedApprovalEntry, type SerializedApprovalState, SerializedContextState, type SerializedHistoryState, type SerializedInContextMemoryState, type SerializedPersistentInstructionsState, type SerializedToolState, type SerializedUserInfoState, type SerializedWorkingMemoryState, SerperProvider, ServiceCategory, type ServiceToolFactory, type ShellToolConfig, type SimpleIcon, SimpleScheduler, type SimpleVideoGenerateOptions, type SourceCapabilities, type SourceResult, SpeechToText, type SpeechToTextConfig, type StdioTransportConfig, type StorageConfig, type StorageContext, StorageRegistry, type StoredAgentDefinition, type StoredAgentType, type StoredConnectorConfig, StoredContextSession, type StoredToken, type StrategyInfo, StrategyRegistry, type StrategyRegistryEntry, StreamEvent, StreamEventType, StreamHelpers, StreamState, type SubRoutineSpec, SummarizeCompactor, TERMINAL_TASK_STATUSES, type TTSModelCapabilities, type TTSOptions, type TTSResponse, TTS_MODELS, TTS_MODEL_REGISTRY, type Task, type AgentConfig as TaskAgentStateConfig, type TaskCondition, type TaskControlFlow, type TaskExecution, type TaskFailure, type TaskFoldFlow, type TaskInput, type TaskMapFlow, type TaskSourceRef, type TaskStatus, TaskStatusForMemory, TaskTimeoutError, ToolContext as TaskToolContext, type TaskUntilFlow, type TaskValidation, TaskValidationError, type TaskValidationResult, TavilyProvider, type TemplateCredentials, TextGenerateOptions, TextToSpeech, type TextToSpeechConfig, TokenBucketRateLimiter, type TokenContentType, Tool, ToolCall, type ToolCatalogPluginConfig, ToolCatalogPluginNextGen, type ToolCategory, ToolCategoryScope, type ToolCondition, ToolContext, ToolExecutionError, ToolExecutionPipeline, type ToolExecutionPipelineOptions, ToolFunction, ToolManager, type ToolManagerConfig, type ToolManagerEvent, type ToolManagerStats, type ToolMetadata, ToolNotFoundError, type ToolOptions, type ToolPermissionConfig, ToolPermissionManager, type ToolRegistration, ToolRegistry, type ToolRegistryEntry, ToolResult, type ToolSelectionContext, type ToolSource, ToolTimeoutError, type TransportConfig, TruncateCompactor, type UserInfoEntry, type UserInfoPluginConfig, UserInfoPluginNextGen, VENDOR_ICON_MAP, VIDEO_MODELS, VIDEO_MODEL_REGISTRY, type ValidationContext, Vendor, type VendorInfo, type VendorLogo, VendorOptionSchema, type VendorRegistryEntry, type VendorTemplate, type VideoExtendOptions, type VideoGenerateOptions, VideoGeneration, type VideoGenerationCreateOptions, type VideoJob, type VideoModelCapabilities, type VideoModelPricing, type VideoResponse, type VideoStatus, type WordTimestamp, WorkingMemory, WorkingMemoryAccess, WorkingMemoryConfig, type WorkingMemoryEvents, type WorkingMemoryPluginConfig, WorkingMemoryPluginNextGen, type WriteFileResult, addJitter, allVendorTemplates, assertNotDestroyed, authenticatedFetch, backoffSequence, backoffWait, bash, buildAuthConfig, buildEndpointWithQuery, buildQueryString, calculateBackoff, calculateSTTCost, calculateTTSCost, calculateVideoCost, canTaskExecute, createAgentStorage, createAuthenticatedFetch, createBashTool, createConnectorFromTemplate, createCreatePRTool, createCustomToolDelete, createCustomToolDraft, createCustomToolList, createCustomToolLoad, createCustomToolMetaTools, createCustomToolSave, createCustomToolTest, createDesktopGetCursorTool, createDesktopGetScreenSizeTool, createDesktopKeyboardKeyTool, createDesktopKeyboardTypeTool, createDesktopMouseClickTool, createDesktopMouseDragTool, createDesktopMouseMoveTool, createDesktopMouseScrollTool, createDesktopScreenshotTool, createDesktopWindowFocusTool, createDesktopWindowListTool, createDraftEmailTool, createEditFileTool, createEditMeetingTool, createEstimator, createExecuteJavaScriptTool, createExecutionRecorder, createFileAgentDefinitionStorage, createFileContextStorage, createFileCustomToolStorage, createFileMediaStorage, createFileRoutineDefinitionStorage, createFindMeetingSlotsTool, createGetMeetingTranscriptTool, createGetPRTool, createGitHubReadFileTool, createGlobTool, createGrepTool, createImageGenerationTool, createImageProvider, createListDirectoryTool, createMeetingTool, createMessageWithImages, createMetricsCollector, createMicrosoftListFilesTool, createMicrosoftReadFileTool, createMicrosoftSearchFilesTool, createPRCommentsTool, createPRFilesTool, createPlan, createProvider, createReadFileTool, createRoutineDefinition, createRoutineExecution, createRoutineExecutionRecord, createSearchCodeTool, createSearchFilesTool, createSendEmailTool, createSpeechToTextTool, createTask, createTaskSnapshots, createTextMessage, createTextToSpeechTool, createVideoProvider, createVideoTools, createWriteFileTool, customToolDelete, customToolDraft, customToolList, customToolLoad, customToolSave, customToolTest, desktopGetCursor, desktopGetScreenSize, desktopKeyboardKey, desktopKeyboardType, desktopMouseClick, desktopMouseDrag, desktopMouseMove, desktopMouseScroll, desktopScreenshot, desktopTools, desktopWindowFocus, desktopWindowList, detectDependencyCycle, developerTools, documentToContent, editFile, encodeSharingUrl, evaluateCondition, executeRoutine, extractJSON, extractJSONField, extractNumber, findConnectorByServiceTypes, formatAttendees, formatFileSize, formatPluginDisplayName, formatRecipients, generateEncryptionKey, generateSimplePlan, generateWebAPITool, getActiveSTTModels, getActiveTTSModels, getActiveVideoModels, getAllBuiltInTools, getAllVendorLogos, getAllVendorTemplates, getBackgroundOutput, getConnectorTools, getCredentialsSetupURL, getDesktopDriver, getDocsURL, getDrivePrefix, getMediaOutputHandler, getMediaStorage, getNextExecutableTasks, getRegisteredScrapeProviders, getRoutineProgress, getSTTModelInfo, getSTTModelsByVendor, getSTTModelsWithFeature, getTTSModelInfo, getTTSModelsByVendor, getTTSModelsWithFeature, getTaskDependencies, getToolByName, getToolCategories, getToolRegistry, getToolsByCategory, getToolsRequiringConnector, getUserPathPrefix, getVendorAuthTemplate, getVendorColor, getVendorDefaultBaseURL, getVendorInfo, getVendorLogo, getVendorLogoCdnUrl, getVendorLogoSvg, getVendorTemplate, getVideoModelInfo, getVideoModelsByVendor, getVideoModelsWithAudio, getVideoModelsWithFeature, glob, globalErrorHandler, grep, hasClipboardImage, hasVendorLogo, hydrateCustomTool, isBlockedCommand, isExcludedExtension, isMicrosoftFileUrl, isTaskBlocked, isTeamsMeetingUrl, isTerminalStatus, isWebUrl, killBackgroundProcess, listConnectorsByServiceTypes, listDirectory, listVendorIds, listVendors, listVendorsByAuthType, listVendorsByCategory, listVendorsWithLogos, logger, mergeTextPieces, metrics, microsoftFetch, normalizeEmails, parseKeyCombo, parseRepository, readClipboardImage, readDocumentAsContent, readFile, registerScrapeProvider, resetDefaultDriver, resolveConnector, resolveDependencies, resolveFileEndpoints, resolveFlowSource, resolveMaxContextTokens, resolveMeetingId, resolveModelCapabilities, resolveRepository, resolveTemplates, retryWithBackoff, sanitizeToolName, setMediaOutputHandler, setMediaStorage, setMetricsCollector, simpleTokenEstimator, toConnectorOptions, toolRegistry, index as tools, updateTaskStatus, validatePath, writeFile };
+export { AGENT_DEFINITION_FORMAT_VERSION, AIError, APPROVAL_STATE_VERSION, Agent, type AgentConfig$1 as AgentConfig, AgentContextNextGen, AgentContextNextGenConfig, type AgentDefinitionListOptions, type AgentDefinitionMetadata, type AgentDefinitionSummary, AgentEvents, type AgentMetrics, type AgentPermissionsConfig, AgentResponse, type AgentSessionConfig, type AgentState, type AgentStatus, type ApprovalCacheEntry, type ApprovalDecision, ApproximateTokenEstimator, type AudioChunkPlaybackCallback, AudioChunkReadyEvent, AudioFormat, AudioPlaybackQueue, AuditEntry, AuthIdentity, type AuthTemplate, type AuthTemplateField, type BackoffConfig, type BackoffStrategyType, BaseMediaProvider, BasePluginNextGen, BaseProvider, type BaseProviderConfig$1 as BaseProviderConfig, type BaseProviderResponse, BaseTextProvider, type BashResult, type BeforeExecuteResult, BraveProvider, CONNECTOR_CONFIG_VERSION, CUSTOM_TOOL_DEFINITION_VERSION, CheckpointManager, type CheckpointStrategy, type ChunkingOptions, CircuitBreaker, type CircuitBreakerConfig, type CircuitBreakerEvents, type CircuitBreakerMetrics, CircuitOpenError, type CircuitState, type ClipboardImageResult, CompactionContext, CompactionResult, Connector, ConnectorAccessContext, ConnectorAuth, ConnectorConfig, ConnectorConfigResult, ConnectorConfigStore, ConnectorFetchOptions, type ConnectorToolEntry, ConnectorTools, type ConnectorToolsOptions, ConsoleMetrics, ConsolidationResult, Content, ContextBudget$1 as ContextBudget, ContextEvents, ContextFeatures, type ContextManagerConfig, type ContextOverflowBudget, ContextOverflowError, ContextSessionMetadata, ContextSessionSummary, ContextStorageListOptions, type ControlFlowResult, type ControlFlowSource, type ConversationMessage, type CreateConnectorOptions, type CustomToolDefinition, type CustomToolListOptions, type CustomToolMetaToolsOptions, type CustomToolMetadata, type CustomToolSummary, type CustomToolTestCase, DEFAULT_ALLOWLIST, DEFAULT_BACKOFF_CONFIG, DEFAULT_CHECKPOINT_STRATEGY, DEFAULT_CIRCUIT_BREAKER_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_DESKTOP_CONFIG, DEFAULT_FILESYSTEM_CONFIG, DEFAULT_HISTORY_MANAGER_CONFIG, DEFAULT_PERMISSION_CONFIG, DEFAULT_RATE_LIMITER_CONFIG, DEFAULT_SHELL_CONFIG, DESKTOP_TOOL_NAMES, type DefaultAllowlistedTool, DefaultCompactionStrategy, type DefaultCompactionStrategyConfig, DependencyCycleError, type DesktopGetCursorResult, type DesktopGetScreenSizeResult, type DesktopKeyboardKeyArgs, type DesktopKeyboardKeyResult, type DesktopKeyboardTypeArgs, type DesktopKeyboardTypeResult, type DesktopMouseClickArgs, type DesktopMouseClickResult, type DesktopMouseDragArgs, type DesktopMouseDragResult, type DesktopMouseMoveArgs, type DesktopMouseMoveResult, type DesktopMouseScrollArgs, type DesktopMouseScrollResult, type DesktopPoint, type DesktopScreenSize, type DesktopScreenshot, type DesktopScreenshotArgs, type DesktopScreenshotResult, type DesktopToolConfig, type DesktopToolName, type DesktopWindow, type DesktopWindowFocusArgs, type DesktopWindowFocusResult, type DesktopWindowListResult, type DirectCallOptions, type DocumentFamily, type DocumentFormat, type DocumentImagePiece, type DocumentMetadata, type DocumentPiece, type DocumentReadOptions, DocumentReader, type DocumentReaderConfig, type DocumentResult, type DocumentSource, type DocumentTextPiece, type DocumentToContentOptions, type EditFileResult, type ErrorContext, ErrorHandler, type ErrorHandlerConfig, type ErrorHandlerEvents, EventEmitterTrigger, type EvictionStrategy, type ExecuteRoutineOptions, ExecutionContext, ExecutionMetrics, type ExecutionRecorder, type ExecutionRecorderOptions, type ExtendedFetchOptions, type ExternalDependency, type ExternalDependencyEvents, ExternalDependencyHandler, type FetchedContent, FileAgentDefinitionStorage, type FileAgentDefinitionStorageConfig, FileConnectorStorage, type FileConnectorStorageConfig, FileContextStorage, type FileContextStorageConfig, FileCustomToolStorage, type FileCustomToolStorageConfig, FileHistoryJournal, FileMediaStorage as FileMediaOutputHandler, FileMediaStorage, type FileMediaStorageConfig, FilePersistentInstructionsStorage, type FilePersistentInstructionsStorageConfig, FileRoutineDefinitionStorage, type FileRoutineDefinitionStorageConfig, FileRoutineExecutionStorage, type FileRoutineExecutionStorageConfig, FileStorage, type FileStorageConfig, FileUserInfoStorage, type FileUserInfoStorageConfig, type FilesystemToolConfig, type FormatDetectionResult, FormatDetector, FrameworkLogger, FunctionToolDefinition, type GeneratedPlan, type GenericAPICallArgs, type GenericAPICallResult, type GenericAPIToolOptions, type GitHubBranchEntry, type GitHubCreatePRResult, type GitHubGetPRResult, type GitHubListBranchesResult, type GitHubPRCommentEntry, type GitHubPRCommentsResult, type GitHubPRFilesResult, type GitHubReadFileResult, type GitHubRepository, type GitHubSearchCodeResult, type GitHubSearchFilesResult, type GlobResult, type GraphDriveItem, type GrepMatch, type GrepResult, type HTTPTransportConfig, HistoryEntry, type HistoryManagerEvents, type HistoryMessage, HistoryMode, HistoryReadOptions, HookConfig, HookName, type HydrateOptions, type IAgentDefinitionStorage, type IAgentStateStorage, type IAgentStorage, type IAsyncDisposable, IBaseModelDescription, type ICapabilityProvider, type IChunkingStrategy, ICompactionStrategy, IConnectorAccessPolicy, type IConnectorConfigStorage, IConnectorRegistry, type IContextCompactor, type IContextComponent, IContextPluginNextGen, type IContextSnapshot, IContextStorage, type IContextStrategy, type ICustomToolStorage, type IDesktopDriver, type IDisposable, type IDocumentTransformer, type IFormatHandler, IHistoryJournal, type IHistoryManager, type IHistoryManagerConfig, type IHistoryStorage, IImageProvider, type IMCPClient, type IMediaStorage as IMediaOutputHandler, type IMediaStorage, type IMemoryStorage, type IPersistentInstructionsStorage, type IPlanStorage, type IPluginSnapshot, IProvider, type IResearchSource, type IRoutineDefinitionStorage, type IRoutineExecutionStorage, type ISTTModelDescription, type IScheduler, type IScrapeProvider, type ISearchProvider, type ISpeechToTextProvider, type IStreamingTextToSpeechProvider, type ITTSModelDescription, ITextProvider, type ITextToSpeechProvider, ITokenEstimator$1 as ITokenEstimator, ITokenStorage, type IToolExecutionPipeline, type IToolExecutionPlugin, type IToolExecutor, type IToolSnapshot, type IUserInfoStorage, type IVideoModelDescription, type IVideoProvider, type IViewContextComponent, type IViewContextData, type IVoiceInfo, type ImageFilterOptions, type InContextEntry, type InContextMemoryConfig, InContextMemoryPluginNextGen, type InContextPriority, InMemoryAgentStateStorage, InMemoryHistoryStorage, InMemoryMetrics, InMemoryPlanStorage, InMemoryStorage, InputItem, type InstructionEntry, InvalidConfigError, InvalidToolArgumentsError, type JSONExtractionResult, LLMResponse, type LogEntry, type LogLevel, type LoggerConfig, LoggingPlugin, type LoggingPluginOptions, MCPClient, type MCPClientConnectionState, type MCPClientState, type MCPConfiguration, MCPConnectionError, MCPError, type MCPPrompt, type MCPPromptResult, MCPProtocolError, MCPRegistry, type MCPResource, type MCPResourceContent, MCPResourceError, type MCPServerCapabilities, type MCPServerConfig, MCPTimeoutError, type MCPTool, MCPToolError, type MCPToolResult, type MCPTransportType, type MediaStorageMetadata as MediaOutputMetadata, type MediaStorageResult as MediaOutputResult, type MediaStorageEntry, type MediaStorageListOptions, type MediaStorageMetadata, type MediaStorageResult, type MeetingSlotSuggestion, MemoryConnectorStorage, MemoryEntry, MemoryEvictionCompactor, MemoryIndex, MemoryPriority, MemoryScope, MemoryStorage, MessageBuilder, MessageRole, type MetricTags, type MetricsCollector, type MetricsCollectorType, type MicrosoftCreateMeetingResult, type MicrosoftDraftEmailResult, type MicrosoftEditMeetingResult, type MicrosoftFindSlotsResult, type MicrosoftGetTranscriptResult, type MicrosoftListFilesResult, type MicrosoftReadFileResult, type MicrosoftSearchFilesResult, type MicrosoftSendEmailResult, ModelCapabilities, ModelNotSupportedError, type MouseButton, type EvictionStrategy$1 as NextGenEvictionStrategy, NoOpMetrics, NutTreeDriver, type OAuthConfig, type OAuthFlow, OAuthManager, OutputItem, ParallelTasksError, type PermissionCheckContext, type PermissionCheckResult, type PermissionManagerEvent, type PermissionScope, type PersistentInstructionsConfig, PersistentInstructionsPluginNextGen, type PieceMetadata, type Plan, type PlanConcurrency, type PlanInput, type PlanStatus, PlanningAgent, type PlanningAgentConfig, type PluginExecutionContext, PreparedContext, ProviderAuthError, ProviderCapabilities, ProviderConfigAgent, ProviderContextLengthError, ProviderError, ProviderErrorMapper, ProviderNotFoundError, ProviderRateLimitError, ROUTINE_KEYS, RapidAPIProvider, RateLimitError, type RateLimiterConfig, type RateLimiterMetrics, type ReadFileResult, type FetchOptions as ResearchFetchOptions, type ResearchFinding, type ResearchPlan, type ResearchProgress, type ResearchQuery, type ResearchResult, type SearchOptions as ResearchSearchOptions, type SearchResponse as ResearchSearchResponse, type RiskLevel, type RoutineDefinition, type RoutineDefinitionInput, type RoutineExecution, type RoutineExecutionRecord, type RoutineExecutionStatus, type RoutineExecutionStep, type RoutineParameter, type RoutineStepType, type RoutineTaskResult, type RoutineTaskSnapshot, SIMPLE_ICONS_CDN, type STTModelCapabilities, type STTOptions, type STTOutputFormat$1 as STTOutputFormat, type STTResponse, STT_MODELS, STT_MODEL_REGISTRY, type ScheduleHandle, type ScheduleSpec, ScopedConnectorRegistry, type ScrapeFeature, type ScrapeOptions, ScrapeProvider, type ScrapeProviderConfig, type ScrapeProviderFallbackConfig, type ScrapeResponse, type ScrapeResult, type SearchOptions$1 as SearchOptions, SearchProvider, type SearchProviderConfig, type SearchResponse$1 as SearchResponse, type SearchResult, type SegmentTimestamp, SentenceChunkingStrategy, type SerializedApprovalEntry, type SerializedApprovalState, SerializedContextState, type SerializedHistoryState, type SerializedInContextMemoryState, type SerializedPersistentInstructionsState, type SerializedToolState, type SerializedUserInfoState, type SerializedWorkingMemoryState, SerperProvider, ServiceCategory, type ServiceToolFactory, type ShellToolConfig, type SimpleIcon, SimpleScheduler, type SimpleVideoGenerateOptions, type SourceCapabilities, type SourceResult, SpeechToText, type SpeechToTextConfig, type StdioTransportConfig, type StorageConfig, type StorageContext, StorageRegistry, type StoredAgentDefinition, type StoredAgentType, type StoredConnectorConfig, StoredContextSession, type StoredToken, type StrategyInfo, StrategyRegistry, type StrategyRegistryEntry, StreamEvent, StreamEventType, StreamHelpers, StreamState, type SubRoutineSpec, SummarizeCompactor, TERMINAL_TASK_STATUSES, type TTSModelCapabilities, type TTSOptions, type TTSResponse, type TTSStreamChunk, TTS_MODELS, TTS_MODEL_REGISTRY, type Task, type AgentConfig as TaskAgentStateConfig, type TaskCondition, type TaskControlFlow, type TaskExecution, type TaskFailure, type TaskFoldFlow, type TaskInput, type TaskMapFlow, type TaskSourceRef, type TaskStatus, TaskStatusForMemory, TaskTimeoutError, ToolContext as TaskToolContext, type TaskUntilFlow, type TaskValidation, TaskValidationError, type TaskValidationResult, TavilyProvider, type TemplateCredentials, TextGenerateOptions, TextToSpeech, type TextToSpeechConfig, TokenBucketRateLimiter, type TokenContentType, Tool, ToolCall, type ToolCatalogPluginConfig, ToolCatalogPluginNextGen, type ToolCategory, ToolCategoryScope, type ToolCondition, ToolContext, ToolExecutionError, ToolExecutionPipeline, type ToolExecutionPipelineOptions, ToolFunction, ToolManager, type ToolManagerConfig, type ToolManagerEvent, type ToolManagerStats, type ToolMetadata, ToolNotFoundError, type ToolOptions, type ToolPermissionConfig, ToolPermissionManager, type ToolRegistration, ToolRegistry, type ToolRegistryEntry, ToolResult, type ToolSelectionContext, type ToolSource, ToolTimeoutError, type TransportConfig, TruncateCompactor, type UserInfoEntry, type UserInfoPluginConfig, UserInfoPluginNextGen, VENDOR_ICON_MAP, VIDEO_MODELS, VIDEO_MODEL_REGISTRY, type ValidationContext, Vendor, type VendorInfo, type VendorLogo, VendorOptionSchema, type VendorRegistryEntry, type VendorTemplate, type VideoExtendOptions, type VideoGenerateOptions, VideoGeneration, type VideoGenerationCreateOptions, type VideoJob, type VideoModelCapabilities, type VideoModelPricing, type VideoResponse, type VideoStatus, VoiceStream, type VoiceStreamConfig, type VoiceStreamEvents, type WordTimestamp, WorkingMemory, WorkingMemoryAccess, WorkingMemoryConfig, type WorkingMemoryEvents, type WorkingMemoryPluginConfig, WorkingMemoryPluginNextGen, type WriteFileResult, addJitter, allVendorTemplates, assertNotDestroyed, authenticatedFetch, backoffSequence, backoffWait, bash, buildAuthConfig, buildEndpointWithQuery, buildQueryString, calculateBackoff, calculateSTTCost, calculateTTSCost, calculateVideoCost, canTaskExecute, createAgentStorage, createAuthenticatedFetch, createBashTool, createConnectorFromTemplate, createCreatePRTool, createCustomToolDelete, createCustomToolDraft, createCustomToolList, createCustomToolLoad, createCustomToolMetaTools, createCustomToolSave, createCustomToolTest, createDesktopGetCursorTool, createDesktopGetScreenSizeTool, createDesktopKeyboardKeyTool, createDesktopKeyboardTypeTool, createDesktopMouseClickTool, createDesktopMouseDragTool, createDesktopMouseMoveTool, createDesktopMouseScrollTool, createDesktopScreenshotTool, createDesktopWindowFocusTool, createDesktopWindowListTool, createDraftEmailTool, createEditFileTool, createEditMeetingTool, createEstimator, createExecuteJavaScriptTool, createExecutionRecorder, createFileAgentDefinitionStorage, createFileContextStorage, createFileCustomToolStorage, createFileMediaStorage, createFileRoutineDefinitionStorage, createFileRoutineExecutionStorage, createFindMeetingSlotsTool, createGetMeetingTranscriptTool, createGetPRTool, createGitHubReadFileTool, createGlobTool, createGrepTool, createImageGenerationTool, createImageProvider, createListBranchesTool, createListDirectoryTool, createMeetingTool, createMessageWithImages, createMetricsCollector, createMicrosoftListFilesTool, createMicrosoftReadFileTool, createMicrosoftSearchFilesTool, createPRCommentsTool, createPRFilesTool, createPlan, createProvider, createReadFileTool, createRoutineDefinition, createRoutineExecution, createRoutineExecutionRecord, createSearchCodeTool, createSearchFilesTool, createSendEmailTool, createSpeechToTextTool, createTask, createTaskSnapshots, createTextMessage, createTextToSpeechTool, createVideoProvider, createVideoTools, createWriteFileTool, customToolDelete, customToolDraft, customToolList, customToolLoad, customToolSave, customToolTest, desktopGetCursor, desktopGetScreenSize, desktopKeyboardKey, desktopKeyboardType, desktopMouseClick, desktopMouseDrag, desktopMouseMove, desktopMouseScroll, desktopScreenshot, desktopTools, desktopWindowFocus, desktopWindowList, detectDependencyCycle, developerTools, documentToContent, editFile, encodeSharingUrl, evaluateCondition, executeRoutine, extractJSON, extractJSONField, extractNumber, findConnectorByServiceTypes, formatAttendees, formatFileSize, formatPluginDisplayName, formatRecipients, generateEncryptionKey, generateSimplePlan, generateWebAPITool, getActiveSTTModels, getActiveTTSModels, getActiveVideoModels, getAllBuiltInTools, getAllVendorLogos, getAllVendorTemplates, getBackgroundOutput, getConnectorTools, getCredentialsSetupURL, getDesktopDriver, getDocsURL, getDrivePrefix, getMediaOutputHandler, getMediaStorage, getNextExecutableTasks, getRegisteredScrapeProviders, getRoutineProgress, getSTTModelInfo, getSTTModelsByVendor, getSTTModelsWithFeature, getTTSModelInfo, getTTSModelsByVendor, getTTSModelsWithFeature, getTaskDependencies, getToolByName, getToolCategories, getToolRegistry, getToolsByCategory, getToolsRequiringConnector, getUserPathPrefix, getVendorAuthTemplate, getVendorColor, getVendorDefaultBaseURL, getVendorInfo, getVendorLogo, getVendorLogoCdnUrl, getVendorLogoSvg, getVendorTemplate, getVideoModelInfo, getVideoModelsByVendor, getVideoModelsWithAudio, getVideoModelsWithFeature, glob, globalErrorHandler, grep, hasClipboardImage, hasVendorLogo, hydrateCustomTool, isBlockedCommand, isExcludedExtension, isMicrosoftFileUrl, isTaskBlocked, isTeamsMeetingUrl, isTerminalStatus, isWebUrl, killBackgroundProcess, listConnectorsByServiceTypes, listDirectory, listVendorIds, listVendors, listVendorsByAuthType, listVendorsByCategory, listVendorsWithLogos, logger, mergeTextPieces, metrics, microsoftFetch, normalizeEmails, parseKeyCombo, parseRepository, readClipboardImage, readDocumentAsContent, readFile, registerScrapeProvider, resetDefaultDriver, resolveConnector, resolveDependencies, resolveFileEndpoints, resolveFlowSource, resolveMaxContextTokens, resolveMeetingId, resolveModelCapabilities, resolveRepository, resolveTemplates, retryWithBackoff, sanitizeToolName, setMediaOutputHandler, setMediaStorage, setMetricsCollector, simpleTokenEstimator, toConnectorOptions, toolRegistry, index as tools, updateTaskStatus, validatePath, writeFile };