@robota-sdk/agent-core 3.0.0-beta.1

package/dist/core/robota.d.ts

@@ -0,0 +1,694 @@
+import { AbstractAgent } from '../abstracts/abstract-agent';
+import { TUniversalMessage, IAgentConfig, IRunOptions, IAgent } from '../interfaces/agent';
+import type { IPluginContract, IPluginHooks, IPluginOptions, IPluginStats } from '../abstracts/abstract-plugin';
+import type { IModule } from '../abstracts/abstract-module';
+import { AbstractTool, type IToolWithEventService } from '../abstracts/abstract-tool';
+import type { IModuleResultData } from '../abstracts/abstract-module';
+/**
+ * Reusable type definitions for Robota agent
+ */
+/**
+ * Agent statistics metadata type
+ * Used for storing statistics and performance data in getStats method
+ */
+export type TAgentStatsMetadata = Record<string, string | number | boolean | Date | string[]>;
+/**
+ * Configuration options for creating a Robota instance.
+ * Extends AgentConfig with additional options specific to the Robota agent system.
+ *
+ * @public
+ * @interface
+ * @example
+ * ```typescript
+ * const config: AgentConfig = {
+ *   name: 'MyAgent',
+ *   aiProviders: [new OpenAIProvider()],
+ *   defaultModel: {
+ *     provider: 'openai',
+ *     model: 'gpt-4'
+ *   },
+ *   tools: [weatherTool, calculatorTool],
+ *   plugins: [new LoggingPlugin(), new UsagePlugin()],
+ *   logging: { level: 'info', enabled: true }
+ * };
+ * ```
+ */
+/**
+ * Core AI agent implementation for the Robota SDK.
+ *
+ * Robota is a comprehensive AI agent that integrates multiple AI providers, tools, and plugins
+ * into a unified conversational interface. Each instance is completely independent with its own
+ * managers and services - NO GLOBAL SINGLETONS are used.
+ *
+ * Key Features:
+ * - Multiple AI provider support (OpenAI, Anthropic, Google)
+ * - Function/tool calling with Zod schema validation
+ * - Plugin system for extensible functionality
+ * - Streaming response support
+ * - Conversation history management
+ * - Instance-specific resource management
+ *
+ * @public
+ * @class
+ * @implements AgentInterface
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { Robota } from '@robota-sdk/agents';
+ * import { OpenAIProvider } from '@robota-sdk/openai';
+ *
+ * const robota = new Robota({
+ *   name: 'MyAgent',
+ *   aiProviders: [new OpenAIProvider({ apiKey: 'sk-...' })],
+ *   defaultModel: {
+ *     provider: 'openai',
+ *     model: 'gpt-4'
+ *   }
+ * });
+ *
+ * const response = await robota.run('Hello, how are you?');
+ * console.log(response);
+ * ```
+ *
+ * @example With Tools and Plugins
+ * ```typescript
+ * import { Robota, LoggingPlugin, UsagePlugin } from '@robota-sdk/agents';
+ * import { weatherTool, calculatorTool } from './my-tools';
+ *
+ * const robota = new Robota({
+ *   name: 'AdvancedAgent',
+ *   aiProviders: [openaiProvider],
+ *   defaultModel: {
+ *     provider: 'openai',
+ *     model: 'gpt-4'
+ *   },
+ *   tools: [weatherTool, calculatorTool],
+ *   plugins: [
+ *     new LoggingPlugin({ level: 'info' }),
+ *     new UsagePlugin({ trackTokens: true })
+ *   ]
+ * });
+ *
+ * const response = await robota.run('What\'s the weather in Tokyo?');
+ * ```
+ *
+ * @example Streaming Response
+ * ```typescript
+ * for await (const chunk of robota.runStream('Tell me a story')) {
+ *   process.stdout.write(chunk);
+ * }
+ * ```
+ */
+export declare class Robota extends AbstractAgent<IAgentConfig, IRunOptions, TUniversalMessage> implements IAgent<IAgentConfig, IRunOptions, TUniversalMessage> {
+    /** The name of this agent instance */
+    readonly name: string;
+    /** The version of the Robota agent implementation */
+    readonly version: string;
+    private aiProviders;
+    private tools;
+    private agentFactory;
+    private conversationHistory;
+    private moduleRegistry;
+    private eventEmitter;
+    private executionService;
+    private eventService;
+    private agentEventService;
+    protected config: IAgentConfig;
+    private conversationId;
+    private logger;
+    private initializationPromise?;
+    private isFullyInitialized;
+    private startTime;
+    private configVersion;
+    private configUpdatedAt;
+    /**
+     * Creates a new Robota agent instance with the new aiProviders array design.
+     *
+     * The constructor performs synchronous initialization and validation.
+     * Async initialization (AI provider setup, tool registration) is deferred
+     * until the first run() call for optimal performance.
+     *
+     * @param config - Configuration options for the agent
+     * @throws {ConfigurationError} When required configuration is missing or invalid
+     * @throws {ValidationError} When configuration values are invalid
+     *
+     * @example
+     * ```typescript
+     * const robota = new Robota({
+     *   name: 'CustomerSupport',
+     *   aiProviders: [
+     *     new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }),
+     *     new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY })
+     *   ],
+     *   defaultModel: {
+     *     provider: 'openai',
+     *     model: 'gpt-4',
+     *     temperature: 0.7
+     *   },
+     *   tools: [emailTool, ticketTool],
+     *   plugins: [new LoggingPlugin(), new ErrorHandlingPlugin()]
+     * });
+     * ```
+     */
+    constructor(config: IAgentConfig);
+    /**
+     * Update tools for this agent instance.
+     * Rebuilds the Tools registry atomically and emits CONFIG_UPDATED event.
+     */
+    updateTools(next: Array<IToolWithEventService>): Promise<{
+        version: number;
+    }>;
+    /**
+     * Update configuration partially. Currently supports tools.
+     */
+    updateConfiguration(patch: Partial<IAgentConfig>): Promise<{
+        version: number;
+    }>;
+    /**
+     * Read-only configuration overview for UI.
+     */
+    getConfiguration(): Promise<{
+        version: number;
+        tools: Array<{
+            name: string;
+            parameters?: string[];
+        }>;
+        updatedAt: number;
+        metadata?: TAgentStatsMetadata;
+    }>;
+    private emitAgentEvent;
+    private buildOwnerPath;
+    /**
+     * Create instance-specific AIProviders manager
+     */
+    private createAIProvidersInstance;
+    /**
+     * Create instance-specific Tools manager
+     */
+    private createToolsInstance;
+    /**
+     * Create instance-specific AgentFactory manager
+     */
+    private createAgentFactoryInstance;
+    /**
+     * Create instance-specific ConversationHistory manager
+     */
+    private createConversationHistoryInstance;
+    /**
+     * Create instance-specific EventEmitter plugin
+     */
+    private createEventEmitterInstance;
+    /**
+     * Create instance-specific ModuleRegistry
+     */
+    private createModuleRegistryInstance;
+    /**
+     * Ensure full initialization has occurred
+     */
+    private ensureFullyInitialized;
+    /**
+     * Perform actual async initialization
+     */
+    private performAsyncInitialization;
+    /**
+     * Initialize the agent if not already done
+     *
+     * Note: This is a protected lifecycle hook required by AbstractAgent.
+     * Do not mark it as an internal tag, because DTS generation uses `stripInternal`
+     * and would remove this method from the public type surface, breaking the
+     * abstract contract in `.d.ts`.
+     */
+    protected initialize(): Promise<void>;
+    /**
+     * Execute a conversation turn with the AI agent.
+     *
+     * This is the primary method for interacting with the agent. It processes user input,
+     * manages conversation history, executes any required tools, and returns the AI response.
+     * The method automatically initializes the agent on first use.
+     *
+     * @param input - The user's message or prompt to send to the AI
+     * @param options - Optional configuration for this specific execution
+     * @returns Promise that resolves to the AI's response as a string
+     *
+     * @throws {ConfigurationError} When the agent configuration is invalid
+     * @throws {ProviderError} When the AI provider encounters an error
+     * @throws {ToolExecutionError} When a tool execution fails
+     *
+     * @example Basic conversation
+     * ```typescript
+     * const response = await robota.run('Hello, how are you?');
+     * console.log(response); // "Hello! I'm doing well, thank you for asking..."
+     * ```
+     *
+     * @example With execution options
+     * ```typescript
+     * const response = await robota.run('Analyze this data', {
+     *   sessionId: 'user-123',
+     *   userId: 'john.doe',
+     *   metadata: { source: 'web-app', priority: 'high' }
+     * });
+     * ```
+     *
+     * @example Error handling
+     * ```typescript
+     * try {
+     *   const response = await robota.run('Complex request');
+     * } catch (error) {
+     *   if (error instanceof ToolExecutionError) {
+     *     console.error('Tool failed:', error.toolName, error.message);
+     *   }
+     * }
+     * ```
+     */
+    run(input: string, options?: IRunOptions): Promise<string>;
+    /**
+     * Execute a conversation turn with streaming response.
+     *
+     * Similar to run() but returns an async generator that yields response chunks
+     * as they arrive from the AI provider. This enables real-time streaming of
+     * the AI's response for better user experience.
+     *
+     * @param input - The user's message or prompt to send to the AI
+     * @param options - Optional configuration for this specific execution
+     * @returns AsyncGenerator that yields string chunks of the AI response
+     *
+     * @throws {ConfigurationError} When the agent configuration is invalid
+     * @throws {ProviderError} When the AI provider encounters an error
+     * @throws {ToolExecutionError} When a tool execution fails
+     *
+     * @example Basic streaming
+     * ```typescript
+     * for await (const chunk of robota.runStream('Tell me a story')) {
+     *   process.stdout.write(chunk);
+     * }
+     * console.log('\n'); // New line after story
+     * ```
+     *
+     * @example Collecting full response
+     * ```typescript
+     * let fullResponse = '';
+     * for await (const chunk of robota.runStream('Explain quantum computing')) {
+     *   fullResponse += chunk;
+     *   updateUI(chunk); // Update UI in real-time
+     * }
+     * console.log('Complete response:', fullResponse);
+     * ```
+     *
+     * @example Error handling in streams
+     * ```typescript
+     * try {
+     *   for await (const chunk of robota.runStream('Complex request')) {
+     *     handleChunk(chunk);
+     *   }
+     * } catch (error) {
+     *   console.error('Streaming failed:', error.message);
+     * }
+     * ```
+     */
+    runStream(input: string, options?: IRunOptions): AsyncGenerator<string, void, undefined>;
+    /**
+     * Get the conversation history for this agent instance.
+     *
+     * Returns an array of messages representing the complete conversation history
+     * for this agent's conversation session. The history includes user messages,
+     * assistant responses, and tool call results.
+     *
+     * @returns Array of TUniversalMessage objects representing the conversation history
+     *
+     * @example
+     * ```typescript
+     * await robota.run('What is 2 + 2?');
+     * await robota.run('What about 3 + 3?');
+     *
+     * const history = robota.getHistory();
+     * console.log(history.length); // 4 (2 user messages, 2 assistant responses)
+     * console.log(history[0].role); // 'user'
+     * console.log(history[0].content); // 'What is 2 + 2?'
+     * ```
+     */
+    getHistory(): TUniversalMessage[];
+    /**
+     * Clear the conversation history for this agent instance.
+     *
+     * Removes all messages from the conversation history, starting fresh.
+     * This does not affect the agent's configuration or other state.
+     *
+     * @example
+     * ```typescript
+     * await robota.run('First message');
+     * console.log(robota.getHistory().length); // 2 (user + assistant)
+     *
+     * robota.clearHistory();
+     * console.log(robota.getHistory().length); // 0
+     * ```
+     */
+    clearHistory(): void;
+    /**
+     * Add a plugin to the agent at runtime.
+     *
+     * Plugins provide extensible functionality through lifecycle hooks.
+     * This method allows dynamic addition of plugins after agent creation.
+     *
+     * @param plugin - The plugin instance to add
+     *
+     * @example
+     * ```typescript
+     * import { UsagePlugin, PerformancePlugin } from '@robota-sdk/agents';
+     *
+     * const robota = new Robota(config);
+     *
+     * // Add plugins dynamically
+     * robota.addPlugin(new UsagePlugin({ trackTokens: true }));
+     * robota.addPlugin(new PerformancePlugin({ trackMemory: true }));
+     * ```
+     */
+    addPlugin(plugin: IPluginContract<IPluginOptions, IPluginStats> & IPluginHooks): void;
+    /**
+     * Remove a plugin from the agent by name.
+     *
+     * @param pluginName - The name of the plugin to remove
+     * @returns true if the plugin was found and removed, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const removed = robota.removePlugin('usage-plugin');
+     * if (removed) {
+     *   console.log('Plugin removed successfully');
+     * } else {
+     *   console.log('Plugin not found');
+     * }
+     * ```
+     */
+    removePlugin(pluginName: string): boolean;
+    /**
+     * Get a specific plugin by name with type safety.
+     *
+     * @template T - The expected plugin type extending AbstractPlugin
+     * @param pluginName - The name of the plugin to retrieve
+     * @returns The plugin instance if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * import { UsagePlugin } from '@robota-sdk/agents';
+     *
+     * const usagePlugin = robota.getPlugin<UsagePlugin>('usage-plugin');
+     * if (usagePlugin) {
+     *   const stats = usagePlugin.getUsageStats();
+     *   console.log('Token usage:', stats.totalTokens);
+     * }
+     * ```
+     */
+    getPlugin(pluginName: string): (IPluginContract<IPluginOptions, IPluginStats> & IPluginHooks) | null;
+    /**
+     * Get all registered plugins.
+     *
+     * @returns Array of all currently registered plugin instances
+     *
+     * @example
+     * ```typescript
+     * const plugins = robota.getPlugins();
+     * console.log(`Agent has ${plugins.length} plugins registered`);
+     * plugins.forEach(plugin => {
+     *   console.log(`- ${plugin.name} (${plugin.version})`);
+     * });
+     * ```
+     */
+    getPlugins(): Array<IPluginContract<IPluginOptions, IPluginStats> & IPluginHooks>;
+    /**
+     * Get all registered plugin names
+     */
+    getPluginNames(): string[];
+    /**
+     * Register a new module with the agent
+     * @param module - The module instance to register
+     * @param options - Registration options
+     */
+    registerModule(module: IModule, options?: {
+        autoInitialize?: boolean;
+        validateDependencies?: boolean;
+    }): Promise<void>;
+    /**
+     * Unregister a module from the agent
+     * @param moduleName - Name of the module to unregister
+     * @returns True if module was unregistered, false if not found
+     */
+    unregisterModule(moduleName: string): Promise<boolean>;
+    /**
+     * Get a module by name with type safety
+     * @param moduleName - Name of the module to retrieve
+     * @returns The module instance or null if not found
+     */
+    getModule(moduleName: string): IModule | null;
+    /**
+     * Get modules by type
+     * @param moduleType - Type of modules to retrieve
+     * @returns Array of modules matching the type
+     */
+    getModulesByType(moduleType: string): IModule[];
+    /**
+     * Get all registered modules
+     * @returns Array of all registered modules
+     */
+    getModules(): IModule[];
+    /**
+     * Get all registered module names
+     * @returns Array of module names
+     */
+    getModuleNames(): string[];
+    /**
+     * Check if a module is registered
+     * @param moduleName - Name of the module to check
+     * @returns True if module is registered
+     */
+    hasModule(moduleName: string): boolean;
+    /**
+     * Execute a module by name
+     * @param moduleName - Name of the module to execute
+     * @param context - Execution context
+     * @returns Module execution result
+     */
+    executeModule(moduleName: string, context: {
+        executionId?: string;
+        sessionId?: string;
+        userId?: string;
+        metadata?: Record<string, string | number | boolean | Date>;
+    }): Promise<{
+        success: boolean;
+        data?: IModuleResultData;
+        error?: Error;
+        duration?: number;
+    }>;
+    /**
+     * Get module execution statistics
+     * @param moduleName - Name of the module
+     * @returns Module statistics or null if not found
+     */
+    getModuleStats(moduleName: string): {
+        totalExecutions: number;
+        successfulExecutions: number;
+        failedExecutions: number;
+        averageExecutionTime: number;
+        lastExecutionTime?: Date;
+    } | null;
+    /**
+     * Register a new AI provider at runtime.
+     *
+     * Allows dynamic addition of AI providers after agent creation.
+     * The provider can then be selected using switchProvider().
+     *
+     * @param name - Unique name for the provider
+     * @param provider - The AI provider instance to register
+     *
+     * @example
+     * ```typescript
+     * import { AnthropicProvider } from '@robota-sdk/anthropic';
+     *
+     * const anthropicProvider = new AnthropicProvider({
+     *   apiKey: process.env.ANTHROPIC_API_KEY
+     * });
+     *
+     * robota.registerProvider('anthropic', anthropicProvider);
+     * robota.switchProvider('anthropic', 'claude-3-opus-20240229');
+     * ```
+     */
+    /**
+     * Set the current model configuration (complete replacement).
+     *
+     * Updates the current AI provider, model, and related settings. This completely
+     * replaces the current model configuration with the new values.
+     *
+     * @param modelConfig - New model configuration
+     *
+     * @throws {ConfigurationError} When the provider is not available
+     *
+     * @example
+     * ```typescript
+     * // Switch to a different provider and model
+     * robota.setModel({
+     *   provider: 'anthropic',
+     *   model: 'claude-3-opus',
+     *   temperature: 0.9,
+     *   maxTokens: 4000
+     * });
+     *
+     * // Simple model change
+     * robota.setModel({
+     *   provider: 'openai',
+     *   model: 'gpt-4-turbo'
+     * });
+     * ```
+     */
+    setModel(modelConfig: {
+        provider: string;
+        model: string;
+        temperature?: number;
+        maxTokens?: number;
+        topP?: number;
+        systemMessage?: string;
+    }): void;
+    /**
+     * Get the current model configuration.
+     *
+     * Returns the current AI provider, model, and related settings.
+     *
+     * @returns Current model configuration
+     *
+     * @example
+     * ```typescript
+     * const current = robota.getModel();
+     * console.log(`Current: ${current.provider}/${current.model}`);
+     * console.log(`Temperature: ${current.temperature}`);
+     * console.log(`Max tokens: ${current.maxTokens}`);
+     * ```
+     */
+    getModel(): {
+        provider: string;
+        model: string;
+        temperature?: number;
+        maxTokens?: number;
+        topP?: number;
+        systemMessage?: string;
+    };
+    /**
+     * Register a new tool for function calling.
+     *
+     * Adds a tool that the AI can call during conversations. The tool's schema
+     * defines its name, description, and parameters for the AI to understand.
+     *
+     * @param tool - The tool instance to register
+     *
+     * @example
+     * ```typescript
+     * import { AbstractTool } from '@robota-sdk/agents';
+     *
+     * class WeatherTool extends AbstractTool {
+     *   name = 'get_weather';
+     *   description = 'Get current weather for a location';
+     *
+     *   get schema() {
+     *     return {
+     *       name: this.name,
+     *       description: this.description,
+     *       parameters: {
+     *         type: 'object',
+     *         properties: {
+     *           location: { type: 'string', description: 'City name' }
+     *         },
+     *         required: ['location']
+     *       }
+     *     };
+     *   }
+     *
+     *   async execute(params: { location: string }) {
+     *     // Implementation here
+     *     return { temperature: 22, condition: 'sunny' };
+     *   }
+     * }
+     *
+     * robota.registerTool(new WeatherTool());
+     * ```
+     */
+    registerTool(tool: AbstractTool): void;
+    /**
+     * Unregister a tool by name.
+     *
+     * Removes a previously registered tool, making it unavailable for future AI calls.
+     *
+     * @param toolName - Name of the tool to unregister
+     *
+     * @example
+     * ```typescript
+     * robota.unregisterTool('weather-tool');
+     *
+     * const stats = robota.getStats();
+     * console.log('Remaining tools:', stats.tools);
+     * ```
+     */
+    unregisterTool(toolName: string): void;
+    /**
+     * Get the current agent configuration.
+     *
+     * Returns a copy of the current configuration object. Modifications to the
+     * returned object do not affect the agent - use updateConfig() to make changes.
+     *
+     * @returns Copy of the current IAgentConfig
+     *
+     * @example
+     * ```typescript
+     * const config = robota.getConfig();
+     * console.log('Current model:', config.currentModel);
+     * console.log('Available providers:', Object.keys(config.aiProviders || {}));
+     * ```
+     */
+    getConfig(): IAgentConfig;
+    /**
+     * Get comprehensive agent statistics including providers, tools, plugins, modules, and performance data.
+     *
+     * @returns Object containing all agent statistics and metadata
+     *
+     * @example
+     * ```typescript
+     * const stats = robota.getStats();
+     * console.log(`Agent: ${stats.name} v${stats.version}`);
+     * console.log(`Uptime: ${stats.uptime}ms`);
+     * console.log(`Providers: ${stats.providers.join(', ')}`);
+     * console.log(`Tools: ${stats.tools.join(', ')}`);
+     * console.log(`Plugins: ${stats.plugins.join(', ')}`);
+     * console.log(`Modules: ${stats.modules.join(', ')}`);
+     * console.log(`Messages: ${stats.historyLength}`);
+     * ```
+     */
+    getStats(): {
+        name: string;
+        version: string;
+        conversationId: string;
+        providers: string[];
+        currentProvider: string | null;
+        tools: string[];
+        plugins: string[];
+        modules: string[];
+        historyLength: number;
+        historyStats: TAgentStatsMetadata;
+        uptime: number;
+    };
+    /**
+     * Validate the new agent configuration format.
+     * @internal
+     */
+    private validateNewConfig;
+    /**
+     * Clean up and dispose of the agent instance.
+     *
+     * This method properly cleans up all resources, managers, and services
+     * to prevent memory leaks and ensure graceful shutdown.
+     *
+     * @example
+     * ```typescript
+     * // Clean shutdown
+     * await robota.destroy();
+     * console.log('Agent destroyed');
+     * ```
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=robota.d.ts.map

package/dist/core/robota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"robota.d.ts","sourceRoot":"","sources":["../../src/core/robota.ts"],"names":[],"mappings":"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"}