minovative-mind-cli 1.5.1 → 2.1.0

package/dist/services/agent-tools.js

@@ -4,7 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { SchemaType } from '@google/generative-ai';
-import { resolveAndValidatePath } from '../utils/pathSecurity.js';
+import { resolveAndValidatePath, resolveAndValidateMultiWorkspacePath } from '../utils/pathSecurity.js';
+import { workspaceRegistry } from './workspaceRegistry.js';
 import { changeLogger } from './changeLogger.js';
 import { findBestMatch, applyMatch } from '../utils/fuzzyMatch.js';
 import { validateSyntax } from '../utils/syntaxValidator.js';
@@ -13,8 +14,22 @@ import { findDependencies, formatDependencyResult } from '../utils/dependencyTra
 import { atomicWriteFile } from '../utils/atomicWrite.js';
 import { EXCLUDED_EXTENSIONS } from '../utils/excludedExtensions.js';
 import { extractSymbols } from '../utils/symbolExtractor.js';
+import { getMetricCollector } from './metrics.js';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
+let _semanticSearchEnabled = true;
+export function isSemanticSearchEnabled() {
+    return _semanticSearchEnabled;
+}
+export function setSemanticSearchEnabled(val) {
+    _semanticSearchEnabled = val;
+}
+export function getToolDeclarations() {
+    if (_semanticSearchEnabled) {
+        return toolDeclarations;
+    }
+    return toolDeclarations.filter((t) => t.name !== 'semantic_search');
+}
 /**
  * FunctionDeclaration-compatible schema objects that describe
  * every tool the agent can invoke. Passed to the model at init.
@@ -22,13 +37,13 @@ const execAsync = promisify(exec);
 export const toolDeclarations = [
     {
         name: 'read_file',
-        description: 'Read the contents of a file at the given path relative to the workspace root. Returns the file text. Use startLine and endLine to read specific chunks of massive files to avoid context limits.',
+        description: 'Read the contents of a file at the given path relative to the workspace root. Supports text files and native parsing of .pdf files (including math and diagrams). Use startLine and endLine to read specific chunks of massive files to avoid context limits. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 startLine: {
                     type: SchemaType.NUMBER,
@@ -49,13 +64,13 @@ export const toolDeclarations = [
     },
     {
         name: 'write_file',
-        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead.',
+        description: 'Create a new file or completely overwrite an existing file with the provided content. Use modify_file for targeted edits instead. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 content: {
                     type: SchemaType.STRING,
@@ -67,13 +82,13 @@ export const toolDeclarations = [
     },
     {
         name: 'delete_file',
-        description: 'Deletes a file from the filesystem. Use this instead of running an rm command.',
+        description: 'Deletes a file from the filesystem. Use this instead of running an rm command. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file to delete.',
+                    description: 'Relative path to the file to delete, or @alias/path for external workspaces.',
                 },
             },
             required: ['filePath'],
@@ -81,17 +96,17 @@ export const toolDeclarations = [
     },
     {
         name: 'rename_file',
-        description: 'Moves or renames a file. Use this instead of running an mv command.',
+        description: 'Moves or renames a file. Use this instead of running an mv command. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 sourcePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file to move/rename.',
+                    description: 'Relative path to the file to move/rename, or @alias/path for external workspaces.',
                 },
                 targetPath: {
                     type: SchemaType.STRING,
-                    description: 'New relative path for the file.',
+                    description: 'New relative path for the file, or @alias/path for external workspaces.',
                 },
             },
             required: ['sourcePath', 'targetPath'],
@@ -99,13 +114,13 @@ export const toolDeclarations = [
     },
     {
         name: 'modify_file',
-        description: 'Perform one or multiple targeted search-and-replace edits in a single file. The search strings must match exactly (including whitespace). This is preferred over write_file for editing existing files because it preserves the rest of the file. Use this to batch multiple changes into a single operation.',
+        description: 'Perform one or multiple targeted search-and-replace edits in a single file. CRITICAL REQUIREMENT: You MUST use read_file or grep_search to fetch the exact current file content BEFORE using this tool. Do NOT guess or hallucinate the searchContent without reading the exact lines first, or the edit will fail. The search strings must match the current file exactly (including whitespace). This is preferred over write_file for editing existing files. For files in external workspaces, prefix the path with @alias/ (e.g., @backend/src/routes.ts).',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 filePath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the file from the workspace root.',
+                    description: 'Relative path to the file from the workspace root, or @alias/path for external workspaces.',
                 },
                 edits: {
                     type: SchemaType.ARRAY,
@@ -131,13 +146,13 @@ export const toolDeclarations = [
     },
     {
         name: 'list_directory',
-        description: 'List files and subdirectories in a directory relative to the workspace root. Returns a recursive tree structure.',
+        description: 'List files and subdirectories in a directory relative to the workspace root. Returns a recursive tree structure. For directories in external workspaces, prefix the path with @alias/ (e.g., @backend/src). Use "@all" to see a summary of all registered workspaces.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
                 dirPath: {
                     type: SchemaType.STRING,
-                    description: 'Relative path to the directory from the workspace root. Use "." for the root.',
+                    description: 'Relative path to the directory from the workspace root, @alias/path for external workspaces, or "@all" for all workspaces.',
                 },
                 maxDepth: {
                     type: SchemaType.NUMBER,
@@ -163,7 +178,7 @@ export const toolDeclarations = [
     },
     {
         name: 'grep_search',
-        description: 'Search for a text pattern across files in the workspace. Returns matching file paths with line numbers and content snippets. Uses Extended Regular Expressions (grep -E). IMPORTANT: grep searches line-by-line. Do NOT search for long lists of Tailwind classes or multi-line strings, as they will fail if line-wrapped. Search for short, unique substrings.',
+        description: 'Search for a text pattern across files in the workspace. Returns matching file paths with line numbers and content snippets. Uses Extended Regular Expressions (grep -E). IMPORTANT: grep searches line-by-line. Do NOT search for long lists of Tailwind classes or multi-line strings, as they will fail if line-wrapped. Search for short, unique substrings. Use the workspace parameter to search external workspaces.',
         parameters: {
             type: SchemaType.OBJECT,
             properties: {
@@ -175,6 +190,10 @@ export const toolDeclarations = [
                     type: SchemaType.STRING,
                     description: 'Optional glob to restrict file types, e.g. "*.ts" or "*.py". Defaults to all files.',
                 },
+                workspace: {
+                    type: SchemaType.STRING,
+                    description: 'Optional. Workspace alias to search in (e.g., "backend"), or "all" to search all registered workspaces. Defaults to the primary workspace.',
+                },
             },
             required: ['pattern'],
         },
@@ -240,6 +259,24 @@ export const toolDeclarations = [
             required: ['language', 'code'],
         },
     },
+    {
+        name: 'semantic_search',
+        description: 'Search the codebase by meaning and concept rather than exact text match. Use this when you need to find code related to a concept, pattern, or behavior but don\'t know the exact variable or function names to grep for. Examples: "error handling for API requests", "user authentication flow", "database connection pooling logic". Returns ranked results with file paths, line ranges, and similarity scores.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                query: {
+                    type: SchemaType.STRING,
+                    description: "Natural language description of what you're looking for in the codebase.",
+                },
+                topK: {
+                    type: SchemaType.NUMBER,
+                    description: 'Number of results to return. Defaults to 5, maximum 15.',
+                },
+            },
+            required: ['query'],
+        },
+    },
 ];
 let currentApprovalMode = 'ask';
 export function getApprovalMode() {
@@ -248,6 +285,13 @@ export function getApprovalMode() {
 export function setApprovalMode(mode) {
     currentApprovalMode = mode;
 }
+let subAgentsEnabled = true;
+export function isSubAgentsEnabled() {
+    return subAgentsEnabled;
+}
+export function setSubAgentsEnabled(enabled) {
+    subAgentsEnabled = enabled;
+}
 /**
  * If set to 'skip-once', reverts to 'ask' after a single command is run.
  */
@@ -300,6 +344,23 @@ async function getIgnoredPaths(workspaceRoot) {
 export async function readFile(workspaceRoot, filePath, startLine, endLine, targetElements) {
     try {
         const absPath = resolveAndValidatePath(workspaceRoot, filePath);
+        // Handle PDF files
+        if (filePath.toLowerCase().endsWith('.pdf')) {
+            const stats = await fs.stat(absPath);
+            const fileSizeMB = stats.size / (1024 * 1024);
+            if (fileSizeMB > 10) {
+                return {
+                    output: '',
+                    error: `File exceeds the 10MB safety limit to prevent excessive credit consumption. Please split the PDF into smaller chunks. (Size: ${fileSizeMB.toFixed(2)}MB)`,
+                };
+            }
+            const buffer = await fs.readFile(absPath);
+            const base64Data = buffer.toString('base64');
+            return {
+                output: `[PDF Data Attached: ${filePath}]`,
+                inlineData: { mimeType: 'application/pdf', data: base64Data },
+            };
+        }
         let content = await fs.readFile(absPath, 'utf-8');
         if (targetElements && targetElements.length > 0) {
             content = extractSymbols(content, filePath, targetElements);
@@ -356,6 +417,9 @@ export async function writeFile(workspaceRoot, filePath, content) {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        const collector = getMetricCollector();
+        if (collector)
+            collector.recordWriteFailure();
         return {
             output: '',
             error: `Failed to write file "${filePath}": ${message}`,
@@ -417,6 +481,9 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 const edit = edits[i];
                 const match = findBestMatch(modified, edit.searchContent);
                 if (!match) {
+                    const collector = getMetricCollector();
+                    if (collector)
+                        collector.recordModifyFailure();
                     if (attempt < MAX_MODIFY_RETRIES) {
                         // Break out of inner loop, triggering a retry in outer loop
                         modified = existing; // reset
@@ -431,6 +498,18 @@ export async function modifyFile(workspaceRoot, filePath, edits) {
                 }
                 modified = applyMatch(modified, match, edit.replaceContent);
                 strategies.push(`Edit #${i + 1}: ${match.strategy}`);
+                const collector = getMetricCollector();
+                if (collector) {
+                    if (match.strategy.startsWith('Exact Match')) {
+                        collector.recordMatchTier('exact');
+                    }
+                    else if (match.strategy.startsWith('Levenshtein')) {
+                        collector.recordMatchTier('levenshtein');
+                    }
+                    else {
+                        collector.recordMatchTier('normalized');
+                    }
+                }
             }
             // If we broke out early for a retry, the modified string will equal the existing string
             // (or we haven't completed all edits), so we continue to the next attempt.
@@ -528,7 +607,9 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         // Truncate command output to prevent memory blowout from massive build logs
         const MAX_CMD_OUTPUT = 15_000;
         if (output.length > MAX_CMD_OUTPUT) {
-            output = output.substring(0, MAX_CMD_OUTPUT) + `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
+            output =
+                output.substring(0, MAX_CMD_OUTPUT) +
+                    `\n\n... (Output truncated: ${output.length} bytes exceeded 15KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
         }
         return { output: output || '(command produced no output)' };
     }
@@ -537,7 +618,8 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
         // Also truncate error output
         const MAX_ERR_OUTPUT = 15_000;
         const truncatedMsg = message.length > MAX_ERR_OUTPUT
-            ? message.substring(0, MAX_ERR_OUTPUT) + `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
+            ? message.substring(0, MAX_ERR_OUTPUT) +
+                `\n\n... (Error output truncated: ${message.length} bytes exceeded 15KB limit. Pipe to a file if you need full logs.)`
             : message;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
@@ -574,7 +656,9 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, abortSignal)
         }
         // Node.js fallback for Windows
         const regexPattern = new RegExp(pattern, 'gi'); // Emulate grep -i and global match
-        const globPattern = fileGlob ? new RegExp('^' + fileGlob.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i') : null;
+        const globPattern = fileGlob
+            ? new RegExp('^' + fileGlob.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$', 'i')
+            : null;
         const results = [];
         async function walk(dir) {
             if (results.length >= 50)
@@ -811,34 +895,188 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
     }
 }
 /**
- * Dispatches a function call from the model to the appropriate local tool.
- * Returns the tool result as a string to feed back to the model.
+ * Resolves `@alias/` prefixed paths in tool arguments to the correct workspace root
+ * and relative path. Returns the effective workspaceRoot and the cleaned arguments.
+ */
+function resolveWorkspaceArgs(primaryRoot, toolName, args) {
+    // Only resolve if workspaces are registered
+    if (!workspaceRegistry.hasWorkspaces()) {
+        return { effectiveRoot: primaryRoot, resolvedArgs: args };
+    }
+    const resolvedArgs = { ...args };
+    // Map of tool-name -> argument keys that hold file/dir paths
+    const pathArgKeys = {
+        read_file: ['filePath'],
+        write_file: ['filePath'],
+        delete_file: ['filePath'],
+        modify_file: ['filePath'],
+        list_directory: ['dirPath'],
+        find_dependencies: ['filePath'],
+        find_recent_changes: ['dirPath'],
+        rename_file: ['sourcePath', 'targetPath'],
+    };
+    const keys = pathArgKeys[toolName];
+    if (!keys) {
+        return { effectiveRoot: primaryRoot, resolvedArgs };
+    }
+    let effectiveRoot = primaryRoot;
+    for (const key of keys) {
+        const val = resolvedArgs[key];
+        if (typeof val !== 'string' || !val.startsWith('@'))
+            continue;
+        // Special case: "@all" for list_directory — handled separately in executeTool
+        if (val === '@all')
+            continue;
+        const resolved = resolveAndValidateMultiWorkspacePath(primaryRoot, val);
+        effectiveRoot = resolved.workspaceRoot;
+        resolvedArgs[key] = resolved.relativePath;
+    }
+    return { effectiveRoot, resolvedArgs };
+}
+/**
+ * Runs grep across all registered workspaces (primary + external) and merges results.
+ * Results from external workspaces are prefixed with @alias/ for disambiguation.
  */
+async function crossWorkspaceGrep(primaryRoot, pattern, fileGlob, abortSignal) {
+    const allRoots = workspaceRegistry.getAllRoots(primaryRoot);
+    const allResults = [];
+    for (const { alias, root } of allRoots) {
+        const result = await grepSearch(root, pattern, fileGlob, abortSignal);
+        if (result.error)
+            continue;
+        // Extract the raw text from the XML wrapper
+        const cdataMatch = result.output.match(/<!\[CDATA\[\n([\s\S]*?)\n\]\]>/);
+        const rawText = cdataMatch ? cdataMatch[1] : result.output;
+        if (rawText.startsWith('No matches found'))
+            continue;
+        // Prefix each result line with the workspace alias for disambiguation
+        const prefix = alias ? `@${alias}/` : '';
+        const lines = rawText.split('\n').filter((l) => l.trim());
+        for (const line of lines) {
+            if (line.startsWith('...')) {
+                allResults.push(line);
+            }
+            else {
+                // Lines are in format "./path:lineNum:content" — prepend alias prefix
+                allResults.push(prefix ? line.replace(/^\.?\//, `@${alias}/`) : line);
+            }
+        }
+    }
+    if (allResults.length === 0) {
+        return { output: `No matches found for "${pattern}" across all workspaces.` };
+    }
+    const limited = allResults.slice(0, 80);
+    const resultText = limited.join('\n') +
+        (allResults.length > 80 ? `\n\n... (${allResults.length - 80} more results truncated)` : '');
+    const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]></content_data>\n</workspace_file>`;
+    return { output: wrappedResult };
+}
 export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
+    // ─── Multi-Workspace Path Resolution ─────────────────────────────
+    // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
+    // before dispatching to the underlying tool functions (which remain unchanged).
+    const { effectiveRoot, resolvedArgs } = resolveWorkspaceArgs(workspaceRoot, toolName, args);
+    let result;
     switch (toolName) {
         case 'read_file':
-            return readFile(workspaceRoot, args.filePath, args.startLine, args.endLine, args.targetElements);
+            result = await readFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.startLine, resolvedArgs.endLine, resolvedArgs.targetElements);
+            break;
         case 'write_file':
-            return writeFile(workspaceRoot, args.filePath, args.content);
+            result = await writeFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.content);
+            break;
         case 'delete_file':
-            return deleteFile(workspaceRoot, args.filePath);
+            result = await deleteFile(effectiveRoot, resolvedArgs.filePath);
+            break;
         case 'rename_file':
-            return renameFile(workspaceRoot, args.sourcePath, args.targetPath);
+            result = await renameFile(effectiveRoot, resolvedArgs.sourcePath, resolvedArgs.targetPath);
+            break;
         case 'modify_file':
-            return modifyFile(workspaceRoot, args.filePath, args.edits);
-        case 'list_directory':
-            return listDirectory(workspaceRoot, args.dirPath, args.maxDepth ?? 3);
+            result = await modifyFile(effectiveRoot, resolvedArgs.filePath, resolvedArgs.edits);
+            break;
+        case 'list_directory': {
+            const dirPath = resolvedArgs.dirPath;
+            // Handle @all — list all registered workspace roots
+            if (dirPath === '@all') {
+                const allRoots = workspaceRegistry.getAllRoots(workspaceRoot);
+                const sections = [];
+                for (const { alias, root } of allRoots) {
+                    const label = alias ? `@${alias}` : '(primary)';
+                    const subResult = await listDirectory(root, '.', 2);
+                    sections.push(`=== Workspace: ${label} [${root}] ===\n${subResult.output}`);
+                }
+                result = { output: sections.join('\n\n') };
+            }
+            else {
+                result = await listDirectory(effectiveRoot, dirPath, resolvedArgs.maxDepth ?? 3);
+            }
+            break;
+        }
         case 'run_command':
-            return runCommand(workspaceRoot, args.command, abortSignal);
+            result = await runCommand(effectiveRoot, resolvedArgs.command, abortSignal);
+            break;
         case 'run_debug_script':
-            return runDebugScript(workspaceRoot, args.language, args.code, abortSignal);
-        case 'grep_search':
-            return grepSearch(workspaceRoot, args.pattern, args.fileGlob, abortSignal);
+            result = await runDebugScript(effectiveRoot, resolvedArgs.language, resolvedArgs.code, abortSignal);
+            break;
+        case 'grep_search': {
+            const wsParam = resolvedArgs.workspace;
+            if (wsParam === 'all') {
+                // Cross-workspace search across all registered workspaces
+                result = await crossWorkspaceGrep(workspaceRoot, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
+            else if (wsParam && workspaceRegistry.get(wsParam)) {
+                // Search in a specific external workspace
+                const ws = workspaceRegistry.get(wsParam);
+                result = await grepSearch(ws.absolutePath, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
+            else {
+                result = await grepSearch(effectiveRoot, resolvedArgs.pattern, resolvedArgs.fileGlob, abortSignal);
+            }
+            break;
+        }
+        case 'semantic_search': {
+            const query = args.query;
+            const topK = args.topK || 5;
+            let output = '';
+            try {
+                const { getEmbeddingIndex } = await import('./embeddingIndex.js');
+                const index = getEmbeddingIndex();
+                if (!index.isReady()) {
+                    const loaded = await index.load(workspaceRoot);
+                    if (!loaded) {
+                        await index.buildIndex(workspaceRoot);
+                        await index.save(workspaceRoot);
+                    }
+                }
+                const results = await index.search(query, topK);
+                if (results.length === 0) {
+                    output = 'No semantically similar code found. (Index might be empty or embedding failed)';
+                }
+                else {
+                    output = results
+                        .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
+                        .join('\n---\n');
+                }
+            }
+            catch (e) {
+                output = `Semantic search failed: ${e.message}`;
+            }
+            result = { output };
+            break;
+        }
         case 'find_dependencies':
-            return traceDependencies(workspaceRoot, args.filePath, args.direction, args.maxDepth);
+            result = await traceDependencies(effectiveRoot, resolvedArgs.filePath, resolvedArgs.direction, resolvedArgs.maxDepth);
+            break;
         case 'find_recent_changes':
-            return findRecentChanges(workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+            result = await findRecentChanges(effectiveRoot, resolvedArgs.dirPath, resolvedArgs.minutes, resolvedArgs.maxDepth);
+            break;
         default:
-            return { output: '', error: `Unknown tool: "${toolName}"` };
+            result = { output: '', error: `Unknown tool: "${toolName}"` };
+            break;
+    }
+    if (result.error) {
+        const collector = getMetricCollector();
+        if (collector)
+            collector.recordToolFailure(toolName);
     }
+    return result;
 }

package/dist/services/agent.d.ts

@@ -15,6 +15,7 @@
  * 5. **Self-Correction Pipeline**: Compares modified files against TS/Linter diagnostics,
  *    providing feedback on syntax or semantic failures back to the AI for self-healing.
  */
+import { AsyncInputHandler } from './agent/inputHandler.js';
 export { AsyncInputHandler } from './agent/inputHandler.js';
 /**
  * Starts and orchestrates the primary interactive command-line interface (REPL) loop.
@@ -48,3 +49,10 @@ export { AsyncInputHandler } from './agent/inputHandler.js';
  * @param version - The Semantic Version string of the active tool distribution.
  */
 export declare function startAgentLoop(workspaceRoot: string, version: string): Promise<void>;
+export declare function executeSingleTurn(workspaceRoot: string, userInput: string, chat: any, inputHandler: AsyncInputHandler, chatSessionState: {
+    id: string;
+    title: string;
+}, isPlanMode: boolean, cachedContextResult?: any): Promise<{
+    planModeReturn?: string;
+    contextResult?: any;
+} | void>;