task-o-matic-core 0.1.0

package/dist/lib/ai-service/retry-handler.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryHandler = void 0;
+const logger_1 = require("../logger");
+class RetryHandler {
+    getRetryConfig() {
+        return {
+            maxAttempts: parseInt(process.env.AI_MAX_RETRY_ATTEMPTS || "3", 10),
+            baseDelay: parseInt(process.env.AI_RETRY_BASE_DELAY || "1000", 10),
+            maxDelay: parseInt(process.env.AI_RETRY_MAX_DELAY || "10000", 10),
+            backoffFactor: parseFloat(process.env.AI_RETRY_BACKOFF_FACTOR || "2"),
+            retryableErrors: [
+                "ECONNRESET",
+                "ENOTFOUND",
+                "ECONNREFUSED",
+                "ETIMEDOUT",
+                "NETWORK_ERROR",
+                "RATE_LIMIT",
+                "TEMPORARY_FAILURE",
+                "INTERNAL_ERROR",
+            ],
+        };
+    }
+    shouldRetryError(error, retryableErrors) {
+        if (!error)
+            return false;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorName = error instanceof Error ? error.name : "";
+        return retryableErrors.some((retryableError) => errorMessage.toUpperCase().includes(retryableError) ||
+            errorName.toUpperCase().includes(retryableError));
+    }
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async executeWithRetry(operation, retryConfig, operationName = "AI operation") {
+        const finalRetryConfig = { ...this.getRetryConfig(), ...retryConfig };
+        const { maxAttempts = 3, baseDelay = 1000, maxDelay = 10000, backoffFactor = 2, retryableErrors = [], } = finalRetryConfig;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on the last attempt
+                if (attempt === maxAttempts) {
+                    break;
+                }
+                // Check if error is retryable
+                if (!this.shouldRetryError(error, retryableErrors)) {
+                    break;
+                }
+                // Calculate delay with exponential backoff
+                const delayMs = Math.min(baseDelay * Math.pow(backoffFactor, attempt - 1), maxDelay);
+                logger_1.logger.warn(`${operationName} failed (attempt ${attempt}/${maxAttempts}), retrying in ${delayMs}ms: ${error}`);
+                await this.delay(delayMs);
+            }
+        }
+        // Throw the original error - NO rebuilding bullshit
+        throw lastError;
+    }
+}
+exports.RetryHandler = RetryHandler;

package/dist/lib/ai-service/task-operations.d.ts

@@ -0,0 +1,13 @@
+import { AIConfig, Task, StreamingOptions, RetryConfig } from "../../types";
+import { BaseOperations } from "./base-operations";
+export declare class TaskOperations extends BaseOperations {
+    private aiOperationUtility;
+    breakdownTask(task: Task, config?: Partial<AIConfig>, promptOverride?: string, userMessage?: string, streamingOptions?: StreamingOptions, retryConfig?: Partial<RetryConfig>, fullContent?: string, stackInfo?: string, existingSubtasks?: Task[], enableFilesystemTools?: boolean): Promise<Array<{
+        title: string;
+        content: string;
+        estimatedEffort?: string;
+    }>>;
+    enhanceTask(title: string, description?: string, config?: Partial<AIConfig>, promptOverride?: string, userMessage?: string, taskId?: string, streamingOptions?: StreamingOptions, retryConfig?: Partial<RetryConfig>): Promise<string>;
+    planTask(taskContext: string, taskDetails: string, config?: Partial<AIConfig>, promptOverride?: string, userMessage?: string, streamingOptions?: StreamingOptions, retryConfig?: Partial<RetryConfig>): Promise<string>;
+}
+//# sourceMappingURL=task-operations.d.ts.map

package/dist/lib/ai-service/task-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-operations.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/task-operations.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,gBAAgB,EAChB,WAAW,EAEZ,MAAM,aAAa,CAAC;AAUrB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAOnD,qBAAa,cAAe,SAAQ,cAAc;IAChD,OAAO,CAAC,kBAAkB,CAA4B;IAChD,aAAa,CACjB,IAAI,EAAE,IAAI,EACV,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EAClC,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,EAClB,gBAAgB,CAAC,EAAE,IAAI,EAAE,EACzB,qBAAqB,CAAC,EAAE,OAAO,GAC9B,OAAO,CACR,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CACpE;IA4HK,WAAW,CACf,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GACjC,OAAO,CAAC,MAAM,CAAC;IA4FZ,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GACjC,OAAO,CAAC,MAAM,CAAC;CAoEnB"}

package/dist/lib/ai-service/task-operations.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskOperations = void 0;
+const prompt_builder_1 = require("../prompt-builder");
+const stack_formatter_1 = require("../../utils/stack-formatter");
+const prompts_1 = require("../../prompts");
+const ai_service_factory_1 = require("../../utils/ai-service-factory");
+const filesystem_tools_1 = require("./filesystem-tools");
+const base_operations_1 = require("./base-operations");
+const ai_operation_utility_1 = require("../../utils/ai-operation-utility");
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+class TaskOperations extends base_operations_1.BaseOperations {
+    aiOperationUtility = new ai_operation_utility_1.AIOperationUtility();
+    async breakdownTask(task, config, promptOverride, userMessage, streamingOptions, retryConfig, fullContent, stackInfo, existingSubtasks, enableFilesystemTools) {
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const variables = {
+                TASK_TITLE: task.title,
+                TASK_DESCRIPTION: task.description || "No description",
+            };
+            if (fullContent) {
+                variables.TASK_CONTENT = fullContent;
+            }
+            if (existingSubtasks && existingSubtasks.length > 0) {
+                const existingSubtasksText = existingSubtasks
+                    .map((subtask, index) => `${index + 1}. ${subtask.title}: ${subtask.description || "No description"}`)
+                    .join("\n");
+                variables.EXISTING_SUBTASKS = existingSubtasksText;
+            }
+            if (stackInfo) {
+                variables.STACK_INFO = stackInfo;
+            }
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-breakdown",
+                type: "user",
+                variables,
+            });
+            if (!promptResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, `Failed to build task breakdown prompt: ${promptResult.error}`, {
+                    context: "Prompt building failed during task breakdown operation",
+                    suggestions: [
+                        "Verify prompt template exists",
+                        "Check variable substitution",
+                    ],
+                });
+            }
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task breakdown", async () => {
+            // Prepare tools if filesystem tools are enabled
+            const tools = enableFilesystemTools ? filesystem_tools_1.filesystemTools : undefined;
+            const response = await this.aiOperationUtility.streamTextWithTools(prompts_1.TASK_BREAKDOWN_SYSTEM_PROMPT +
+                (enableFilesystemTools
+                    ? `
+
+You have access to filesystem tools that allow you to:
+- readFile: Read the contents of any file in the project
+- listDirectory: List contents of directories
+
+Use these tools to understand the project structure, existing code, and dependencies when breaking down tasks into subtasks.`
+                    : ""), userMessage || prompt, config, streamingOptions, tools);
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, parseResult.error || "Failed to parse task breakdown response", {
+                    context: "AI response parsing failed during task breakdown",
+                    suggestions: [
+                        "Check AI response format",
+                        "Verify JSON structure",
+                    ],
+                });
+            }
+            const parsed = parseResult.data;
+            let subtasksList = [];
+            // Handle various output formats (Array, { subtasks: [] }, { tasks: [] })
+            if (Array.isArray(parsed)) {
+                subtasksList = parsed;
+            }
+            else if (parsed && typeof parsed === "object") {
+                subtasksList = parsed.subtasks || parsed.tasks || [];
+            }
+            return subtasksList.map((subtask) => ({
+                title: subtask.title,
+                content: subtask.description || subtask.content || "",
+                estimatedEffort: subtask.effort,
+            }));
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
+    }
+    async enhanceTask(title, description, config, promptOverride, userMessage, taskId, streamingOptions, retryConfig) {
+        // Build context
+        let contextInfo = "";
+        let prdContent = "";
+        if (taskId) {
+            const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+            try {
+                const context = await contextBuilder.buildContext(taskId);
+                if (context.documentation || context.stack || context.prdContent) {
+                    contextInfo = "\n\nAvailable Context:\n";
+                    if (context.stack) {
+                        contextInfo += (0, stack_formatter_1.formatStackForContext)(context.stack) + "\n";
+                    }
+                    if (context.documentation) {
+                        contextInfo += `Documentation Available: ${context.documentation.recap}\n`;
+                        if (context.documentation.files.length > 0) {
+                            contextInfo += `Documentation Files: ${context.documentation.files
+                                .map((f) => f.path)
+                                .join(", ")}\n`;
+                        }
+                    }
+                    if (context.prdContent) {
+                        prdContent = context.prdContent;
+                    }
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-enhancement",
+                type: "user",
+                variables: {
+                    TASK_TITLE: title,
+                    TASK_DESCRIPTION: description || "None",
+                    CONTEXT_INFO: contextInfo,
+                    PRD_CONTENT: prdContent || "No PRD content available",
+                },
+            });
+            if (!promptResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, `Failed to build task enhancement prompt: ${promptResult.error}`, {
+                    context: "Prompt building failed during task enhancement operation",
+                    suggestions: [
+                        "Verify prompt template exists",
+                        "Check variable substitution",
+                    ],
+                });
+            }
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task enhancement", async () => {
+            return await this.aiOperationUtility.streamText("", config, prompts_1.TASK_ENHANCEMENT_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
+    }
+    async planTask(taskContext, taskDetails, config, promptOverride, userMessage, streamingOptions, retryConfig) {
+        // Build prompt
+        let prompt;
+        if (promptOverride) {
+            prompt = promptOverride;
+        }
+        else {
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "task-planning",
+                type: "user",
+                variables: {
+                    TASK_CONTEXT: taskContext,
+                    TASK_DETAILS: taskDetails,
+                },
+            });
+            if (!promptResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.AI_OPERATION_FAILED, `Failed to build task planning prompt: ${promptResult.error}`, {
+                    context: "Prompt building failed during task planning operation",
+                    suggestions: [
+                        "Verify prompt template exists",
+                        "Check variable substitution",
+                    ],
+                });
+            }
+            prompt = promptResult.prompt;
+        }
+        // Execute AI operation with proper error handling
+        const result = await this.aiOperationUtility.executeAIOperation("Task planning", async () => {
+            const mcpTools = await this.context7Client.getMCPTools();
+            const allTools = {
+                ...mcpTools,
+                ...filesystem_tools_1.filesystemTools,
+            };
+            return await this.aiOperationUtility.streamTextWithTools(prompts_1.TASK_PLANNING_SYSTEM_PROMPT +
+                `
+
+You have access to filesystem tools that allow you to:
+- readFile: Read the contents of any file in the project
+- listDirectory: List contents of directories
+
+Use these tools to understand the project structure, existing code, and dependencies when creating implementation plans.`, userMessage || prompt, config, streamingOptions, allTools);
+        }, {
+            streamingOptions,
+            retryConfig,
+            aiConfig: config,
+            maxRetries: retryConfig?.maxAttempts || 2,
+        });
+        // Return the result directly (errors are thrown, not returned)
+        return result.result;
+    }
+}
+exports.TaskOperations = TaskOperations;

package/dist/lib/benchmark/registry.d.ts

@@ -0,0 +1,11 @@
+import { BenchmarkableOperation } from "./types";
+export declare class BenchmarkRegistry {
+    private operations;
+    constructor();
+    register(op: BenchmarkableOperation): void;
+    get(id: string): BenchmarkableOperation | undefined;
+    list(): BenchmarkableOperation[];
+    private registerDefaults;
+}
+export declare const benchmarkRegistry: BenchmarkRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/benchmark/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/lib/benchmark/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAA0B,MAAM,SAAS,CAAC;AAOzE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAAkD;;IAMpE,QAAQ,CAAC,EAAE,EAAE,sBAAsB;IAInC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAInD,IAAI,IAAI,sBAAsB,EAAE;IAIhC,OAAO,CAAC,gBAAgB;CAsRzB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/lib/benchmark/registry.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkRegistry = exports.BenchmarkRegistry = void 0;
+const prd_1 = require("../../services/prd");
+const tasks_1 = require("../../services/tasks");
+const workflow_benchmark_1 = require("../../services/workflow-benchmark");
+class BenchmarkRegistry {
+    operations = new Map();
+    constructor() {
+        this.registerDefaults();
+    }
+    register(op) {
+        this.operations.set(op.id, op);
+    }
+    get(id) {
+        return this.operations.get(id);
+    }
+    list() {
+        return Array.from(this.operations.values());
+    }
+    registerDefaults() {
+        // PRD Parsing Adapter
+        this.register({
+            id: "prd-parse",
+            name: "PRD Parsing",
+            description: "Parse a PRD file into tasks",
+            validateInput: (input) => typeof input.file === "string" && input.file.length > 0,
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.parsePRD({
+                    file: input.file,
+                    workingDirectory: input.workingDirectory,
+                    enableFilesystemTools: input.tools,
+                    promptOverride: input.prompt,
+                    messageOverride: input.message,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+        // PRD Rework Adapter
+        this.register({
+            id: "prd-rework",
+            name: "PRD Rework",
+            description: "Rework a PRD based on feedback",
+            validateInput: (input) => typeof input.file === "string" && typeof input.feedback === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.reworkPRD({
+                    file: input.file,
+                    feedback: input.feedback,
+                    workingDirectory: input.workingDirectory,
+                    enableFilesystemTools: input.tools,
+                    promptOverride: input.prompt,
+                    messageOverride: input.message,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+        // Task Breakdown Adapter
+        this.register({
+            id: "task-breakdown",
+            name: "Task Breakdown",
+            description: "Break down a task into subtasks",
+            validateInput: (input) => typeof input.taskId === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await tasks_1.taskService.splitTask(input.taskId, aiOptions, input.prompt, input.message, streamingOptions, // streaming options
+                input.tools);
+            },
+        });
+        // Workflow Full Execution
+        this.register({
+            id: "workflow-full",
+            name: "Complete Workflow",
+            description: "Execute the complete workflow: initialization, PRD creation, task generation, and splitting",
+            validateInput: (input) => workflow_benchmark_1.workflowBenchmarkService.validateInput(input),
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await workflow_benchmark_1.workflowBenchmarkService.executeWorkflow(input, aiOptions, streamingOptions);
+            },
+        });
+        // Task Create with AI Enhancement
+        this.register({
+            id: "task-create",
+            name: "Task Creation (AI-Enhanced)",
+            description: "Create a new task with AI enhancement using Context7 documentation",
+            validateInput: (input) => typeof input.title === "string" && input.title.length > 0,
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await tasks_1.taskService.createTask({
+                    title: input.title,
+                    content: input.content,
+                    parentId: input.parentId,
+                    effort: input.effort,
+                    aiEnhance: true, // Always use AI enhancement for benchmarking
+                    aiOptions,
+                    streamingOptions,
+                });
+            },
+        });
+        // Task Enhancement
+        this.register({
+            id: "task-enhance",
+            name: "Task Enhancement",
+            description: "Enhance an existing task with AI using Context7 documentation",
+            validateInput: (input) => typeof input.taskId === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await tasks_1.taskService.enhanceTask(input.taskId, aiOptions, streamingOptions);
+            },
+        });
+        // Task Planning
+        this.register({
+            id: "task-plan",
+            name: "Task Planning",
+            description: "Create a detailed implementation plan for a task",
+            validateInput: (input) => typeof input.taskId === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await tasks_1.taskService.planTask(input.taskId, aiOptions, streamingOptions);
+            },
+        });
+        // Task Documentation
+        this.register({
+            id: "task-document",
+            name: "Task Documentation",
+            description: "Analyze and generate documentation for a task",
+            validateInput: (input) => typeof input.taskId === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await tasks_1.taskService.documentTask(input.taskId, input.force || false, aiOptions, streamingOptions);
+            },
+        });
+        // PRD Creation
+        this.register({
+            id: "prd-create",
+            name: "PRD Creation",
+            description: "Generate a Product Requirements Document from a description",
+            validateInput: (input) => typeof input.description === "string" && input.description.length > 0,
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.generatePRD({
+                    description: input.description,
+                    outputDir: input.outputDir,
+                    filename: input.filename,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+        // PRD Combine
+        this.register({
+            id: "prd-combine",
+            name: "PRD Combination",
+            description: "Combine multiple PRD files into a single master PRD",
+            validateInput: (input) => Array.isArray(input.prds) &&
+                input.prds.length > 0 &&
+                typeof input.originalDescription === "string",
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.combinePRDs({
+                    prds: input.prds,
+                    originalDescription: input.originalDescription,
+                    outputDir: input.outputDir,
+                    filename: input.filename,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+        // PRD Question Generation
+        this.register({
+            id: "prd-question",
+            name: "PRD Question Generation",
+            description: "Generate clarifying questions for a PRD",
+            validateInput: (input) => typeof input.file === "string" && input.file.length > 0,
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.generateQuestions({
+                    file: input.file,
+                    workingDirectory: input.workingDirectory,
+                    enableFilesystemTools: input.tools,
+                    promptOverride: input.prompt,
+                    messageOverride: input.message,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+        // PRD Refinement
+        this.register({
+            id: "prd-refine",
+            name: "PRD Refinement",
+            description: "Refine a PRD by generating questions and incorporating answers",
+            validateInput: (input) => typeof input.file === "string" &&
+                input.file.length > 0 &&
+                typeof input.questionMode === "string" &&
+                (input.questionMode === "user" || input.questionMode === "ai"),
+            execute: async (input, aiOptions, streamingOptions) => {
+                return await prd_1.prdService.refinePRDWithQuestions({
+                    file: input.file,
+                    questionMode: input.questionMode,
+                    answers: input.answers,
+                    questionAIOptions: input.questionAIOptions,
+                    workingDirectory: input.workingDirectory,
+                    enableFilesystemTools: input.tools,
+                    aiOptions,
+                    streamingOptions,
+                    callbacks: {},
+                });
+            },
+        });
+    }
+}
+exports.BenchmarkRegistry = BenchmarkRegistry;
+exports.benchmarkRegistry = new BenchmarkRegistry();

package/dist/lib/benchmark/runner.d.ts

@@ -0,0 +1,6 @@
+import { BenchmarkConfig, BenchmarkRun, BenchmarkProgressEvent } from "./types";
+export declare class BenchmarkRunner {
+    run(operationId: string, input: any, config: BenchmarkConfig, onProgress?: (event: BenchmarkProgressEvent) => void): Promise<BenchmarkRun>;
+}
+export declare const benchmarkRunner: BenchmarkRunner;
+//# sourceMappingURL=runner.d.ts.map

package/dist/lib/benchmark/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/lib/benchmark/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,YAAY,EACZ,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAMjB,qBAAa,eAAe;IACpB,GAAG,CACP,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,eAAe,EACvB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GACnD,OAAO,CAAC,YAAY,CAAC;CA0KzB;AAED,eAAO,MAAM,eAAe,iBAAwB,CAAC"}