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

package/dist/abstracts/abstract-tool.d.ts

@@ -0,0 +1,175 @@
+/**
+ * @fileoverview Abstract Tool Base Class
+ *
+ * 🎯 ABSTRACT CLASS - DO NOT DEPEND ON CONCRETE IMPLEMENTATIONS
+ *
+ * This is a pure abstract base class that defines the interface and common behavior
+ * for all tools. It follows strict architectural principles:
+ *
+ * - Depends ONLY on interfaces (EventService interface, not concrete implementations)
+ * - Does NOT import concrete classes
+ * - Uses Dependency Injection for all dependencies
+ * - Handles undefined dependencies gracefully (Null Object Pattern)
+ *
+ * Concrete implementations should be handled
+ * by the caller who creates the tool instance, not by this abstract class.
+ *
+ * @example
+ * ```typescript
+ * // ✅ CORRECT: Caller prepares an owner-bound EventService and injects it
+ * // (Example: bind to the current tool call identity and ownerPath.)
+ * const toolEventService = bindWithOwnerPath(baseEventService, {
+ *   ownerType: 'tool',
+ *   ownerId: toolCallId,
+ *   ownerPath,
+ * });
+ * const tool = new MyTool({ eventService: toolEventService });
+ *
+ * // ❌ WRONG: AbstractTool creates concrete EventService
+ * // This violates Dependency Inversion Principle
+ * ```
+ */
+import type { IToolResult, IToolExecutionContext, IParameterValidationResult, TToolParameters } from '../interfaces/tool';
+import type { IToolSchema } from '../interfaces/provider';
+import type { ILogger } from '../utils/logger';
+import type { IBaseEventData, IEventService } from '../services/event-service';
+/**
+ * Options for AbstractTool construction
+ */
+export interface IAbstractToolOptions {
+    /**
+     * Optional logger for tool operations
+     * Defaults to SilentLogger if not provided
+     */
+    logger?: ILogger;
+    /**
+     * Optional event service for unified event emission
+     * If not provided, tool will operate silently without emitting events
+     *
+     * The caller should provide an EventService configured with appropriate settings
+     * (e.g., ownerPrefix='tool' for tool events)
+     *
+     * @since 2.1.0
+     */
+    eventService?: IEventService;
+}
+/**
+ * Tool execution function type with proper parameter constraints
+ */
+export type TToolExecutionFunction<TParams = TToolParameters, TResult = IToolResult> = (parameters: TParams) => Promise<TResult> | TResult;
+/**
+ * Abstract tool interface with type parameters for enhanced type safety
+ *
+ * @template TParams - Tool parameters type (defaults to AbstractToolParameters for backward compatibility)
+ * @template TResult - Tool result type (defaults to ToolResult for backward compatibility)
+ */
+export interface IAbstractTool<TParams = TToolParameters, TResult = IToolResult> {
+    name: string;
+    description: string;
+    parameters: IToolSchema['parameters'];
+    execute: TToolExecutionFunction<TParams, TResult>;
+}
+/**
+ * Type-safe tool interface with type parameters
+ *
+ * @template TParameters - Tool parameters type (defaults to AbstractToolParameters for backward compatibility)
+ * @template TResult - Tool result type (defaults to ToolResult for backward compatibility)
+ */
+export interface IToolContract<TParameters = TToolParameters, TResult = IToolResult> {
+    readonly schema: IToolSchema;
+    execute(parameters: TParameters, context: IToolExecutionContext): Promise<TResult>;
+    validate(parameters: TParameters): boolean;
+    validateParameters(parameters: TParameters): IParameterValidationResult;
+    getDescription(): string;
+    getName(): string;
+}
+/**
+ * Runtime tool instance contract used by Robota internals.
+ *
+ * Tools passed into Agent configuration must support EventService injection
+ * so Robota can emit unified tool lifecycle events.
+ */
+export interface IToolWithEventService<TParameters = TToolParameters, TResult = IToolResult> extends IToolContract<TParameters, TResult> {
+    setEventService(eventService: IEventService | undefined): void;
+}
+/**
+ * Abstract base class for tools with type parameter support
+ * Provides type-safe parameter handling and result processing
+ *
+ * 🎯 ARCHITECTURAL PRINCIPLES:
+ * - Pure abstract class - depends only on interfaces
+ * - No concrete class dependencies (EventService interface only)
+ * - Dependency Injection for all external dependencies
+ * - Graceful degradation (undefined dependencies = silent operation)
+ *
+ * @template TParameters - Tool parameters type (defaults to TToolParameters)
+ * @template TResult - Tool result type (defaults to ToolResult for backward compatibility)
+ */
+export declare abstract class AbstractTool<TParameters = TToolParameters, TResult = IToolResult> implements IToolWithEventService<TParameters, TResult> {
+    abstract readonly schema: IToolSchema;
+    /**
+     * Logger for tool operations
+     */
+    protected readonly logger: ILogger;
+    /**
+     * EventService for direct event emission (optional)
+     * If undefined, tool operates silently without emitting events
+     */
+    private eventService;
+    /**
+     * Constructor with simplified options
+     *
+     * 🎯 DEPENDENCY INJECTION:
+     * All dependencies are injected via options parameter
+     * No concrete classes are instantiated within this constructor
+     *
+     * @param options - Configuration options for the tool
+     */
+    constructor(options?: IAbstractToolOptions);
+    /**
+     * Set EventService for post-construction injection
+     *
+     * 🎯 DEPENDENCY INJECTION:
+     * Accepts EventService as-is without transformation
+     * Caller is responsible for providing properly configured EventService
+     *
+     * @param eventService - EventService instance to use for event emission (or undefined for silent operation)
+     */
+    setEventService(eventService: IEventService | undefined): void;
+    /**
+     * Get current EventService (for testing/inspection)
+     */
+    protected getEventService(): IEventService | undefined;
+    /**
+     * Emit event through EventService (if available)
+     * If EventService is not available, silently ignores the event (Null Object Pattern)
+     *
+     * @param eventType - Type of event to emit
+     * @param data - Event data
+     */
+    protected emitEvent(eventType: string, data: IBaseEventData): void;
+    /**
+     * Execute tool with simplified lifecycle
+     * @param parameters - Tool parameters
+     * @param context - Optional execution context
+     * @returns Promise resolving to tool result
+     */
+    execute(parameters: TParameters, context: IToolExecutionContext): Promise<TResult>;
+    /**
+     * Concrete implementation of tool execution
+     * This method should be implemented by subclasses to provide actual tool logic
+     *
+     * @param parameters - Tool parameters
+     * @param context - Optional execution context
+     * @returns Promise resolving to tool result
+     */
+    protected abstract executeImpl(parameters: TParameters, context: IToolExecutionContext): Promise<TResult>;
+    validate(parameters: TParameters): boolean;
+    /**
+     * Validate tool parameters with detailed result (default implementation)
+     */
+    validateParameters(parameters: TParameters): IParameterValidationResult;
+    getDescription(): string;
+    getName(): string;
+}
+//# sourceMappingURL=abstract-tool.d.ts.map

package/dist/abstracts/abstract-tool.d.ts.map

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

package/dist/abstracts/abstract-tool.js

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview Abstract Tool Base Class
+ *
+ * 🎯 ABSTRACT CLASS - DO NOT DEPEND ON CONCRETE IMPLEMENTATIONS
+ *
+ * This is a pure abstract base class that defines the interface and common behavior
+ * for all tools. It follows strict architectural principles:
+ *
+ * - Depends ONLY on interfaces (EventService interface, not concrete implementations)
+ * - Does NOT import concrete classes
+ * - Uses Dependency Injection for all dependencies
+ * - Handles undefined dependencies gracefully (Null Object Pattern)
+ *
+ * Concrete implementations should be handled
+ * by the caller who creates the tool instance, not by this abstract class.
+ *
+ * @example
+ * ```typescript
+ * // ✅ CORRECT: Caller prepares an owner-bound EventService and injects it
+ * // (Example: bind to the current tool call identity and ownerPath.)
+ * const toolEventService = bindWithOwnerPath(baseEventService, {
+ *   ownerType: 'tool',
+ *   ownerId: toolCallId,
+ *   ownerPath,
+ * });
+ * const tool = new MyTool({ eventService: toolEventService });
+ *
+ * // ❌ WRONG: AbstractTool creates concrete EventService
+ * // This violates Dependency Inversion Principle
+ * ```
+ */
+import { SilentLogger } from '../utils/logger';
+/**
+ * Abstract base class for tools with type parameter support
+ * Provides type-safe parameter handling and result processing
+ *
+ * 🎯 ARCHITECTURAL PRINCIPLES:
+ * - Pure abstract class - depends only on interfaces
+ * - No concrete class dependencies (EventService interface only)
+ * - Dependency Injection for all external dependencies
+ * - Graceful degradation (undefined dependencies = silent operation)
+ *
+ * @template TParameters - Tool parameters type (defaults to TToolParameters)
+ * @template TResult - Tool result type (defaults to ToolResult for backward compatibility)
+ */
+export class AbstractTool {
+    /**
+     * Logger for tool operations
+     */
+    logger;
+    /**
+     * EventService for direct event emission (optional)
+     * If undefined, tool operates silently without emitting events
+     */
+    eventService;
+    /**
+     * Constructor with simplified options
+     *
+     * 🎯 DEPENDENCY INJECTION:
+     * All dependencies are injected via options parameter
+     * No concrete classes are instantiated within this constructor
+     *
+     * @param options - Configuration options for the tool
+     */
+    constructor(options = {}) {
+        // Accept eventService as-is (no wrapping, no transformation)
+        // Caller is responsible for providing properly configured EventService
+        this.eventService = options.eventService;
+        this.logger = options.logger ?? SilentLogger;
+    }
+    /**
+     * Set EventService for post-construction injection
+     *
+     * 🎯 DEPENDENCY INJECTION:
+     * Accepts EventService as-is without transformation
+     * Caller is responsible for providing properly configured EventService
+     *
+     * @param eventService - EventService instance to use for event emission (or undefined for silent operation)
+     */
+    setEventService(eventService) {
+        this.eventService = eventService;
+    }
+    /**
+     * Get current EventService (for testing/inspection)
+     */
+    getEventService() {
+        return this.eventService;
+    }
+    /**
+     * Emit event through EventService (if available)
+     * If EventService is not available, silently ignores the event (Null Object Pattern)
+     *
+     * @param eventType - Type of event to emit
+     * @param data - Event data
+     */
+    emitEvent(eventType, data) {
+        if (!this.eventService) {
+            // Silent operation - no EventService available
+            return;
+        }
+        this.eventService.emit(eventType, data);
+    }
+    /**
+     * Execute tool with simplified lifecycle
+     * @param parameters - Tool parameters
+     * @param context - Optional execution context
+     * @returns Promise resolving to tool result
+     */
+    async execute(parameters, context) {
+        return await this.executeImpl(parameters, context);
+    }
+    validate(parameters) {
+        const required = this.schema.parameters.required || [];
+        return required.every(field => field in parameters);
+    }
+    /**
+     * Validate tool parameters with detailed result (default implementation)
+     */
+    validateParameters(parameters) {
+        const required = this.schema.parameters.required || [];
+        const errors = [];
+        const paramObj = parameters;
+        for (const field of required) {
+            if (!(field in paramObj)) {
+                errors.push(`Missing required parameter: ${field}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    getDescription() {
+        return this.schema.description;
+    }
+    getName() {
+        return this.schema.name;
+    }
+}
+//# sourceMappingURL=abstract-tool.js.map

package/dist/abstracts/abstract-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-tool.js","sourceRoot":"","sources":["../../src/abstracts/abstract-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAsE/C;;;;;;;;;;;;GAYG;AACH,MAAM,OAAgB,YAAY;IAK9B;;OAEG;IACgB,MAAM,CAAU;IAEnC;;;OAGG;IACK,YAAY,CAA4B;IAEhD;;;;;;;;OAQG;IACH,YAAY,UAAgC,EAAE;QAC1C,6DAA6D;QAC7D,uEAAuE;QACvE,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,YAAY,CAAC;IACjD,CAAC;IAED;;;;;;;;OAQG;IACH,eAAe,CAAC,YAAuC;QACnD,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACrC,CAAC;IAED;;OAEG;IACO,eAAe;QACrB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACO,SAAS,CAAC,SAAiB,EAAE,IAAoB;QACvD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACrB,+CAA+C;YAC/C,OAAO;QACX,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CAAC,UAAuB,EAAE,OAA8B;QACjE,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAYD,QAAQ,CAAC,UAAuB;QAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC;QACvD,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,IAAK,UAAwD,CAAC,CAAC;IACvG,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,UAAuB;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC;QACvD,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,UAAuD,CAAC;QAEzE,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC3B,IAAI,CAAC,CAAC,KAAK,IAAI,QAAQ,CAAC,EAAE,CAAC;gBACvB,MAAM,CAAC,IAAI,CAAC,+BAA+B,KAAK,EAAE,CAAC,CAAC;YACxD,CAAC;QACL,CAAC;QAED,OAAO;YACH,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;YAC5B,MAAM;SACT,CAAC;IACN,CAAC;IAED,cAAc;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;IACnC,CAAC;IAED,OAAO;QACH,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC5B,CAAC;CACJ"}

package/dist/abstracts/abstract-workflow-converter.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Abstract Workflow Converter
+ *
+ * Abstract base class for all workflow converters in the Robota SDK.
+ * Uses an enabled flag + injected logger pattern.
+ *
+ * @template TInput - Input workflow data type
+ * @template TOutput - Output workflow data type
+ */
+import type { IWorkflowConverter, IWorkflowConversionOptions, IWorkflowConversionResult, IWorkflowData, IWorkflowConfig } from '../interfaces/workflow-converter';
+import type { ILogger } from '../utils/logger';
+import type { TUniversalValue } from '../interfaces/types';
+/**
+ * Converter options (enabled flag + injected logger).
+ */
+export interface IBaseWorkflowConverterOptions {
+    /** Enable/disable the converter */
+    enabled?: boolean;
+    /** Custom logger instance */
+    logger?: ILogger;
+    /** Converter-specific configuration */
+    config?: IWorkflowConfig;
+}
+/**
+ * Base Workflow Converter Abstract Class
+ *
+ * Provides common functionality for all workflow converters:
+ * - Statistics tracking
+ * - Logging with dependency injection
+ * - Error handling and validation
+ * - Performance monitoring
+ * - Enable/disable functionality
+ *
+ * @template TInput - Input workflow data type
+ * @template TOutput - Output workflow data type
+ */
+export declare abstract class AbstractWorkflowConverter<TInput extends IWorkflowData, TOutput extends IWorkflowData> implements IWorkflowConverter<TInput, TOutput> {
+    abstract readonly name: string;
+    abstract readonly version: string;
+    abstract readonly sourceFormat: string;
+    abstract readonly targetFormat: string;
+    /** Enable/disable state */
+    enabled: boolean;
+    /** Logger instance with dependency injection */
+    protected readonly logger: ILogger;
+    /** Converter configuration */
+    protected readonly config: IWorkflowConfig;
+    /** Statistics tracking */
+    private stats;
+    /**
+     * Constructor
+     *
+     * @param options - Converter configuration options
+     */
+    constructor(options?: IBaseWorkflowConverterOptions);
+    /**
+     * Main conversion method with comprehensive error handling and metrics
+     *
+     * @param input - Input workflow data
+     * @param options - Conversion options
+     * @returns Promise resolving to conversion result
+     */
+    convert(input: TInput, options?: IWorkflowConversionOptions): Promise<IWorkflowConversionResult<TOutput>>;
+    /**
+     * Abstract method for actual conversion logic
+     * Must be implemented by subclasses
+     *
+     * @param input - Input workflow data
+     * @param options - Conversion options
+     * @returns Promise resolving to converted data
+     */
+    protected abstract performConversion(input: TInput, options: IWorkflowConversionOptions): Promise<TOutput>;
+    /**
+     * Default input validation (can be overridden by subclasses)
+     *
+     * @param input - Input workflow data
+     * @returns Promise resolving to validation result
+     */
+    validateInput(input: TInput): Promise<{
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Default output validation (can be overridden by subclasses)
+     *
+     * @param output - Output workflow data
+     * @returns Promise resolving to validation result
+     */
+    validateOutput(output: TOutput): Promise<{
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    /**
+     * Default implementation for checking if converter can handle input
+     * Should be overridden by subclasses for specific type checking
+     *
+     * @param input - Input data to check
+     * @returns True if converter can handle this input
+     */
+    canConvert(input: IWorkflowData): input is TInput;
+    /**
+     * Get converter statistics
+     *
+     * @returns Converter performance metrics
+     */
+    getStats(): {
+        totalConversions: number;
+        successfulConversions: number;
+        failedConversions: number;
+        averageProcessingTime: number;
+        lastConversionAt: Date | undefined;
+    };
+    /**
+     * Reset converter statistics
+     */
+    resetStats(): void;
+    /**
+     * Create success result with metadata
+     */
+    protected createSuccessResult(data: TOutput, startTime: number, input: TInput, options: IWorkflowConversionOptions): IWorkflowConversionResult<TOutput>;
+    /**
+     * Create failure result with error information
+     */
+    protected createFailureResult(errors: string[], warnings: string[], startTime: number, input: TInput, _logger: ILogger): IWorkflowConversionResult<TOutput>;
+    /**
+     * Extract basic statistics from workflow data
+     * Can be overridden by subclasses for specific data formats
+     */
+    protected getDataStats(data: Record<string, TUniversalValue>): {
+        nodeCount: number;
+        edgeCount: number;
+    };
+}
+//# sourceMappingURL=abstract-workflow-converter.d.ts.map

package/dist/abstracts/abstract-workflow-converter.d.ts.map

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