art-framework 0.3.2 → 0.3.3

package/dist/index.d.cts

@@ -2875,7 +2875,7 @@ interface IToolExecutor {
 /**
  * Interface for managing the registration and retrieval of tools.
  */
-interface ToolRegistry {
+interface ToolRegistry$1 {
     /**
      * Registers a tool executor instance, making it available for use.
      * @param executor - The instance of the class implementing `IToolExecutor`.
@@ -2924,7 +2924,7 @@ interface ToolSystem {
 /**
  * Interface for managing thread-specific configuration and state.
  */
-interface StateManager {
+interface StateManager$1 {
     /**
      * Loads the complete context (`ThreadConfig` and `AgentState`) for a specific thread.
      * This is typically called at the beginning of an agent execution cycle.
@@ -3082,7 +3082,7 @@ interface ITypedSocket<DataType, FilterType = any> {
 /**
  * Interface for the system providing access to UI communication sockets.
  */
-interface UISystem {
+interface UISystem$1 {
     /** Returns the singleton instance of the ObservationSocket. */
     getObservationSocket(): ObservationSocket;
     /** Returns the singleton instance of the ConversationSocket. */
@@ -3240,13 +3240,13 @@ interface ArtInstance {
     /** The main method to process a user query using the configured Agent Core. */
     readonly process: IAgentCore['process'];
     /** Accessor for the UI System, used to get sockets for subscriptions. */
-    readonly uiSystem: UISystem;
+    readonly uiSystem: UISystem$1;
     /** Accessor for the State Manager, used for managing thread configuration and state. */
-    readonly stateManager: StateManager;
+    readonly stateManager: StateManager$1;
     /** Accessor for the Conversation Manager, used for managing message history. */
     readonly conversationManager: ConversationManager;
     /** Accessor for the Tool Registry, used for managing available tools. */
-    readonly toolRegistry: ToolRegistry;
+    readonly toolRegistry: ToolRegistry$1;
     /** Accessor for the Observation Manager, used for recording and retrieving observations. */
     readonly observationManager: ObservationManager;
     /** Accessor for the Auth Manager, used for handling authentication. */
@@ -3375,7 +3375,7 @@ declare class McpManager {
      * @param _stateManager The state manager (not currently used).
      * @param authManager The authentication manager.
      */
-    constructor(toolRegistry: ToolRegistry, _stateManager: StateManager, authManager?: AuthManager);
+    constructor(toolRegistry: ToolRegistry$1, _stateManager: StateManager$1, authManager?: AuthManager);
     /**
      * Initializes the McpManager, discovers and registers tools from configured servers.
      *
@@ -3664,7 +3664,7 @@ declare class TaskDelegationService {
 
 interface PESAgentDependencies {
     /** Manages thread configuration and state. */
-    stateManager: StateManager;
+    stateManager: StateManager$1;
     /**
      * Optional default system prompt string provided at the ART instance level.
      * This serves as a custom prompt part if no thread-specific or call-specific
@@ -3673,7 +3673,7 @@ interface PESAgentDependencies {
     /** Manages conversation history. */
     conversationManager: ConversationManager;
     /** Registry for available tools. */
-    toolRegistry: ToolRegistry;
+    toolRegistry: ToolRegistry$1;
     /** Handles interaction with the LLM provider. */
     reasoningEngine: ReasoningEngine;
     /** Parses LLM responses. */
@@ -3683,7 +3683,7 @@ interface PESAgentDependencies {
     /** Orchestrates tool execution. */
     toolSystem: ToolSystem;
     /** Provides access to UI communication sockets. */
-    uiSystem: UISystem;
+    uiSystem: UISystem$1;
     /** Repository for A2A tasks. */
     a2aTaskRepository: IA2ATaskRepository;
     /** Service for discovering A2A agents. */
@@ -4539,6 +4539,44 @@ declare class CalculatorTool implements IToolExecutor {
     execute(input: any, context: ExecutionContext): Promise<ToolResult>;
 }
 
+/**
+ * Provides access to the UI communication sockets (Observation, Conversation, LLM Stream, and A2A Task).
+ * Instantiates the sockets with their required dependencies.
+ */
+declare class UISystem implements UISystem$1 {
+    private observationSocketInstance;
+    private conversationSocketInstance;
+    private llmStreamSocketInstance;
+    private a2aTaskSocketInstance;
+    /**
+     * Creates an instance of UISystem.
+     * @param observationRepository - Repository for observation data, passed to ObservationSocket.
+     * @param conversationRepository - Repository for conversation data, passed to ConversationSocket.
+     * @param a2aTaskRepository - Optional repository for A2A task data, passed to A2ATaskSocket.
+     */
+    constructor(observationRepository: IObservationRepository, conversationRepository: IConversationRepository, a2aTaskRepository?: IA2ATaskRepository);
+    /**
+     * Gets the singleton instance of the ObservationSocket.
+     * @returns The ObservationSocket instance.
+     */
+    getObservationSocket(): ObservationSocket;
+    /**
+     * Gets the singleton instance of the ConversationSocket.
+     * @returns The ConversationSocket instance.
+     */
+    getConversationSocket(): ConversationSocket;
+    /**
+     * Gets the singleton instance of the LLMStreamSocket.
+     * @returns The LLMStreamSocket instance.
+     */
+    getLLMStreamSocket(): LLMStreamSocket;
+    /**
+     * Gets the singleton instance of the A2ATaskSocket.
+     * @returns The A2ATaskSocket instance.
+     */
+    getA2ATaskSocket(): A2ATaskSocket;
+}
+
 /**
  * Configuration for the PKCE OAuth 2.0 authentication strategy.
  */
@@ -4631,6 +4669,234 @@ declare class PKCEOAuthStrategy implements IAuthStrategy {
     private exchangeCodeForToken;
 }
 
+/**
+ * Simple API key authentication strategy.
+ * Supports configurable header names for different service requirements.
+ */
+declare class ApiKeyStrategy implements IAuthStrategy {
+    private readonly apiKey;
+    private readonly headerName;
+    /**
+     * Creates a new API key authentication strategy.
+     * @param apiKey - The API key to use for authentication
+     * @param headerName - The header name to use (defaults to 'Authorization')
+     */
+    constructor(apiKey: string, headerName?: string);
+    /**
+     * Generates authentication headers for API key-based authentication.
+     * Uses Bearer token format for Authorization header, plain key for custom headers.
+     * @returns Promise resolving to authentication headers
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Gets the configured header name for this strategy.
+     * @returns The header name that will be used
+     */
+    getHeaderName(): string;
+    /**
+     * Checks if this strategy uses the standard Authorization header.
+     * @returns True if using Authorization header, false for custom headers
+     */
+    isUsingAuthorizationHeader(): boolean;
+}
+
+/**
+ * Configuration for OAuth 2.0 authentication strategy
+ */
+interface OAuthConfig {
+    /** Client ID for OAuth authentication */
+    clientId: string;
+    /** Client secret for OAuth authentication */
+    clientSecret: string;
+    /** OAuth token endpoint URL */
+    tokenEndpoint: string;
+    /** OAuth scopes to request (space-separated) */
+    scopes?: string;
+    /** Grant type to use (defaults to 'client_credentials') */
+    grantType?: 'client_credentials' | 'authorization_code' | 'refresh_token';
+    /** Additional headers to send with token requests */
+    tokenRequestHeaders?: Record<string, string>;
+    /** Custom timeout for token requests in milliseconds (default: 30000) */
+    tokenTimeoutMs?: number;
+    /** Buffer time before token expiry to trigger refresh (default: 300000 = 5 minutes) */
+    tokenRefreshBufferMs?: number;
+}
+/**
+ * Generic OAuth 2.0 authentication strategy with token caching and refresh capabilities.
+ * Supports client credentials flow and authorization code flow with automatic token refresh.
+ * @deprecated This strategy is not recommended for browser-based applications as it uses the insecure client_credentials grant type. Please use PKCEOAuthStrategy instead.
+ */
+declare class GenericOAuthStrategy implements IAuthStrategy {
+    private config;
+    private cachedToken;
+    private refreshPromise;
+    /**
+     * Creates a new OAuth authentication strategy.
+     * @param {OAuthConfig} config - OAuth configuration including endpoints, credentials, and options
+     */
+    constructor(config: OAuthConfig);
+    /**
+     * Validates the OAuth configuration to ensure required fields are present.
+     * @param {OAuthConfig} config - The OAuth configuration to validate.
+     * @throws {ARTError} If the configuration is invalid.
+     */
+    private validateConfig;
+    /**
+     * Gets authentication headers, automatically handling token refresh if needed.
+     * @returns {Promise<Record<string, string>>} A promise that resolves to the authentication headers.
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Gets a valid access token, refreshing if necessary.
+     * @returns {Promise<CachedToken>} A promise that resolves to a valid cached token.
+     */
+    private getValidToken;
+    /**
+     * Checks if a token is still valid (not expired with buffer).
+     * @param {CachedToken} token - The token to validate.
+     * @returns {boolean} True if the token is valid, false otherwise.
+     */
+    private isTokenValid;
+    /**
+     * Acquires a new token from the OAuth provider.
+     * @returns {Promise<CachedToken>} A promise that resolves to a new cached token.
+     */
+    private acquireNewToken;
+    /**
+     * Builds the token request configuration based on grant type.
+     * @returns {RequestInit} The request initialization object for the token request.
+     */
+    private buildTokenRequest;
+    /**
+     * Processes the token response and creates a cached token object.
+     * @param {TokenResponse} response - The token response from the provider.
+     * @returns {CachedToken} The processed and cached token.
+     */
+    private processTokenResponse;
+    /**
+     * Manually refreshes the cached token.
+     * @returns {Promise<Record<string, string>>} A promise that resolves to new authentication headers.
+     */
+    refreshToken(): Promise<Record<string, string>>;
+    /**
+     * Clears the cached token, forcing a new token request on next use.
+     */
+    clearTokenCache(): void;
+    /**
+     * Gets information about the current cached token.
+     * @returns {{ expiresAt: Date; scope?: string; hasRefreshToken: boolean } | null} Token information or null if no token is cached.
+     */
+    getTokenInfo(): {
+        expiresAt: Date;
+        scope?: string;
+        hasRefreshToken: boolean;
+    } | null;
+    /**
+     * Gets the configured OAuth endpoints and settings.
+     * @returns {Omit<OAuthConfig, 'clientSecret'>} Configuration information (excluding sensitive data).
+     */
+    getConfig(): Omit<OAuthConfig, 'clientSecret'>;
+}
+
+/**
+ * Configuration specific to Zyntopia OAuth strategy
+ */
+interface ZyntopiaOAuthConfig {
+    /** Client ID for Zyntopia OAuth authentication */
+    clientId: string;
+    /** Client secret for Zyntopia OAuth authentication */
+    clientSecret: string;
+    /** Optional custom token endpoint (defaults to Zyntopia's standard endpoint) */
+    tokenEndpoint?: string;
+    /** Optional custom scopes (defaults to Zyntopia's standard scopes) */
+    scopes?: string;
+    /** Optional environment ('production' | 'staging' | 'development') */
+    environment?: 'production' | 'staging' | 'development';
+    /** Optional custom timeout for token requests in milliseconds */
+    tokenTimeoutMs?: number;
+    /** Optional custom buffer time before token expiry to trigger refresh */
+    tokenRefreshBufferMs?: number;
+    /** Additional custom headers for Zyntopia API requirements */
+    customHeaders?: Record<string, string>;
+}
+/**
+ * Zyntopia-specific OAuth 2.0 authentication strategy.
+ * Pre-configured for Zyntopia services with standard endpoints, scopes, and authentication flows.
+ * Extends GenericOAuthStrategy with Zyntopia-specific defaults and configurations.
+ */
+declare class ZyntopiaOAuthStrategy extends GenericOAuthStrategy {
+    private static readonly ZYNTOPIA_ENDPOINTS;
+    private static readonly ZYNTOPIA_DEFAULT_SCOPES;
+    private zyntopiaConfig;
+    /**
+     * Creates a new Zyntopia OAuth authentication strategy.
+     * @param {ZyntopiaOAuthConfig} config - Zyntopia-specific OAuth configuration
+     */
+    constructor(config: ZyntopiaOAuthConfig);
+    /**
+     * Gets the Zyntopia-specific configuration.
+     * @returns {Omit<ZyntopiaOAuthConfig, 'clientSecret'>} Zyntopia configuration (excluding sensitive data).
+     */
+    getZyntopiaConfig(): Omit<ZyntopiaOAuthConfig, 'clientSecret'>;
+    /**
+     * Gets the current environment this strategy is configured for.
+     * @returns {'production' | 'staging' | 'development'} The environment ('production', 'staging', or 'development').
+     */
+    getEnvironment(): 'production' | 'staging' | 'development';
+    /**
+     * Checks if this strategy is configured for production environment.
+     * @returns {boolean} True if configured for production, false otherwise.
+     */
+    isProduction(): boolean;
+    /**
+     * Checks if this strategy is configured for development/testing.
+     * @returns {boolean} True if configured for development or staging, false for production.
+     */
+    isDevelopment(): boolean;
+    /**
+     * Creates a ZyntopiaOAuthStrategy instance pre-configured for production.
+     * @param {string} clientId - Zyntopia client ID
+     * @param {string} clientSecret - Zyntopia client secret
+     * @param {string} [customScopes] - Optional custom scopes (defaults to production scopes)
+     * @returns {ZyntopiaOAuthStrategy} Configured ZyntopiaOAuthStrategy for production.
+     */
+    static forProduction(clientId: string, clientSecret: string, customScopes?: string): ZyntopiaOAuthStrategy;
+    /**
+     * Creates a ZyntopiaOAuthStrategy instance pre-configured for staging.
+     * @param {string} clientId - Zyntopia client ID
+     * @param {string} clientSecret - Zyntopia client secret
+     * @param {string} [customScopes] - Optional custom scopes (defaults to staging scopes)
+     * @returns {ZyntopiaOAuthStrategy} Configured ZyntopiaOAuthStrategy for staging.
+     */
+    static forStaging(clientId: string, clientSecret: string, customScopes?: string): ZyntopiaOAuthStrategy;
+    /**
+     * Creates a ZyntopiaOAuthStrategy instance pre-configured for development.
+     * @param {string} clientId - Zyntopia client ID
+     * @param {string} clientSecret - Zyntopia client secret
+     * @param {string} [customScopes] - Optional custom scopes (defaults to development scopes)
+     * @returns {ZyntopiaOAuthStrategy} Configured ZyntopiaOAuthStrategy for development.
+     */
+    static forDevelopment(clientId: string, clientSecret: string, customScopes?: string): ZyntopiaOAuthStrategy;
+    /**
+     * Gets the default scopes for a specific environment.
+     * @param {'production' | 'staging' | 'development'} environment - The environment to get scopes for
+     * @returns {string} Default scopes for the specified environment.
+     */
+    static getDefaultScopes(environment: 'production' | 'staging' | 'development'): string;
+    /**
+     * Gets the token endpoint for a specific environment.
+     * @param {'production' | 'staging' | 'development'} environment - The environment to get endpoint for
+     * @returns {string} Token endpoint URL for the specified environment.
+     */
+    static getTokenEndpoint(environment: 'production' | 'staging' | 'development'): string;
+    /**
+     * Validates Zyntopia-specific configuration requirements.
+     * @param {ZyntopiaOAuthConfig} config - Configuration to validate
+     * @throws {Error} If configuration is invalid.
+     */
+    static validateZyntopiaConfig(config: ZyntopiaOAuthConfig): void;
+}
+
 /**
  * A proxy tool that wraps an MCP server tool and implements the {@link IToolExecutor} interface.
  *
@@ -4683,6 +4949,195 @@ declare class McpProxyTool implements IToolExecutor {
     getToolDefinition(): McpToolDefinition;
 }
 
+/**
+ * Manages thread-specific configuration (ThreadConfig) and state (AgentState)
+ * using an underlying StateRepository. Supports explicit and implicit state saving strategies.
+ */
+declare class StateManager implements StateManager$1 {
+    private repository;
+    private strategy;
+    private contextCache;
+    /**
+     * Creates an instance of StateManager.
+     * @param {IStateRepository} stateRepository - The repository for persisting state.
+     * @param {StateSavingStrategy} [strategy='explicit'] - The state saving strategy to use.
+     */
+    constructor(stateRepository: IStateRepository, strategy?: StateSavingStrategy);
+    /**
+     * Loads the complete context (`ThreadConfig` and `AgentState`) for a specific thread.
+     * If in 'implicit' state saving strategy, it caches the loaded context and a snapshot
+     * of its AgentState for later comparison in `saveStateIfModified`.
+     * @param {string} threadId - The unique identifier for the thread.
+     * @param {string} [_userId] - Optional user identifier (currently unused).
+     * @returns {Promise<ThreadContext>} A promise resolving to the `ThreadContext` object.
+     * @throws {Error} If `threadId` is empty or if the repository fails to find the context.
+     */
+    loadThreadContext(threadId: string, _userId?: string): Promise<ThreadContext>;
+    /**
+     * Checks if a specific tool is permitted for use within a given thread.
+     * It loads the thread's context and checks the `enabledTools` array in the configuration.
+     * @param {string} threadId - The ID of the thread.
+     * @param {string} toolName - The name of the tool to check.
+     * @returns {Promise<boolean>} A promise resolving to `true` if the tool is listed in the thread's `enabledTools` config, `false` otherwise or if the context/config cannot be loaded.
+     */
+    isToolEnabled(threadId: string, toolName: string): Promise<boolean>;
+    /**
+     * Retrieves a specific value from the thread's configuration (`ThreadConfig`).
+     * Loads the context first (which might come from cache in implicit mode).
+     * @template T - The expected type of the configuration value.
+     * @param {string} threadId - The ID of the thread.
+     * @param {string} key - The top-level configuration key.
+     * @returns {Promise<T | undefined>} A promise resolving to the configuration value, or `undefined`.
+     */
+    getThreadConfigValue<T>(threadId: string, key: string): Promise<T | undefined>;
+    /**
+     * Persists the thread's `AgentState` if it has been modified.
+     * Behavior depends on the `stateSavingStrategy`:
+     * - 'explicit': This method is a no-op for `AgentState` persistence and logs a warning.
+     * - 'implicit': Compares the current `AgentState` (from the cached `ThreadContext` modified by the agent)
+     *               with the snapshot taken during `loadThreadContext`. If different, saves the state
+     *               to the repository and updates the snapshot.
+     * @param {string} threadId - The ID of the thread whose state might need saving.
+     * @returns {Promise<void>} A promise that resolves when the state is saved or the operation is skipped.
+     */
+    saveStateIfModified(threadId: string): Promise<void>;
+    /**
+      * Sets or completely replaces the configuration (`ThreadConfig`) for a specific thread
+      * by calling the underlying state repository. This also clears any cached context for the thread.
+      * @param {string} threadId - The ID of the thread.
+      * @param {ThreadConfig} config - The complete `ThreadConfig` object.
+      * @returns {Promise<void>} A promise that resolves when the configuration is saved.
+      */
+    setThreadConfig(threadId: string, config: ThreadConfig): Promise<void>;
+    /**
+     * Explicitly sets or updates the AgentState for a specific thread by calling the underlying state repository.
+     * If in 'implicit' mode, this also updates the cached snapshot to prevent `saveStateIfModified`
+     * from re-saving the same state immediately.
+     * @param {string} threadId - The unique identifier of the thread.
+     * @param {AgentState} state - The AgentState object to save. Must not be undefined or null.
+     * @returns {Promise<void>} A promise that resolves when the state is saved.
+     * @throws {Error} If threadId or state is undefined/null, or if the repository fails.
+     */
+    setAgentState(threadId: string, state: AgentState): Promise<void>;
+    /**
+     * Enables specific tools for a conversation thread by adding them to the thread's enabled tools list.
+     * This method loads the current thread configuration, updates the enabledTools array,
+     * and persists the changes. Cache is invalidated to ensure fresh data on next load.
+     * @param {string} threadId - The unique identifier of the thread.
+     * @param {string[]} toolNames - Array of tool names to enable for this thread.
+     * @returns {Promise<void>} A promise that resolves when the tools are enabled.
+     * @throws {Error} If threadId is empty, toolNames is empty, or if the repository fails.
+     */
+    enableToolsForThread(threadId: string, toolNames: string[]): Promise<void>;
+    /**
+     * Disables specific tools for a conversation thread by removing them from the thread's enabled tools list.
+     * This method loads the current thread configuration, updates the enabledTools array,
+     * and persists the changes. Cache is invalidated to ensure fresh data on next load.
+     * @param {string} threadId - The unique identifier of the thread.
+     * @param {string[]} toolNames - Array of tool names to disable for this thread.
+     * @returns {Promise<void>} A promise that resolves when the tools are disabled.
+     * @throws {Error} If threadId is empty, toolNames is empty, or if the repository fails.
+     */
+    disableToolsForThread(threadId: string, toolNames: string[]): Promise<void>;
+    /**
+     * Gets the list of currently enabled tools for a specific thread.
+     * This is a convenience method that loads the thread context and returns the enabledTools array.
+     * @param {string} threadId - The unique identifier of the thread.
+     * @returns {Promise<string[]>} A promise that resolves to an array of enabled tool names, or empty array if no tools are enabled.
+     * @throws {Error} If the thread context cannot be loaded.
+     */
+    getEnabledToolsForThread(threadId: string): Promise<string[]>;
+    /**
+     * Clears the internal context cache. Useful if the underlying storage is manipulated externally
+     * during an agent's processing cycle, though this is generally not recommended.
+     * Or for testing purposes.
+     */
+    clearCache(): void;
+}
+
+/**
+ * A simple in-memory implementation of the `ToolRegistry` interface.
+ * Stores tool executors in a Map, keyed by the tool's unique name.
+ */
+declare class ToolRegistry implements ToolRegistry$1 {
+    private executors;
+    private stateManager;
+    /**
+     * Creates an instance of ToolRegistry.
+     * @param stateManager - Optional StateManager instance for advanced filtering.
+     */
+    constructor(stateManager?: StateManager$1);
+    /**
+     * Registers a tool executor instance, making it available for lookup via `getToolExecutor`.
+     * If a tool with the same name (from `executor.schema.name`) already exists, it will be overwritten, and a warning will be logged.
+     * @param executor - The instance of the class implementing `IToolExecutor`. Must have a valid schema with a name.
+     * @returns A promise that resolves when the tool is registered.
+     * @throws {Error} If the provided executor or its schema is invalid.
+     */
+    registerTool(executor: IToolExecutor): Promise<void>;
+    /**
+     * Retrieves a registered tool executor instance by its unique name.
+     * @param toolName - The `name` property defined in the tool's schema.
+     * @returns A promise resolving to the `IToolExecutor` instance, or `undefined` if no tool with that name is registered.
+     */
+    getToolExecutor(toolName: string): Promise<IToolExecutor | undefined>;
+    /**
+     * Retrieves the schemas of all currently registered tools.
+     * Retrieves the schemas of available tools, optionally filtering by those enabled for a specific thread.
+     * If `filter.enabledForThreadId` is provided and a `StateManager` was injected, it attempts to load the thread's configuration
+     * and return only the schemas for tools listed in `enabledTools`. Otherwise, it returns all registered tool schemas.
+     * @param filter - Optional filter criteria. `enabledForThreadId` triggers filtering based on thread config.
+     * @returns A promise resolving to an array containing the `ToolSchema` of the available tools based on the filter.
+     */
+    getAvailableTools(filter?: {
+        enabledForThreadId?: string;
+    }): Promise<ToolSchema[]>;
+    /**
+     * Removes all registered tool executors from the registry.
+     * Primarily useful for resetting state during testing or specific application scenarios.
+     * @returns A promise that resolves when all tools have been cleared.
+     */
+    clearAllTools(): Promise<void>;
+    /**
+     * Unregister a single tool by name.
+     */
+    unregisterTool(toolName: string): Promise<void>;
+    /**
+     * Unregister tools matching a predicate; returns count removed.
+     */
+    unregisterTools(predicate: (schema: ToolSchema) => boolean): Promise<number>;
+}
+
+/**
+ * Manages the lifecycle and access to multiple ProviderAdapter implementations.
+ */
+declare class ProviderManagerImpl implements IProviderManager {
+    private availableProviders;
+    private maxParallelApiInstancesPerProvider;
+    private apiInstanceIdleTimeoutMs;
+    private managedInstances;
+    private requestQueue;
+    constructor(config: ProviderManagerConfig);
+    /**
+     * Generates a stable configuration signature for caching.
+     * @param config The runtime provider configuration.
+     * @returns A string signature.
+     */
+    private _getConfigSignature;
+    getAvailableProviders(): string[];
+    getAdapter(config: RuntimeProviderConfig): Promise<ManagedAdapterAccessor>;
+    /**
+     * Internal method to release an adapter instance back to the manager.
+     * @param configSignature The signature of the instance to release.
+     */
+    private _releaseAdapter;
+    /**
+     * Internal method to evict an instance from the manager.
+     * @param configSignature The signature of the instance to evict.
+     */
+    private _evictInstance;
+}
+
 /**
  * Generates a unique Version 4 UUID (Universally Unique Identifier) string.
  *
@@ -4750,6 +5205,6 @@ declare const generateUUID: () => string;
 /**
  * The current version of the ART Framework package.
  */
-declare const VERSION = "0.2.8";
+declare const VERSION = "0.3.3";
 
-export { type A2AAgentInfo, type A2ATask, type A2ATaskEvent, type A2ATaskFilter, type A2ATaskMetadata, A2ATaskPriority, type A2ATaskResult, A2ATaskSocket, A2ATaskStatus, ARTError, AdapterInstantiationError, type AgentDiscoveryConfig, AgentDiscoveryService, type AgentFinalResponse, type AgentOptions, type AgentPersona, type AgentProps, type AgentState, AnthropicAdapter, type AnthropicAdapterOptions, ApiQueueTimeoutError, type ArtInstance, type ArtInstanceConfig, type ArtStandardMessage, type ArtStandardMessageRole, ArtStandardMessageSchema, type ArtStandardPrompt, ArtStandardPromptSchema, AuthManager, type AvailableProviderEntry, CalculatorTool, type CallOptions, type ConversationManager, type ConversationMessage, ConversationSocket, type CreateA2ATaskRequest, DeepSeekAdapter, type DeepSeekAdapterOptions, ErrorCode, type ExecutionContext, type ExecutionMetadata, type FilterOptions, type FormattedPrompt, GeminiAdapter, type GeminiAdapterOptions, type IA2ATaskRepository, type IAgentCore, type IAuthStrategy, type IConversationRepository, type IObservationRepository, type IProviderManager, type IStateRepository, type IToolExecutor, type ITypedSocket, InMemoryStorageAdapter, IndexedDBStorageAdapter, type JsonObjectSchema, type JsonSchema, type LLMMetadata, LLMStreamSocket, LocalInstanceBusyError, LocalProviderConflictError, LogLevel, Logger, type LoggerConfig, type ManagedAdapterAccessor, McpClientController, McpManager, type McpManagerConfig, McpProxyTool, type McpResource, type McpResourceTemplate, type McpServerConfig, type McpServerStatus, type McpToolDefinition, type MessageOptions, MessageRole, ModelCapability, type Observation, type ObservationFilter, type ObservationManager, ObservationSocket, ObservationType, OllamaAdapter, type OllamaAdapterOptions, OpenAIAdapter, type OpenAIAdapterOptions, OpenRouterAdapter, type OpenRouterAdapterOptions, type OutputParser, PESAgent, type PKCEOAuthConfig, PKCEOAuthStrategy, type ParsedToolCall, type PromptBlueprint, type PromptContext, type PromptManager, type ProviderAdapter, type ProviderManagerConfig, type ReasoningEngine, type RuntimeProviderConfig, type StageSpecificPrompts, type StateManager, type StateSavingStrategy, type StorageAdapter, type StreamEvent, type StreamEventTypeFilter, SupabaseStorageAdapter, type SystemPromptMergeStrategy, type SystemPromptOverride, type SystemPromptResolver, type SystemPromptSpec, type SystemPromptsRegistry, type TaskDelegationConfig, TaskDelegationService, type TaskStatusResponse, type ThreadConfig, type ThreadContext, type ToolRegistry, type ToolResult, type ToolSchema, type ToolSystem, TypedSocket, type UISystem, UnknownProviderError, type UnsubscribeFunction, type UpdateA2ATaskRequest, VERSION, createArtInstance, generateUUID };
+export { type A2AAgentInfo, type A2ATask, type A2ATaskEvent, type A2ATaskFilter, type A2ATaskMetadata, A2ATaskPriority, type A2ATaskResult, A2ATaskSocket, A2ATaskStatus, ARTError, AdapterInstantiationError, type AgentDiscoveryConfig, AgentDiscoveryService, type AgentFinalResponse, type AgentOptions, type AgentPersona, type AgentProps, type AgentState, AnthropicAdapter, type AnthropicAdapterOptions, ApiKeyStrategy, ApiQueueTimeoutError, type ArtInstance, type ArtInstanceConfig, type ArtStandardMessage, type ArtStandardMessageRole, ArtStandardMessageSchema, type ArtStandardPrompt, ArtStandardPromptSchema, AuthManager, type AvailableProviderEntry, CalculatorTool, type CallOptions, type ConversationManager, type ConversationMessage, ConversationSocket, type CreateA2ATaskRequest, DeepSeekAdapter, type DeepSeekAdapterOptions, ErrorCode, type ExecutionContext, type ExecutionMetadata, type FilterOptions, type FormattedPrompt, GeminiAdapter, type GeminiAdapterOptions, GenericOAuthStrategy, type IA2ATaskRepository, type IAgentCore, type IAuthStrategy, type IConversationRepository, type IObservationRepository, type IProviderManager, type IStateRepository, type IToolExecutor, type ITypedSocket, InMemoryStorageAdapter, IndexedDBStorageAdapter, type JsonObjectSchema, type JsonSchema, type LLMMetadata, LLMStreamSocket, LocalInstanceBusyError, LocalProviderConflictError, LogLevel, Logger, type LoggerConfig, type ManagedAdapterAccessor, McpClientController, McpManager, type McpManagerConfig, McpProxyTool, type McpResource, type McpResourceTemplate, type McpServerConfig, type McpServerStatus, type McpToolDefinition, type MessageOptions, MessageRole, ModelCapability, type OAuthConfig, type Observation, type ObservationFilter, type ObservationManager, ObservationSocket, ObservationType, OllamaAdapter, type OllamaAdapterOptions, OpenAIAdapter, type OpenAIAdapterOptions, OpenRouterAdapter, type OpenRouterAdapterOptions, type OutputParser, PESAgent, type PKCEOAuthConfig, PKCEOAuthStrategy, type ParsedToolCall, type PromptBlueprint, type PromptContext, type PromptManager, type ProviderAdapter, type ProviderManagerConfig, ProviderManagerImpl, type ReasoningEngine, type RuntimeProviderConfig, type StageSpecificPrompts, StateManager, type StateSavingStrategy, type StorageAdapter, type StreamEvent, type StreamEventTypeFilter, SupabaseStorageAdapter, type SystemPromptMergeStrategy, type SystemPromptOverride, type SystemPromptResolver, type SystemPromptSpec, type SystemPromptsRegistry, type TaskDelegationConfig, TaskDelegationService, type TaskStatusResponse, type ThreadConfig, type ThreadContext, ToolRegistry, type ToolResult, type ToolSchema, type ToolSystem, TypedSocket, UISystem, UnknownProviderError, type UnsubscribeFunction, type UpdateA2ATaskRequest, VERSION, type ZyntopiaOAuthConfig, ZyntopiaOAuthStrategy, createArtInstance, generateUUID };