task-o-matic-core 0.1.0

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

@@ -0,0 +1,592 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRDOperations = void 0;
+const ai_1 = require("ai");
+const prompt_builder_1 = require("../prompt-builder");
+const prompts_1 = require("../../prompts");
+const filesystem_tools_1 = require("./filesystem-tools");
+const base_operations_1 = require("./base-operations");
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+class PRDOperations extends base_operations_1.BaseOperations {
+    async parsePRD(prdContent, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory, enableFilesystemTools) {
+        // console.log(
+        //   `[Library Debug] parsePRD called. Config arg has key: ${!!config?.apiKey} Provider internal key: ${!!this.modelProvider.getAIConfig()
+        //     ?.apiKey}`
+        // );
+        return this.retryHandler.executeWithRetry(async () => {
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available
+            }
+            let enhancedPrompt;
+            if (promptOverride) {
+                enhancedPrompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                };
+                if (stackInfo) {
+                    variables.STACK_INFO = stackInfo;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-parsing",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_PARSING_ERROR, `Failed to build PRD parsing prompt: ${promptResult.error}`, {
+                        context: "Prompt building failed during PRD parsing",
+                        suggestions: [
+                            "Verify prompt template exists",
+                            "Check variable substitution",
+                        ],
+                    });
+                }
+                enhancedPrompt = promptResult.prompt;
+            }
+            let response;
+            if (enableFilesystemTools) {
+                const model = this.modelProvider.getModel({
+                    ...this.modelProvider.getAIConfig(),
+                    ...config,
+                });
+                const allTools = {
+                    ...filesystem_tools_1.filesystemTools,
+                };
+                const result = await (0, ai_1.streamText)({
+                    model,
+                    tools: allTools,
+                    system: prompts_1.PRD_PARSING_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 patterns, and dependencies when parsing the PRD and creating tasks.`,
+                    messages: [
+                        { role: "user", content: userMessage || enhancedPrompt },
+                    ],
+                    maxRetries: 0,
+                    onChunk: streamingOptions?.onChunk
+                        ? ({ chunk }) => {
+                            if (chunk.type === "text-delta") {
+                                streamingOptions.onChunk(chunk.text);
+                            }
+                            else if (chunk.type === "reasoning-delta") {
+                                streamingOptions.onReasoning?.(chunk.text);
+                            }
+                        }
+                        : undefined,
+                    onFinish: streamingOptions?.onFinish
+                        ? ({ text, finishReason, usage }) => {
+                            streamingOptions.onFinish({
+                                text,
+                                finishReason,
+                                usage,
+                                isAborted: false,
+                            });
+                        }
+                        : undefined,
+                });
+                response = await result.text;
+            }
+            else {
+                response = await this.streamText("", config, prompts_1.PRD_PARSING_SYSTEM_PROMPT, userMessage || enhancedPrompt, streamingOptions, { maxAttempts: 1 });
+            }
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_PARSING_ERROR, parseResult.error || "Failed to parse PRD response", {
+                    context: "AI response parsing failed during PRD parsing",
+                    suggestions: [
+                        "Check AI response format",
+                        "Verify JSON structure",
+                    ],
+                });
+            }
+            const parsed = parseResult.data;
+            // Handle both { tasks: [...] } and [...] (array) formats
+            let tasksList = [];
+            let summary = "PRD parsed successfully";
+            let estimatedDuration = "Unknown";
+            let confidence = 0.7;
+            if (Array.isArray(parsed)) {
+                tasksList = parsed;
+            }
+            else if (parsed && typeof parsed === "object") {
+                tasksList = parsed.tasks || [];
+                summary = parsed.summary || summary;
+                estimatedDuration = parsed.estimatedDuration || estimatedDuration;
+                confidence = parsed.confidence || confidence;
+            }
+            const tasks = tasksList.map((task, index) => {
+                const taskId = task.id || (index + 1).toString();
+                const { title, description, content, effort, dependencies, ...extraData } = task;
+                let fullContent = "";
+                if (description || content) {
+                    fullContent = description || content || "";
+                }
+                if (Object.keys(extraData).length > 0) {
+                    fullContent += "\n\n## Additional AI-Generated Information\n";
+                    for (const [key, value] of Object.entries(extraData)) {
+                        fullContent += `\n**${key}:** ${JSON.stringify(value, null, 2)}`;
+                    }
+                }
+                return {
+                    id: taskId,
+                    title: task.title,
+                    description: task.description || task.content || "",
+                    content: fullContent,
+                    status: "todo",
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                    estimatedEffort: task.effort,
+                    dependencies: task.dependencies || [],
+                    tags: task.tags || [],
+                };
+            });
+            return {
+                tasks,
+                summary,
+                estimatedDuration,
+                confidence,
+            };
+        }, retryConfig, "PRD parsing");
+    }
+    async reworkPRD(prdContent, feedback, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory, enableFilesystemTools) {
+        return this.retryHandler.executeWithRetry(async () => {
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available
+            }
+            let prompt;
+            if (promptOverride) {
+                prompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                    USER_FEEDBACK: feedback,
+                };
+                if (stackInfo) {
+                    variables.STACK_INFO = stackInfo;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-rework",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, `Failed to build PRD rework prompt: ${promptResult.error}`, {
+                        context: "Prompt building failed during PRD rework",
+                        suggestions: [
+                            "Verify prompt template exists",
+                            "Check variable substitution",
+                        ],
+                    });
+                }
+                prompt = promptResult.prompt;
+            }
+            if (enableFilesystemTools) {
+                const model = this.modelProvider.getModel({
+                    ...this.modelProvider.getAIConfig(),
+                    ...config,
+                });
+                const allTools = {
+                    ...filesystem_tools_1.filesystemTools,
+                };
+                const result = await (0, ai_1.streamText)({
+                    model,
+                    tools: allTools,
+                    system: prompts_1.PRD_REWORK_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 current project structure, existing code patterns, and dependencies when reworking the PRD based on feedback.`,
+                    messages: [{ role: "user", content: userMessage || prompt }],
+                    maxRetries: 0,
+                    onChunk: streamingOptions?.onChunk
+                        ? ({ chunk }) => {
+                            if (chunk.type === "text-delta") {
+                                streamingOptions.onChunk(chunk.text);
+                            }
+                            else if (chunk.type === "reasoning-delta") {
+                                streamingOptions.onReasoning?.(chunk.text);
+                            }
+                        }
+                        : undefined,
+                    onFinish: streamingOptions?.onFinish
+                        ? ({ text, finishReason, usage }) => {
+                            streamingOptions.onFinish({
+                                text,
+                                finishReason,
+                                usage,
+                                isAborted: false,
+                            });
+                        }
+                        : undefined,
+                });
+                return await result.text;
+            }
+            else {
+                return this.streamText("", config, prompts_1.PRD_REWORK_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+            }
+        }, retryConfig, "PRD rework");
+    }
+    async generatePRDQuestions(prdContent, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory, enableFilesystemTools) {
+        return this.retryHandler.executeWithRetry(async () => {
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available
+            }
+            let prompt;
+            if (promptOverride) {
+                prompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                };
+                if (stackInfo) {
+                    variables.STACK_INFO = stackInfo;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-question",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, `Failed to build PRD question prompt: ${promptResult.error}`, {
+                        context: "Prompt building failed during PRD question generation",
+                        suggestions: [
+                            "Verify prompt template exists",
+                            "Check variable substitution",
+                        ],
+                    });
+                }
+                prompt = promptResult.prompt;
+            }
+            const { PRD_QUESTION_SYSTEM_PROMPT } = await Promise.resolve().then(() => __importStar(require("../../prompts")));
+            let response;
+            if (enableFilesystemTools) {
+                const model = this.modelProvider.getModel({
+                    ...this.modelProvider.getAIConfig(),
+                    ...config,
+                });
+                const allTools = { ...filesystem_tools_1.filesystemTools };
+                const result = await (0, ai_1.streamText)({
+                    model,
+                    tools: allTools,
+                    system: PRD_QUESTION_SYSTEM_PROMPT +
+                        `\n\nYou have access to filesystem tools to check existing code/structure if needed.`,
+                    messages: [{ role: "user", content: userMessage || prompt }],
+                    maxRetries: 0,
+                    onChunk: streamingOptions?.onChunk
+                        ? ({ chunk }) => {
+                            if (chunk.type === "text-delta") {
+                                streamingOptions.onChunk(chunk.text);
+                            }
+                            else if (chunk.type === "reasoning-delta") {
+                                streamingOptions.onReasoning?.(chunk.text);
+                            }
+                        }
+                        : undefined,
+                    onFinish: streamingOptions?.onFinish
+                        ? ({ text, finishReason, usage }) => {
+                            streamingOptions.onFinish({
+                                text,
+                                finishReason,
+                                usage,
+                                isAborted: false,
+                            });
+                        }
+                        : undefined,
+                });
+                response = await result.text;
+            }
+            else {
+                response = await this.streamText("", config, PRD_QUESTION_SYSTEM_PROMPT, userMessage || prompt, streamingOptions, { maxAttempts: 1 });
+            }
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, parseResult.error || "Failed to parse PRD questions", {
+                    context: "AI response parsing failed during PRD question generation",
+                    suggestions: [
+                        "Check AI response format",
+                        "Verify JSON structure",
+                    ],
+                });
+            }
+            return parseResult.data?.questions || [];
+        }, retryConfig, "PRD questioning");
+    }
+    async answerPRDQuestions(prdContent, questions, config, contextInfo, streamingOptions, retryConfig) {
+        return this.retryHandler.executeWithRetry(async () => {
+            const questionsText = questions
+                .map((q, i) => `${i + 1}. ${q}`)
+                .join("\n");
+            const contextText = contextInfo
+                ? `\n\nProject Context:\n${contextInfo.stackInfo
+                    ? `Technology Stack: ${contextInfo.stackInfo}\n`
+                    : ""}${contextInfo.projectDescription
+                    ? `Project Description: ${contextInfo.projectDescription}\n`
+                    : ""}`
+                : "";
+            const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "prd-question-answer",
+                type: "user",
+                variables: {
+                    PRD_CONTENT: prdContent,
+                    QUESTIONS_TEXT: questionsText,
+                    CONTEXT_TEXT: contextText,
+                },
+            });
+            if (!promptResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, `Failed to build PRD question answer prompt: ${promptResult.error}`, {
+                    context: "Prompt building failed during PRD answer generation",
+                    suggestions: [
+                        "Verify prompt template exists",
+                        "Check variable substitution",
+                    ],
+                });
+            }
+            const systemPromptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                name: "prd-question-answer",
+                type: "system",
+                variables: {},
+            });
+            const response = await this.streamText("", config, systemPromptResult.prompt, promptResult.prompt, streamingOptions, { maxAttempts: 1 });
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, parseResult.error || "Failed to parse PRD answers response", {
+                    context: "AI response parsing failed during PRD answer generation",
+                    suggestions: [
+                        "Check AI response format",
+                        "Verify JSON structure",
+                    ],
+                });
+            }
+            const answers = {};
+            const numberedAnswers = parseResult.data?.answers || {};
+            questions.forEach((question, index) => {
+                const key = String(index + 1);
+                if (numberedAnswers[key]) {
+                    answers[question] = numberedAnswers[key];
+                }
+            });
+            return answers;
+        }, retryConfig, "PRD question answering");
+    }
+    async generatePRD(description, config, promptOverride, userMessage, streamingOptions, retryConfig) {
+        return this.retryHandler.executeWithRetry(async () => {
+            const systemPrompt = prompts_1.PRD_GENERATION_SYSTEM_PROMPT;
+            const userContent = userMessage || `Product Description:\n${description}`;
+            return this.streamText("", config, systemPrompt, userContent, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "PRD generation");
+    }
+    async combinePRDs(prds, originalDescription, config, promptOverride, userMessage, streamingOptions, retryConfig) {
+        return this.retryHandler.executeWithRetry(async () => {
+            const systemPrompt = prompts_1.PRD_COMBINATION_SYSTEM_PROMPT;
+            let userContent = userMessage;
+            if (!userContent) {
+                userContent = `Original Description:\n${originalDescription}\n\n`;
+                userContent += `<generated_prds>\n`;
+                prds.forEach((prd, index) => {
+                    userContent += `  <prd id="${index + 1}">\n${prd}\n  </prd>\n`;
+                });
+                userContent += `</generated_prds>\n`;
+            }
+            return this.streamText("", config, systemPrompt, userContent, streamingOptions, { maxAttempts: 1 });
+        }, retryConfig, "PRD combination");
+    }
+    /**
+     * Suggest a technology stack based on PRD analysis.
+     */
+    async suggestStack(prdContent, projectName, config, promptOverride, userMessage, streamingOptions, retryConfig, workingDirectory, enableFilesystemTools) {
+        return this.retryHandler.executeWithRetry(async () => {
+            // Try to detect stack info for context
+            let stackInfo = "";
+            try {
+                stackInfo = await prompt_builder_1.PromptBuilder.detectStackInfo(workingDirectory);
+                if (stackInfo === "Not detected") {
+                    stackInfo = "";
+                }
+            }
+            catch (error) {
+                // Stack info not available
+            }
+            let enhancedPrompt;
+            if (promptOverride) {
+                enhancedPrompt = promptOverride;
+            }
+            else {
+                const variables = {
+                    PRD_CONTENT: prdContent,
+                };
+                if (stackInfo) {
+                    variables.STACK_INFO = `## Existing Stack Info\n${stackInfo}`;
+                }
+                if (projectName) {
+                    variables.PROJECT_NAME = `## Project Name\nUse this project name: ${projectName}`;
+                }
+                const promptResult = prompt_builder_1.PromptBuilder.buildPrompt({
+                    name: "prd-suggest-stack",
+                    type: "user",
+                    variables,
+                });
+                if (!promptResult.success) {
+                    throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, `Failed to build stack suggestion prompt: ${promptResult.error}`, {
+                        context: "Prompt building failed during stack suggestion",
+                        suggestions: [
+                            "Verify prompt template exists",
+                            "Check variable substitution",
+                        ],
+                    });
+                }
+                enhancedPrompt = promptResult.prompt;
+            }
+            let response;
+            if (enableFilesystemTools) {
+                const model = this.modelProvider.getModel({
+                    ...this.modelProvider.getAIConfig(),
+                    ...config,
+                });
+                const allTools = {
+                    ...filesystem_tools_1.filesystemTools,
+                };
+                const result = await (0, ai_1.streamText)({
+                    model,
+                    tools: allTools,
+                    system: prompts_1.PRD_SUGGEST_STACK_SYSTEM_PROMPT +
+                        `\n\nYou have access to filesystem tools that allow you to:\n- readFile: Read the contents of any file in the project\n- listDirectory: List contents of directories\n\nUse these tools to understand the project structure and existing dependencies when suggesting the stack.`,
+                    messages: [
+                        { role: "user", content: userMessage || enhancedPrompt },
+                    ],
+                    maxRetries: 0,
+                    onChunk: streamingOptions?.onChunk
+                        ? ({ chunk }) => {
+                            if (chunk.type === "text-delta") {
+                                streamingOptions.onChunk(chunk.text);
+                            }
+                            else if (chunk.type === "reasoning-delta") {
+                                streamingOptions.onReasoning?.(chunk.text);
+                            }
+                        }
+                        : undefined,
+                    onFinish: streamingOptions?.onFinish
+                        ? ({ text, finishReason, usage }) => {
+                            streamingOptions.onFinish({
+                                text,
+                                finishReason,
+                                usage,
+                                isAborted: false,
+                            });
+                        }
+                        : undefined,
+                });
+                response = await result.text;
+            }
+            else {
+                response = await this.streamText("", config, prompts_1.PRD_SUGGEST_STACK_SYSTEM_PROMPT, userMessage || enhancedPrompt, streamingOptions, { maxAttempts: 1 });
+            }
+            // Parse the JSON response
+            const parseResult = this.jsonParser.parseJSONFromResponse(response);
+            if (!parseResult.success) {
+                throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.PRD_GENERATION_ERROR, parseResult.error || "Failed to parse stack suggestion response", {
+                    context: "AI response parsing failed during stack suggestion",
+                    suggestions: [
+                        "Check AI response format",
+                        "Verify JSON structure",
+                    ],
+                });
+            }
+            const parsed = parseResult.data;
+            // Validate and apply defaults to the config
+            const validatedConfig = this.validateStackConfig(parsed.config || parsed);
+            return {
+                config: validatedConfig,
+                reasoning: parsed.reasoning || "No reasoning provided.",
+            };
+        }, retryConfig, "Stack suggestion");
+    }
+    /**
+     * Validate and apply defaults to a partial BTSConfig.
+     */
+    validateStackConfig(partial) {
+        return {
+            projectName: partial.projectName || "my-project",
+            frontend: partial.frontend || "none",
+            backend: partial.backend || "none",
+            database: partial.database || "none",
+            orm: partial.orm || "none",
+            api: partial.api || "none",
+            auth: partial.auth || "none",
+            payments: partial.payments || "none",
+            dbSetup: partial.dbSetup || "none",
+            runtime: partial.runtime || "bun",
+            packageManager: partial.packageManager || "bun",
+            git: partial.git ?? true,
+            install: partial.install ?? true,
+            webDeploy: partial.webDeploy || "none",
+            serverDeploy: partial.serverDeploy || "none",
+            addons: Array.isArray(partial.addons) ? partial.addons : [],
+            examples: Array.isArray(partial.examples) ? partial.examples : [],
+        };
+    }
+}
+exports.PRDOperations = PRDOperations;

package/dist/lib/ai-service/research-tools.d.ts

@@ -0,0 +1,4 @@
+export declare class ResearchTools {
+    private storage;
+}
+//# sourceMappingURL=research-tools.d.ts.map

package/dist/lib/ai-service/research-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-tools.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/research-tools.ts"],"names":[],"mappings":"AAKA,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAgC;CAwMhD"}

package/dist/lib/ai-service/research-tools.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchTools = void 0;
+const ai_service_factory_1 = require("../../utils/ai-service-factory");
+class ResearchTools {
+    storage = (0, ai_service_factory_1.getStorage)();
+}
+exports.ResearchTools = ResearchTools;

package/dist/lib/ai-service/retry-handler.d.ts

@@ -0,0 +1,8 @@
+import { RetryConfig } from "../../types";
+export declare class RetryHandler {
+    private getRetryConfig;
+    private shouldRetryError;
+    private delay;
+    executeWithRetry<T>(operation: () => Promise<T>, retryConfig?: Partial<RetryConfig>, operationName?: string): Promise<T>;
+}
+//# sourceMappingURL=retry-handler.d.ts.map

package/dist/lib/ai-service/retry-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/retry-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,gBAAgB;YAaV,KAAK;IAIb,gBAAgB,CAAC,CAAC,EACtB,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EAClC,aAAa,GAAE,MAAuB,GACrC,OAAO,CAAC,CAAC,CAAC;CA4Cd"}