dominds 0.1.0

package/dist/llm/gen/mock.js

@@ -0,0 +1,326 @@
+"use strict";
+/**
+ * Module: llm/gen/mock
+ *
+ * Mock LLM generator that uses a static response database for testing and development.
+ *
+ * === MOCK DATABASE FORMAT (YAML) ===
+ *
+ * ```yaml
+ * responses:
+ *   # Comments are supported! Explain which test step uses each entry.
+ *   # E.g., # docs/e2e-story-test/basics/reminders.md: Step 1
+ *   - message: "hello"
+ *     role: "user"
+ *     response: "Hi there!"
+ *   - message: "error text"
+ *     role: "tool"
+ *     response: "corrected response"
+ * ```
+ *
+ * === ROLE-BASED MATCHING (EXACT ONLY) ===
+ *
+ * The mock looks at the EXACT last message in context (no fallback):
+ * - role='user' from prompting_msg → matches entries with role='user'
+ * - role='tool' from func_result_msg → matches entries with role='tool'
+ *
+ * Matching rules (strict exact matching, NO fallback):
+ * 1. Exact: "tool:error text" matches response with message="error text" AND role="tool"
+ * 2. Exact: "user:hello" matches response with message="hello" AND role="user"
+ * 3. No match: returns fallback response explaining how to add mocks
+ *
+ * === BENEFITS OF YAML FORMAT ===
+ *
+ * - Comments: Document which test step uses each entry
+ * - Easy cleanup: Identify unused entries by checking test step references
+ * - Maintainability: Update comments when tests change, never lose referenced entries
+ *
+ * === EXAMPLE: TOOL ERROR RECOVERY ===
+ *
+ * // Turn 1: User asks, LLM makes syntax error
+ * # docs/e2e-story-test/reminders.md: User creates reminders
+ * - message: "create reminders"
+ *   role: "user"
+ *   response: "Call the function tool `add_reminder` with {\"content\":\"goals...\"}"
+ *
+ * // Turn 2: Tool error (func_result_msg with role='tool'), LLM self-corrects
+ * # docs/e2e-story-test/reminders.md: Tool syntax error recovery
+ * - message: "Error: Invalid args. Use: add_reminder({ content: string, position: number }) (position=0 means append)."
+ *   role: "tool"
+ *   response: "Call the function tool `add_reminder` with {\"content\":\"Goals...\",\"position\":1}"
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGen = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const log_1 = require("../../log");
+class MockGen {
+    constructor() {
+        this.databaseCache = new Map();
+    }
+    get apiType() {
+        return 'mock';
+    }
+    async loadResponseDatabase(dbPath, modelName) {
+        const cacheKey = `${dbPath}:${modelName}`;
+        const dbFilePath = path_1.default.join(dbPath, `${modelName}.yaml`);
+        const cached = this.databaseCache.get(cacheKey);
+        if (cached) {
+            try {
+                const stats = await promises_1.default.stat(dbFilePath);
+                if (stats.mtimeMs === cached.lastModified) {
+                    return cached;
+                }
+            }
+            catch {
+                // Continue to reload
+            }
+        }
+        try {
+            const content = await promises_1.default.readFile(dbFilePath, 'utf-8');
+            const rawDatabase = yaml_1.default.parse(content);
+            // EXACT MATCHING ONLY: Store entries with role prefix
+            // No fallback to message-only entries
+            const lookupMap = new Map();
+            for (const resp of rawDatabase.responses) {
+                if (!resp.role) {
+                    log_1.log.warn(`⚠️  Mock response without role: "${resp.message.substring(0, 50)}..."`);
+                    log_1.log.warn('💡 All mock responses should have a "role" field (e.g., "user" or "tool")');
+                }
+                const key = resp.role
+                    ? `${resp.role}:${resp.message.trim().toLowerCase()}`
+                    : resp.message.trim().toLowerCase();
+                lookupMap.set(key, resp);
+            }
+            const stats = await promises_1.default.stat(dbFilePath);
+            const cachedDb = {
+                filePath: dbFilePath,
+                lastModified: stats.mtimeMs,
+                lookupMap,
+            };
+            this.databaseCache.set(cacheKey, cachedDb);
+            return cachedDb;
+        }
+        catch {
+            log_1.log.warn(`⚠️  Mock database not found: ${dbFilePath}`);
+            log_1.log.warn('💡 Create the file with: responses: [{ message: "...", role: "...", response: "..." }]');
+            const emptyDb = {
+                filePath: dbFilePath,
+                lastModified: Date.now(),
+                lookupMap: new Map(),
+            };
+            this.databaseCache.set(cacheKey, emptyDb);
+            return emptyDb;
+        }
+    }
+    /**
+     * Find matching response using EXACT last message only.
+     * NO fallback to message-only matching - if exact match fails, return null.
+     */
+    findMatchingResponse(database, input, role) {
+        if (!role) {
+            throw new Error('role is required for mock response matching');
+        }
+        const normalizedInput = input.trim().toLowerCase();
+        const lookupMap = database.lookupMap;
+        // Exact match only: "role:message"
+        const exactKey = `${role}:${normalizedInput}`;
+        return lookupMap.get(exactKey) || null;
+    }
+    makeFallbackResponse(dbPath, input, role, modelName) {
+        return `🤖 **Mock Response Not Found**
+
+No mock response for the specified message with role=${JSON.stringify(role)} !!
+
+Database: \`${path_1.default.join(dbPath, `${modelName}.yaml`)}\`
+
+Add to database:
+\`\`\`yaml
+responses:
+  - message: ${JSON.stringify(input.trim())}
+    role: ${JSON.stringify(role)}
+    response: "Your response here"
+\`\`\``;
+    }
+    async genToReceiver(providerConfig, agent, systemPrompt, _funcTools, context, receiver, _genseq, abortSignal) {
+        const dbPath = providerConfig.baseUrl;
+        if (!agent.model) {
+            throw new Error('Model undefined for agent: ' + agent.id);
+        }
+        const modelName = agent.model;
+        const lastMsg = context[context.length - 1];
+        const content = lastMsg && 'content' in lastMsg ? lastMsg.content : '';
+        const role = lastMsg?.role ?? '';
+        if (abortSignal?.aborted) {
+            throw new Error('AbortError');
+        }
+        await receiver.thinkingStart();
+        await receiver.thinkingChunk(`[${modelName}] `);
+        await receiver.thinkingChunk(content.substring(0, 50) || '(empty)');
+        await receiver.thinkingFinish();
+        const db = await this.loadResponseDatabase(dbPath, modelName);
+        const matched = this.findMatchingResponse(db, content, role);
+        if (matched?.streamError) {
+            throw new Error(matched.streamError);
+        }
+        const responseText = matched?.response ?? this.makeFallbackResponse(dbPath, content, role, modelName);
+        let usage = { kind: 'unavailable' };
+        if (matched && matched.usageUnavailable === true) {
+            usage = { kind: 'unavailable' };
+        }
+        else if (matched && matched.usage) {
+            const promptTokens = matched.usage.promptTokens;
+            const completionTokens = typeof matched.usage.completionTokens === 'number' ? matched.usage.completionTokens : 0;
+            const totalTokens = typeof matched.usage.totalTokens === 'number'
+                ? matched.usage.totalTokens
+                : promptTokens + completionTokens;
+            usage = {
+                kind: 'available',
+                promptTokens,
+                completionTokens,
+                totalTokens,
+            };
+        }
+        else {
+            const promptChars = systemPrompt.length +
+                context.reduce((acc, msg) => {
+                    switch (msg.type) {
+                        case 'environment_msg':
+                        case 'transient_guide_msg':
+                        case 'prompting_msg':
+                        case 'saying_msg':
+                        case 'thinking_msg':
+                        case 'func_result_msg':
+                        case 'call_result_msg':
+                            return acc + msg.content.length;
+                        case 'func_call_msg':
+                            return acc + msg.name.length + msg.arguments.length;
+                        default: {
+                            const _exhaustive = msg;
+                            throw new Error(`Unsupported chat message: ${_exhaustive}`);
+                        }
+                    }
+                }, 0);
+            const promptTokens = Math.ceil(promptChars / 4);
+            const completionTokens = Math.ceil(responseText.length / 4);
+            usage = {
+                kind: 'available',
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+            };
+        }
+        await receiver.sayingStart();
+        const words = responseText.split(/(\s+)/);
+        for (const word of words) {
+            if (abortSignal?.aborted) {
+                throw new Error('AbortError');
+            }
+            await receiver.sayingChunk(word);
+        }
+        await receiver.sayingFinish();
+        return { usage, llmGenModel: modelName };
+    }
+    async genMoreMessages(providerConfig, agent, systemPrompt, _funcTools, context, genseq, abortSignal) {
+        if (abortSignal?.aborted) {
+            throw new Error('AbortError');
+        }
+        const dbPath = providerConfig.baseUrl;
+        if (!agent.model) {
+            throw new Error('Model undefined for agent: ' + agent.id);
+        }
+        const modelName = agent.model;
+        const lastMsg = context[context.length - 1];
+        const content = lastMsg && 'content' in lastMsg ? lastMsg.content : '';
+        const role = lastMsg?.role ?? '';
+        try {
+            const db = await this.loadResponseDatabase(dbPath, modelName);
+            const matched = this.findMatchingResponse(db, content, role);
+            const responseText = matched?.response ?? this.makeFallbackResponse(dbPath, content, role, modelName);
+            const thinking = {
+                type: 'thinking_msg',
+                role: 'assistant',
+                genseq,
+                content: `[${modelName}] ${content.substring(0, 100)}`,
+            };
+            const saying = {
+                type: 'saying_msg',
+                role: 'assistant',
+                genseq,
+                content: matched?.streamError ? `❌ Mock Error: ${matched.streamError}` : responseText,
+            };
+            let usage = { kind: 'unavailable' };
+            if (matched && matched.usageUnavailable === true) {
+                usage = { kind: 'unavailable' };
+            }
+            else if (matched && matched.usage) {
+                const promptTokens = matched.usage.promptTokens;
+                const completionTokens = typeof matched.usage.completionTokens === 'number' ? matched.usage.completionTokens : 0;
+                const totalTokens = typeof matched.usage.totalTokens === 'number'
+                    ? matched.usage.totalTokens
+                    : promptTokens + completionTokens;
+                usage = {
+                    kind: 'available',
+                    promptTokens,
+                    completionTokens,
+                    totalTokens,
+                };
+            }
+            else {
+                const promptChars = systemPrompt.length +
+                    context.reduce((acc, msg) => {
+                        switch (msg.type) {
+                            case 'environment_msg':
+                            case 'transient_guide_msg':
+                            case 'prompting_msg':
+                            case 'saying_msg':
+                            case 'thinking_msg':
+                            case 'func_result_msg':
+                            case 'call_result_msg':
+                                return acc + msg.content.length;
+                            case 'func_call_msg':
+                                return acc + msg.name.length + msg.arguments.length;
+                            default: {
+                                const _exhaustive = msg;
+                                throw new Error(`Unsupported chat message: ${_exhaustive}`);
+                            }
+                        }
+                    }, 0);
+                const promptTokens = Math.ceil(promptChars / 4);
+                const completionTokens = Math.ceil(responseText.length / 4);
+                usage = {
+                    kind: 'available',
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                };
+            }
+            return { messages: [thinking, saying], usage, llmGenModel: modelName };
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            const saying = {
+                type: 'saying_msg',
+                role: 'assistant',
+                genseq,
+                content: `❌ Mock Error: ${errMsg}`,
+            };
+            const thinking = {
+                type: 'thinking_msg',
+                role: 'assistant',
+                content: `[${modelName}] error: ${errMsg}`,
+                genseq,
+            };
+            return {
+                messages: [thinking, saying],
+                usage: { kind: 'unavailable' },
+                llmGenModel: modelName,
+            };
+        }
+    }
+}
+exports.MockGen = MockGen;