art-framework 0.2.4

package/dist/index.d.cts

@@ -0,0 +1,937 @@
+/**
+ * Represents the role of a message sender in a conversation.
+ */
+declare enum MessageRole {
+    USER = "USER",
+    AI = "AI",
+    SYSTEM = "SYSTEM",// Added for system prompts, though not explicitly in checklist message interface
+    TOOL = "TOOL"
+}
+/**
+ * Represents a single message within a conversation thread.
+ */
+interface ConversationMessage {
+    messageId: string;
+    threadId: string;
+    role: MessageRole;
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Represents the type of an observation record.
+ */
+declare enum ObservationType {
+    INTENT = "INTENT",
+    PLAN = "PLAN",
+    THOUGHTS = "THOUGHTS",
+    TOOL_CALL = "TOOL_CALL",// Renamed from checklist for clarity
+    TOOL_EXECUTION = "TOOL_EXECUTION",
+    SYNTHESIS = "SYNTHESIS",// Added for final synthesis step
+    ERROR = "ERROR",
+    FINAL_RESPONSE = "FINAL_RESPONSE",// Added for the final AI response message
+    STATE_UPDATE = "STATE_UPDATE"
+}
+/**
+ * Represents a recorded event during the agent's execution.
+ */
+interface Observation {
+    id: string;
+    threadId: string;
+    traceId?: string;
+    timestamp: number;
+    type: ObservationType;
+    title: string;
+    content: any;
+    metadata?: Record<string, any>;
+}
+/**
+ * Represents a basic JSON Schema definition, focusing on object types commonly used for tool inputs/outputs.
+ * This is a simplified representation and doesn't cover all JSON Schema features.
+ */
+interface JsonObjectSchema {
+    type: 'object';
+    properties: {
+        [key: string]: {
+            type: string;
+            description?: string;
+            default?: any;
+            items?: JsonObjectSchema | {
+                type: string;
+            };
+            properties?: JsonObjectSchema['properties'];
+            required?: string[];
+            additionalProperties?: boolean | {
+                type: string;
+            };
+            [key: string]: any;
+        };
+    };
+    required?: string[];
+    additionalProperties?: boolean;
+}
+type JsonSchema = JsonObjectSchema | {
+    type: 'string' | 'number' | 'boolean' | 'array';
+    [key: string]: any;
+};
+/**
+ * Defines the schema for a tool, including its input parameters.
+ * Uses JSON Schema format for inputSchema.
+ */
+interface ToolSchema {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema?: JsonSchema;
+    examples?: Array<{
+        input: any;
+        output?: any;
+        description?: string;
+    }>;
+}
+/**
+ * Represents the structured result of a tool execution.
+ */
+interface ToolResult {
+    callId: string;
+    toolName: string;
+    status: 'success' | 'error';
+    output?: any;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Represents a parsed request from the LLM to call a specific tool.
+ */
+interface ParsedToolCall {
+    callId: string;
+    toolName: string;
+    arguments: any;
+}
+/**
+ * Configuration specific to a conversation thread.
+ */
+interface ThreadConfig {
+    reasoning: {
+        provider: string;
+        model: string;
+        parameters?: Record<string, any>;
+    };
+    enabledTools: string[];
+    historyLimit: number;
+    systemPrompt?: string;
+}
+/**
+ * Represents non-configuration state associated with an agent or thread.
+ * Could include user preferences, accumulated knowledge, etc. (Less defined for v1.0)
+ */
+interface AgentState {
+    [key: string]: any;
+}
+/**
+ * Encapsulates the configuration and state for a specific thread.
+ */
+interface ThreadContext {
+    config: ThreadConfig;
+    state: AgentState | null;
+}
+/**
+ * Properties required to initiate an agent processing cycle.
+ */
+interface AgentProps {
+    query: string;
+    threadId: string;
+    sessionId?: string;
+    userId?: string;
+    traceId?: string;
+    options?: AgentOptions;
+}
+/**
+ * Options to override agent behavior at runtime.
+ */
+interface AgentOptions {
+    llmParams?: Record<string, any>;
+    forceTools?: string[];
+}
+/**
+ * The final structured response returned by the agent core after processing.
+ */
+interface AgentFinalResponse {
+    response: ConversationMessage;
+    metadata: ExecutionMetadata;
+}
+/**
+ * Metadata summarizing an agent execution cycle.
+ */
+interface ExecutionMetadata {
+    threadId: string;
+    traceId?: string;
+    userId?: string;
+    status: 'success' | 'error' | 'partial';
+    totalDurationMs: number;
+    llmCalls: number;
+    toolCalls: number;
+    llmCost?: number;
+    error?: string;
+}
+/**
+ * Context provided to a tool during its execution.
+ */
+interface ExecutionContext {
+    threadId: string;
+    traceId?: string;
+    userId?: string;
+}
+/**
+ * Options for configuring an LLM call.
+ */
+interface CallOptions {
+    threadId: string;
+    traceId?: string;
+    userId?: string;
+    onThought?: (thought: string) => void;
+    [key: string]: any;
+}
+/**
+ * Represents the prompt data formatted for a specific LLM provider.
+ * Can be a simple string or a complex object (e.g., for OpenAI Chat Completion API).
+ */
+type FormattedPrompt = string | object | Array<object>;
+/**
+ * Options for filtering data retrieved from storage.
+ * Structure depends heavily on the underlying adapter's capabilities.
+ */
+interface FilterOptions {
+    filter?: Record<string, any>;
+    sort?: Record<string, 'asc' | 'desc'>;
+    limit?: number;
+    skip?: number;
+}
+/**
+ * Options for retrieving conversation messages.
+ */
+interface MessageOptions {
+    limit?: number;
+    beforeTimestamp?: number;
+    afterTimestamp?: number;
+}
+/**
+ * Options for filtering observations.
+ */
+interface ObservationFilter {
+    types?: ObservationType[];
+    beforeTimestamp?: number;
+    afterTimestamp?: number;
+}
+
+type UnsubscribeFunction = () => void;
+interface Subscription<DataType, FilterType> {
+    id: string;
+    callback: (data: DataType) => void;
+    filter?: FilterType;
+    options?: {
+        threadId?: string;
+    };
+}
+/**
+ * A generic class for implementing a publish/subscribe pattern with filtering capabilities.
+ * Designed for decoupling components, particularly UI updates from backend events.
+ */
+declare class TypedSocket$1<DataType, FilterType = any> {
+    protected subscriptions: Map<string, Subscription<DataType, FilterType>>;
+    constructor();
+    /**
+     * Subscribes a callback function to receive notifications.
+     * @param callback - The function to call when new data is notified.
+     * @param filter - An optional filter to only receive specific types of data.
+     * @param options - Optional configuration, like a threadId for filtering.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: (data: DataType) => void, filter?: FilterType, options?: {
+        threadId?: string;
+    }): UnsubscribeFunction;
+    /**
+     * Notifies all relevant subscribers with new data.
+     * @param data - The data payload to send to subscribers.
+     * @param options - Optional targeting options (e.g., targetThreadId).
+     * @param filterCheck - A function to check if a subscription's filter matches the data.
+     */
+    notify(data: DataType, options?: {
+        targetThreadId?: string;
+        targetSessionId?: string;
+    }, // targetSessionId might be useful later
+    filterCheck?: (data: DataType, filter?: FilterType) => boolean): void;
+    /**
+     * Optional: Retrieves historical data. This base implementation is empty.
+     * Subclasses might implement this by interacting with repositories.
+     */
+    getHistory?(_filter?: FilterType, _options?: {
+        threadId?: string;
+        limit?: number;
+    }): Promise<DataType[]>;
+    /**
+     * Clears all subscriptions. Useful for cleanup.
+     */
+    clearAllSubscriptions(): void;
+}
+
+/**
+ * A specialized TypedSocket for handling Observation data.
+ * Allows filtering by ObservationType.
+ * Can optionally fetch historical observations from a repository.
+ */
+declare class ObservationSocket$1 extends TypedSocket$1<Observation, ObservationType | ObservationType[]> {
+    private observationRepository?;
+    constructor(observationRepository?: IObservationRepository);
+    /**
+     * Notifies subscribers about a new observation.
+     * @param observation - The observation data.
+     */
+    notifyObservation(observation: Observation): void;
+    /**
+     * Retrieves historical observations, optionally filtered by type and thread.
+     * Requires an ObservationRepository to be configured.
+     * @param filter - Optional ObservationType or array of types to filter by.
+     * @param options - Optional threadId and limit.
+     * @returns A promise resolving to an array of observations.
+     */
+    getHistory(filter?: ObservationType | ObservationType[], options?: {
+        threadId?: string;
+        limit?: number;
+    }): Promise<Observation[]>;
+}
+
+/**
+ * A specialized TypedSocket for handling ConversationMessage data.
+ * Allows filtering by MessageRole.
+ * Can optionally fetch historical messages from a repository.
+ */
+declare class ConversationSocket$1 extends TypedSocket$1<ConversationMessage, MessageRole | MessageRole[]> {
+    private conversationRepository?;
+    constructor(conversationRepository?: IConversationRepository);
+    /**
+     * Notifies subscribers about a new conversation message.
+     * @param message - The conversation message data.
+     */
+    notifyMessage(message: ConversationMessage): void;
+    /**
+     * Retrieves historical messages, optionally filtered by role and thread.
+     * Requires a ConversationRepository to be configured.
+     * @param filter - Optional MessageRole or array of roles to filter by.
+     * @param options - Optional threadId and limit.
+     * @returns A promise resolving to an array of messages.
+     */
+    getHistory(filter?: MessageRole | MessageRole[], options?: {
+        threadId?: string;
+        limit?: number;
+    }): Promise<ConversationMessage[]>;
+}
+
+/**
+ * Interface for the central agent orchestrator.
+ */
+interface IAgentCore {
+    process(props: AgentProps): Promise<AgentFinalResponse>;
+}
+/**
+ * Interface for the component responsible for interacting with LLMs.
+ */
+interface ReasoningEngine {
+    /**
+     * Calls the underlying LLM provider.
+     * @param prompt The formatted prompt for the provider.
+     * @param options Call-specific options, including threadId and callbacks.
+     * @returns The raw string response from the LLM.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+/**
+ * Interface for managing and constructing prompts for the LLM.
+ */
+interface PromptManager {
+    /**
+     * Creates the prompt for the planning phase.
+     * @param query User query.
+     * @param history Conversation history.
+     * @param systemPrompt System prompt string.
+     * @param availableTools Schemas of available tools.
+     * @param threadContext Current thread context.
+     * @returns Formatted prompt suitable for the ReasoningEngine.
+     */
+    createPlanningPrompt(query: string, history: ConversationMessage[], systemPrompt: string | undefined, availableTools: ToolSchema[], threadContext: ThreadContext): Promise<FormattedPrompt>;
+    /**
+     * Creates the prompt for the synthesis phase.
+     * @param query User query.
+     * @param intent Parsed intent from planning.
+     * @param plan Parsed plan from planning.
+     * @param toolResults Results from tool execution.
+     * @param history Conversation history.
+     * @param systemPrompt System prompt string.
+     * @param threadContext Current thread context.
+     * @returns Formatted prompt suitable for the ReasoningEngine.
+     */
+    createSynthesisPrompt(query: string, intent: string | undefined, // Or a structured intent object
+    plan: string | undefined, // Or a structured plan object
+    toolResults: ToolResult[], history: ConversationMessage[], systemPrompt: string | undefined, threadContext: ThreadContext): Promise<FormattedPrompt>;
+}
+/**
+ * Interface for parsing structured output from LLM responses.
+ */
+interface OutputParser {
+    /**
+     * Parses the output of the planning LLM call.
+     * @param output Raw LLM output string.
+     * @returns Structured planning data (intent, plan, tool calls).
+     */
+    parsePlanningOutput(output: string): Promise<{
+        intent?: string;
+        plan?: string;
+        toolCalls?: ParsedToolCall[];
+    }>;
+    /**
+     * Parses the output of the synthesis LLM call.
+     * @param output Raw LLM output string.
+     * @returns The final synthesized response content.
+     */
+    parseSynthesisOutput(output: string): Promise<string>;
+}
+/**
+ * Base interface for LLM Provider Adapters, extending the core ReasoningEngine.
+ * Implementations will handle provider-specific API calls, authentication, etc.
+ */
+interface ProviderAdapter extends ReasoningEngine {
+    readonly providerName: string;
+}
+/**
+ * Interface for the executable logic of a tool.
+ */
+interface IToolExecutor {
+    /** The schema definition for this tool. */
+    readonly schema: ToolSchema;
+    /**
+     * Executes the tool's logic.
+     * @param input Validated input arguments matching the tool's inputSchema.
+     * @param context Execution context containing threadId, traceId, etc.
+     * @returns A promise resolving to the structured tool result.
+     */
+    execute(input: any, context: ExecutionContext): Promise<ToolResult>;
+}
+/**
+ * Interface for managing the registration and retrieval of tools.
+ */
+interface ToolRegistry {
+    /**
+     * Registers a tool executor.
+     * @param executor The tool executor instance.
+     */
+    registerTool(executor: IToolExecutor): Promise<void>;
+    /**
+     * Retrieves a tool executor by its name.
+     * @param toolName The unique name of the tool.
+     * @returns The executor instance or undefined if not found.
+     */
+    getToolExecutor(toolName: string): Promise<IToolExecutor | undefined>;
+    /**
+     * Retrieves the schemas of all registered tools, potentially filtered.
+     * @param filter Optional criteria (e.g., only enabled tools for a thread).
+     * @returns An array of tool schemas.
+     */
+    getAvailableTools(filter?: {
+        enabledForThreadId?: string;
+    }): Promise<ToolSchema[]>;
+}
+/**
+ * Interface for the system responsible for orchestrating tool execution.
+ */
+interface ToolSystem {
+    /**
+     * Executes a list of parsed tool calls.
+     * @param toolCalls Array of tool calls requested by the LLM.
+     * @param threadId The current thread ID for context and permissions.
+     * @param traceId Optional trace ID.
+     * @returns A promise resolving to an array of tool results.
+     */
+    executeTools(toolCalls: ParsedToolCall[], threadId: string, traceId?: string): Promise<ToolResult[]>;
+}
+/**
+ * Interface for managing thread-specific configuration and state.
+ */
+interface StateManager {
+    /**
+     * Loads the full context (config + state) for a given thread.
+     * @param threadId The ID of the thread.
+     * @param userId Optional user ID for access control.
+     * @returns The thread context.
+     */
+    loadThreadContext(threadId: string, userId?: string): Promise<ThreadContext>;
+    /**
+     * Checks if a specific tool is enabled for the given thread based on its config.
+     * @param threadId The ID of the thread.
+     * @param toolName The name of the tool.
+     * @returns True if the tool is enabled, false otherwise.
+     */
+    isToolEnabled(threadId: string, toolName: string): Promise<boolean>;
+    /**
+     * Retrieves a specific configuration value for the thread.
+     * @param threadId The ID of the thread.
+     * @param key The configuration key (potentially nested, e.g., 'reasoning.model').
+     * @returns The configuration value or undefined.
+     */
+    getThreadConfigValue<T>(threadId: string, key: string): Promise<T | undefined>;
+    /**
+     * Saves the thread's state if it has been modified during execution.
+     * Implementations should track changes to avoid unnecessary writes.
+     * @param threadId The ID of the thread.
+     */
+    saveStateIfModified(threadId: string): Promise<void>;
+    /**
+     * Sets or updates the configuration for a specific thread.
+     * @param threadId The ID of the thread.
+     * @param config The complete configuration object to set.
+     */
+    setThreadConfig(threadId: string, config: ThreadConfig): Promise<void>;
+}
+/**
+ * Interface for managing conversation history.
+ */
+interface ConversationManager {
+    /**
+     * Adds one or more messages to a thread's history.
+     * @param threadId The ID of the thread.
+     * @param messages An array of messages to add.
+     */
+    addMessages(threadId: string, messages: ConversationMessage[]): Promise<void>;
+    /**
+     * Retrieves messages from a thread's history.
+     * @param threadId The ID of the thread.
+     * @param options Filtering and pagination options.
+     * @returns An array of conversation messages.
+     */
+    getMessages(threadId: string, options?: MessageOptions): Promise<ConversationMessage[]>;
+}
+/**
+ * Interface for managing the recording and retrieval of observations.
+ */
+interface ObservationManager {
+    /**
+     * Records a new observation. Automatically assigns ID, timestamp, and potentially title.
+     * Notifies the ObservationSocket.
+     * @param observationData Data for the observation (excluding id, timestamp, title).
+     */
+    record(observationData: Omit<Observation, 'id' | 'timestamp' | 'title'>): Promise<void>;
+    /**
+     * Retrieves observations for a specific thread, with optional filtering.
+     * @param threadId The ID of the thread.
+     * @param filter Optional filtering criteria.
+     * @returns An array of observations.
+     */
+    getObservations(threadId: string, filter?: ObservationFilter): Promise<Observation[]>;
+}
+/**
+ * Generic interface for a typed publish/subscribe socket.
+ */
+interface TypedSocket<DataType, FilterType = any> {
+    /**
+     * Subscribes a callback function to receive data updates.
+     * @param callback The function to call with new data.
+     * @param filter Optional filter criteria specific to the socket type.
+     * @param options Optional configuration like target threadId.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: (data: DataType) => void, filter?: FilterType, options?: {
+        threadId?: string;
+    }): () => void;
+    /**
+     * Notifies subscribers of new data.
+     * @param data The data payload.
+     * @param options Optional targeting information (e.g., specific thread).
+     */
+    notify(data: DataType, options?: {
+        targetThreadId?: string;
+        targetSessionId?: string;
+    }): void;
+    /**
+     * Optional method to retrieve historical data from the socket's source.
+     * @param filter Optional filter criteria.
+     * @param options Optional configuration like threadId and limit.
+     */
+    getHistory?(filter?: FilterType, options?: {
+        threadId?: string;
+        limit?: number;
+    }): Promise<DataType[]>;
+}
+/**
+ * TypedSocket specifically for Observation data.
+ * FilterType is ObservationType or array of ObservationType.
+ */
+interface ObservationSocket extends TypedSocket<Observation, ObservationType | ObservationType[]> {
+}
+/**
+ * TypedSocket specifically for ConversationMessage data.
+ * FilterType is MessageRole or array of MessageRole.
+ */
+interface ConversationSocket extends TypedSocket<ConversationMessage, MessageRole | MessageRole[]> {
+}
+
+/**
+ * Interface for the system providing access to UI communication sockets.
+ */
+interface UISystem {
+    getObservationSocket(): ObservationSocket$1;
+    getConversationSocket(): ConversationSocket$1;
+}
+/**
+ * Interface for a storage adapter, providing a generic persistence layer.
+ */
+interface StorageAdapter {
+    /** Optional initialization method (e.g., connecting to DB). */
+    init?(config?: any): Promise<void>;
+    /**
+     * Retrieves a single item from a collection by its ID.
+     * @param collection The name of the data collection (e.g., 'conversations', 'observations').
+     * @param id The unique ID of the item.
+     * @returns The item or null if not found.
+     */
+    get<T>(collection: string, id: string): Promise<T | null>;
+    /**
+     * Saves (creates or updates) an item in a collection.
+     * @param collection The name of the collection.
+     * @param id The unique ID of the item.
+     * @param data The data to save.
+     */
+    set<T>(collection: string, id: string, data: T): Promise<void>;
+    /**
+     * Deletes an item from a collection by its ID.
+     * @param collection The name of the collection.
+     * @param id The unique ID of the item.
+     */
+    delete(collection: string, id: string): Promise<void>;
+    /**
+     * Queries items in a collection based on filter options.
+     * @param collection The name of the collection.
+     * @param filterOptions Filtering, sorting, and pagination options.
+     * @returns An array of matching items.
+     */
+    query<T>(collection: string, filterOptions: FilterOptions): Promise<T[]>;
+    /** Optional: Clears all items from a specific collection. */
+    clearCollection?(collection: string): Promise<void>;
+    /** Optional: Clears all data managed by the adapter. Use with caution! */
+    clearAll?(): Promise<void>;
+}
+/** Repository for managing ConversationMessages. */
+interface IConversationRepository {
+    addMessages(threadId: string, messages: ConversationMessage[]): Promise<void>;
+    getMessages(threadId: string, options?: MessageOptions): Promise<ConversationMessage[]>;
+}
+/** Repository for managing Observations. */
+interface IObservationRepository {
+    addObservation(observation: Observation): Promise<void>;
+    getObservations(threadId: string, filter?: ObservationFilter): Promise<Observation[]>;
+}
+/** Repository for managing ThreadConfig and AgentState. */
+interface IStateRepository {
+    getThreadConfig(threadId: string): Promise<ThreadConfig | null>;
+    setThreadConfig(threadId: string, config: ThreadConfig): Promise<void>;
+    getAgentState(threadId: string): Promise<AgentState | null>;
+    setAgentState(threadId: string, state: AgentState): Promise<void>;
+    getThreadContext(threadId: string): Promise<ThreadContext | null>;
+    setThreadContext(threadId: string, context: ThreadContext): Promise<void>;
+}
+/**
+ * Represents the initialized ART instance returned by the factory function.
+ */
+interface ArtInstance {
+    process: IAgentCore['process'];
+    uiSystem: UISystem;
+    stateManager: StateManager;
+    conversationManager: ConversationManager;
+    toolRegistry: ToolRegistry;
+    observationManager: ObservationManager;
+}
+
+interface StorageConfig {
+    type: 'memory' | 'indexedDB';
+    dbName?: string;
+}
+interface ReasoningConfig {
+    provider: 'openai' | 'gemini' | 'anthropic' | 'openrouter' | 'deepseek';
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+}
+interface AgentFactoryConfig {
+    storage: StorageConfig;
+    reasoning: ReasoningConfig;
+    tools?: IToolExecutor[];
+    agentCore?: new (dependencies: any) => IAgentCore;
+}
+/**
+ * Creates and initializes an ART instance with the specified configuration.
+ * This is the recommended way to get started with the ART framework.
+ * @param config The configuration for the ART instance.
+ * @returns A promise resolving to the initialized ArtInstance.
+ */
+declare function createArtInstance(config: AgentFactoryConfig): Promise<ArtInstance>;
+
+interface PESAgentDependencies {
+    stateManager: StateManager;
+    conversationManager: ConversationManager;
+    toolRegistry: ToolRegistry;
+    promptManager: PromptManager;
+    reasoningEngine: ReasoningEngine;
+    outputParser: OutputParser;
+    observationManager: ObservationManager;
+    toolSystem: ToolSystem;
+}
+/**
+ * Implements the Plan-Execute-Synthesize (PES) agent orchestration logic.
+ */
+declare class PESAgent implements IAgentCore {
+    private readonly deps;
+    constructor(dependencies: PESAgentDependencies);
+    process(props: AgentProps): Promise<AgentFinalResponse>;
+}
+
+/**
+ * An in-memory implementation of the StorageAdapter interface.
+ * Useful for testing, development, or simple scenarios where persistence
+ * across sessions is not required.
+ */
+declare class InMemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    /**
+     * Initializes the adapter (no-op for in-memory).
+     * @param _config Optional configuration (ignored).
+     */
+    init(_config?: any): Promise<void>;
+    /**
+     * Retrieves a single item from a collection by its ID.
+     * @param collection The name of the data collection.
+     * @param id The unique ID of the item.
+     * @returns The item or null if not found.
+     */
+    get<T>(collection: string, id: string): Promise<T | null>;
+    /**
+     * Saves (creates or updates) an item in a collection.
+     * @param collection The name of the collection.
+     * @param id The unique ID of the item.
+     * @param data The data to save (will be deep copied).
+     */
+    set<T>(collection: string, id: string, data: T): Promise<void>;
+    /**
+     * Deletes an item from a collection by its ID.
+     * @param collection The name of the collection.
+     * @param id The unique ID of the item.
+     */
+    delete(collection: string, id: string): Promise<void>;
+    /**
+     * Queries items in a collection based on simple filter options.
+     * Note: This is a basic implementation. It only supports exact matches
+     * on top-level properties defined in the filter object. It does not
+     * support complex queries, sorting, or deep filtering.
+     * @param collection The name of the collection.
+     * @param filterOptions Filtering options. Only `filter` is partially supported.
+     * @returns An array of matching items (deep copies).
+     */
+    query<T>(collection: string, filterOptions: FilterOptions): Promise<T[]>;
+    /**
+     * Clears all items from a specific collection.
+     * @param collection The name of the collection to clear.
+     */
+    clearCollection(collection: string): Promise<void>;
+    /**
+     * Clears all data managed by the adapter.
+     */
+    clearAll(): Promise<void>;
+}
+
+/**
+ * Configuration options for the IndexedDBStorageAdapter.
+ */
+interface IndexedDBConfig {
+    dbName?: string;
+    dbVersion?: number;
+    objectStores: string[];
+}
+/**
+ * An implementation of the StorageAdapter interface using IndexedDB
+ * for persistent storage in the browser.
+ */
+declare class IndexedDBStorageAdapter implements StorageAdapter {
+    private db;
+    private dbName;
+    private dbVersion;
+    private requiredObjectStores;
+    private initPromise;
+    constructor(config: IndexedDBConfig);
+    /**
+     * Initializes the IndexedDB database connection and ensures object stores exist.
+     * This method should be called before any other operations.
+     */
+    init(): Promise<void>;
+    private getTransaction;
+    get<T>(collection: string, id: string): Promise<T | null>;
+    set<T>(collection: string, id: string, data: T): Promise<void>;
+    delete(collection: string, id: string): Promise<void>;
+    query<T>(collection: string, filterOptions: FilterOptions): Promise<T[]>;
+    clearCollection(collection: string): Promise<void>;
+    clearAll(): Promise<void>;
+}
+
+interface GeminiAdapterOptions {
+    apiKey: string;
+    model?: string;
+    apiBaseUrl?: string;
+    apiVersion?: string;
+}
+declare class GeminiAdapter implements ProviderAdapter {
+    readonly providerName = "gemini";
+    private apiKey;
+    private model;
+    private apiBaseUrl;
+    private apiVersion;
+    constructor(options: GeminiAdapterOptions);
+    /**
+     * Calls the Google Generative AI API (Gemini).
+     * Note: Assumes prompt is a string for basic user input.
+     *       Does not yet handle complex history or system prompts.
+     *       `onThought` is not implemented (requires streaming API).
+     * @param prompt - Treated as the user message content.
+     * @param options - Call options including LLM parameters.
+     * @returns The content string from the API response.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+
+interface OpenAIAdapterOptions {
+    apiKey: string;
+    model?: string;
+    apiBaseUrl?: string;
+}
+declare class OpenAIAdapter implements ProviderAdapter {
+    readonly providerName = "openai";
+    private apiKey;
+    private model;
+    private apiBaseUrl;
+    constructor(options: OpenAIAdapterOptions);
+    /**
+     * Calls the OpenAI Chat Completions API.
+     * Note: This basic implementation assumes the FormattedPrompt is a string
+     *       representing the user's message or a pre-formatted structure.
+     *       It doesn't yet handle complex history formatting or system prompts
+     *       directly from the FormattedPrompt type itself.
+     *       The `onThought` callback is not implemented in this non-streaming version.
+     * @param prompt - For this basic version, treated as the primary user message content.
+     *                 A more robust version would parse a structured prompt object.
+     * @param options - Call options, including threadId, traceId, and LLM parameters.
+     * @returns The content string from the API response.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+
+interface AnthropicAdapterOptions {
+    apiKey: string;
+    model?: string;
+    apiVersion?: string;
+    apiBaseUrl?: string;
+}
+declare class AnthropicAdapter implements ProviderAdapter {
+    readonly providerName = "anthropic";
+    private apiKey;
+    private model;
+    private apiVersion;
+    private apiBaseUrl;
+    private defaultMaxTokens;
+    constructor(options: AnthropicAdapterOptions);
+    /**
+     * Calls the Anthropic Messages API.
+     * Note: Assumes prompt is a string for basic user input.
+     *       Does not yet handle complex history or system prompts robustly.
+     *       `onThought` is not implemented (requires streaming API).
+     * @param prompt - Treated as the user message content.
+     * @param options - Call options including LLM parameters. Requires max_tokens/maxOutputTokens.
+     * @returns The content string from the API response.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+
+interface OpenRouterAdapterOptions {
+    apiKey: string;
+    model: string;
+    apiBaseUrl?: string;
+    siteUrl?: string;
+    appName?: string;
+}
+declare class OpenRouterAdapter implements ProviderAdapter {
+    readonly providerName = "openrouter";
+    private apiKey;
+    private model;
+    private apiBaseUrl;
+    private siteUrl?;
+    private appName?;
+    constructor(options: OpenRouterAdapterOptions);
+    /**
+     * Calls the OpenRouter Chat Completions API (OpenAI compatible).
+     * Note: Assumes prompt is a string for basic user input.
+     *       Does not yet handle complex history or system prompts robustly.
+     *       `onThought` is not implemented (requires streaming API).
+     * @param prompt - Treated as the user message content.
+     * @param options - Call options including LLM parameters.
+     * @returns The content string from the API response.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+
+interface DeepSeekAdapterOptions {
+    apiKey: string;
+    model?: string;
+    apiBaseUrl?: string;
+}
+declare class DeepSeekAdapter implements ProviderAdapter {
+    readonly providerName = "deepseek";
+    private apiKey;
+    private model;
+    private apiBaseUrl;
+    constructor(options: DeepSeekAdapterOptions);
+    /**
+     * Calls the DeepSeek Chat Completions API (OpenAI compatible).
+     * Note: Assumes prompt is a string for basic user input.
+     *       Does not yet handle complex history or system prompts robustly.
+     *       `onThought` is not implemented (requires streaming API).
+     * @param prompt - Treated as the user message content.
+     * @param options - Call options including LLM parameters.
+     * @returns The content string from the API response.
+     */
+    call(prompt: FormattedPrompt, options: CallOptions): Promise<string>;
+}
+
+declare class CalculatorTool implements IToolExecutor {
+    static readonly toolName = "calculator";
+    readonly schema: ToolSchema;
+    execute(input: any, context: ExecutionContext): Promise<ToolResult>;
+}
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+interface LoggerConfig {
+    level: LogLevel;
+    prefix?: string;
+}
+declare class Logger {
+    private static config;
+    static configure(config: Partial<LoggerConfig>): void;
+    static debug(message: string, ...args: any[]): void;
+    static info(message: string, ...args: any[]): void;
+    static warn(message: string, ...args: any[]): void;
+    static error(message: string, ...args: any[]): void;
+}
+
+declare const generateUUID: () => string;
+
+declare const VERSION = "0.2.4";
+
+export { type AgentFinalResponse, type AgentOptions, type AgentProps, type AgentState, AnthropicAdapter, type ArtInstance, CalculatorTool, type CallOptions, type ConversationManager, type ConversationMessage, type ConversationSocket, DeepSeekAdapter, type ExecutionContext, type ExecutionMetadata, type FilterOptions, type FormattedPrompt, GeminiAdapter, type IAgentCore, type IConversationRepository, type IObservationRepository, type IStateRepository, type IToolExecutor, InMemoryStorageAdapter, IndexedDBStorageAdapter, type JsonObjectSchema, type JsonSchema, LogLevel, Logger, type MessageOptions, MessageRole, type Observation, type ObservationFilter, type ObservationManager, type ObservationSocket, ObservationType, OpenAIAdapter, OpenRouterAdapter, type OutputParser, PESAgent, type ParsedToolCall, type PromptManager, type ProviderAdapter, type ReasoningEngine, type StateManager, type StorageAdapter, type ThreadConfig, type ThreadContext, type ToolRegistry, type ToolResult, type ToolSchema, type ToolSystem, type TypedSocket, type UISystem, VERSION, createArtInstance, generateUUID };