@wonderwhy-er/desktop-commander 0.2.42 → 0.2.43

package/dist/tools/fuzzySearch.js

@@ -1,113 +1,74 @@
-import { distance } from 'fastest-levenshtein';
 import { capture } from '../utils/capture.js';
+import { Worker } from 'worker_threads';
+// Re-export so existing callers keep importing from this module.
+export { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearchCore.js';
+/** Abort fuzzy search in the worker after this many ms to avoid unbounded CPU burn. */
+export const FUZZY_SEARCH_TIMEOUT_MS = 30000;
 /**
- * Recursively finds the closest match to a query string within text using fuzzy matching
- * @param text The text to search within
- * @param query The query string to find
- * @param start Start index in the text (default: 0)
- * @param end End index in the text (default: text.length)
- * @param parentDistance Best distance found so far (default: Infinity)
- * @returns Object with start and end indices, matched value, and Levenshtein distance
+ * Inline worker entry: imports the dependency-free core module (passed as
+ * moduleUrl) and runs the search off the main thread. The core module is
+ * deliberately a leaf — importing this module (or anything app-level) from the
+ * worker would boot the whole server per search. Kept as an eval'd snippet so
+ * the worker needs no separate file to ship alongside the compiled output.
  */
-export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity, depth = 0) {
-    // For debugging and performance tracking purposes
-    if (depth === 0) {
-        const startTime = performance.now();
-        const result = recursiveFuzzyIndexOf(text, query, start, end, parentDistance, depth + 1);
-        const executionTime = performance.now() - startTime;
-        // Capture detailed metrics for the recursive search for in-depth analysis
-        capture('fuzzy_search_recursive_metrics', {
-            execution_time_ms: executionTime,
-            text_length: text.length,
-            query_length: query.length,
-            result_distance: result.distance
-        });
-        return result;
-    }
-    if (end === null)
-        end = text.length;
-    // For small text segments, use iterative approach
-    if (end - start <= 2 * query.length) {
-        return iterativeReduction(text, query, start, end, parentDistance);
-    }
-    let midPoint = start + Math.floor((end - start) / 2);
-    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
-    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
-    // Calculate distance for current segments
-    let leftDistance = distance(text.substring(start, leftEnd), query);
-    let rightDistance = distance(text.substring(rightStart, end), query);
-    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
-    // If parent distance is already the best, use iterative approach
-    if (parentDistance === bestDistance) {
-        return iterativeReduction(text, query, start, end, parentDistance);
-    }
-    // Recursively search the better half
-    if (leftDistance < rightDistance) {
-        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance, depth + 1);
-    }
-    else {
-        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance, depth + 1);
-    }
-}
+const WORKER_CODE = `
+const { workerData, parentPort } = require('worker_threads');
+import(workerData.moduleUrl)
+    .then((m) => {
+        parentPort.postMessage({ ok: true, ...m.runFuzzySearch(workerData.text, workerData.query) });
+    })
+    .catch((err) => {
+        parentPort.postMessage({ ok: false, error: String(err && err.stack || err) });
+    });
+`;
+const CORE_MODULE_URL = new URL('./fuzzySearchCore.js', import.meta.url).href;
 /**
- * Iteratively refines the best match by reducing the search area
- * @param text The text to search within
- * @param query The query string to find
- * @param start Start index in the text
- * @param end End index in the text
- * @param parentDistance Best distance found so far
- * @returns Object with start and end indices, matched value, and Levenshtein distance
+ * Runs the fuzzy search in a Worker thread so the main MCP event loop stays
+ * responsive to pings and other tool calls during heavy scans. Rejects if the
+ * scan exceeds timeoutMs, terminating the worker so it doesn't linger in the
+ * background. Search metrics come back with the result and are captured here,
+ * on the main thread, where the client identity is initialized.
  */
-function iterativeReduction(text, query, start, end, parentDistance) {
-    const startTime = performance.now();
-    let iterations = 0;
-    let bestDistance = parentDistance;
-    let bestStart = start;
-    let bestEnd = end;
-    // Improve start position
-    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
-    while (nextDistance < bestDistance) {
-        bestDistance = nextDistance;
-        bestStart++;
-        const smallerString = text.substring(bestStart + 1, bestEnd);
-        nextDistance = distance(smallerString, query);
-        iterations++;
-    }
-    // Improve end position
-    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
-    while (nextDistance < bestDistance) {
-        bestDistance = nextDistance;
-        bestEnd--;
-        const smallerString = text.substring(bestStart, bestEnd - 1);
-        nextDistance = distance(smallerString, query);
-        iterations++;
-    }
-    const executionTime = performance.now() - startTime;
-    // Capture metrics for the iterative refinement phase
-    capture('fuzzy_search_iterative_metrics', {
-        execution_time_ms: executionTime,
-        iterations: iterations,
-        segment_length: end - start,
-        query_length: query.length,
-        final_distance: bestDistance
+export function runFuzzySearchInWorker(text, query, timeoutMs = FUZZY_SEARCH_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(WORKER_CODE, { eval: true, workerData: { moduleUrl: CORE_MODULE_URL, text, query } });
+        // Never let a scan keep the server process alive during shutdown.
+        worker.unref();
+        const timer = setTimeout(() => {
+            worker.terminate();
+            reject(new Error(`Fuzzy search timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref();
+        worker.on('message', (msg) => {
+            clearTimeout(timer);
+            if (msg.ok) {
+                captureFuzzySearchMetrics(msg.metrics);
+                resolve(msg.result);
+            }
+            else {
+                reject(new Error(`Fuzzy search worker failed: ${msg.error}`));
+            }
+            // Don't let the worker wind down on its own; the answer is already
+            // here, and a lingering worker holds its copy of the file text.
+            // The promise is settled, so the exit-code rejection below is a no-op.
+            worker.terminate();
+        });
+        worker.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        worker.on('exit', (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`Fuzzy search worker exited with code ${code}`));
+            }
+        });
     });
-    return {
-        start: bestStart,
-        end: bestEnd,
-        value: text.substring(bestStart, bestEnd),
-        distance: bestDistance
-    };
 }
-/**
- * Calculates the similarity ratio between two strings
- * @param a First string
- * @param b Second string
- * @returns Similarity ratio (0-1)
- */
-export function getSimilarityRatio(a, b) {
-    const maxLength = Math.max(a.length, b.length);
-    if (maxLength === 0)
-        return 1; // Both strings are empty
-    const levenshteinDistance = distance(a, b);
-    return 1 - (levenshteinDistance / maxLength);
+/** Same telemetry events the search used to emit inline, now sent from the main thread. */
+function captureFuzzySearchMetrics(metrics) {
+    capture('fuzzy_search_recursive_metrics', metrics.recursive);
+    if (metrics.iterative) {
+        capture('fuzzy_search_iterative_metrics', metrics.iterative);
+    }
 }

package/dist/tools/fuzzySearchCore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure fuzzy-search core, kept free of app imports on purpose: it runs inside
+ * the worker thread spawned by runFuzzySearchInWorker (fuzzySearch.ts), and
+ * anything imported here is loaded per worker. Telemetry is returned as data
+ * and captured on the main thread, which has the real client identity.
+ */
+export interface FuzzyMatch {
+    start: number;
+    end: number;
+    value: string;
+    distance: number;
+}
+export interface FuzzySearchMetrics {
+    recursive: {
+        execution_time_ms: number;
+        text_length: number;
+        query_length: number;
+        result_distance: number;
+    };
+    iterative: {
+        execution_time_ms: number;
+        iterations: number;
+        segment_length: number;
+        query_length: number;
+        final_distance: number;
+    } | null;
+}
+/**
+ * Runs a full fuzzy search and returns the match together with the timing
+ * metrics that used to be captured inline.
+ */
+export declare function runFuzzySearch(text: string, query: string): {
+    result: FuzzyMatch;
+    metrics: FuzzySearchMetrics;
+};
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number): FuzzyMatch;
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export declare function getSimilarityRatio(a: string, b: string): number;

package/dist/tools/fuzzySearchCore.js

@@ -0,0 +1,125 @@
+import { distance } from 'fastest-levenshtein';
+// Set by iterativeReduction during a search (exactly one terminal call per
+// search) and collected by runFuzzySearch. Single-threaded per context, so a
+// module-level slot is safe.
+let lastIterativeMetrics = null;
+/**
+ * Runs a full fuzzy search and returns the match together with the timing
+ * metrics that used to be captured inline.
+ */
+export function runFuzzySearch(text, query) {
+    const startTime = performance.now();
+    lastIterativeMetrics = null;
+    const result = recursiveFuzzyIndexOf(text, query);
+    return {
+        result,
+        metrics: {
+            recursive: {
+                execution_time_ms: performance.now() - startTime,
+                text_length: text.length,
+                query_length: query.length,
+                result_distance: result.distance
+            },
+            iterative: lastIterativeMetrics
+        }
+    };
+}
+/**
+ * Recursively finds the closest match to a query string within text using fuzzy matching
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text (default: 0)
+ * @param end End index in the text (default: text.length)
+ * @param parentDistance Best distance found so far (default: Infinity)
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+export function recursiveFuzzyIndexOf(text, query, start = 0, end = null, parentDistance = Infinity) {
+    if (end === null)
+        end = text.length;
+    // For small text segments, use iterative approach
+    if (end - start <= 2 * query.length) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    let midPoint = start + Math.floor((end - start) / 2);
+    let leftEnd = Math.min(end, midPoint + query.length); // Include query length to cover overlaps
+    let rightStart = Math.max(start, midPoint - query.length); // Include query length to cover overlaps
+    // Calculate distance for current segments
+    let leftDistance = distance(text.substring(start, leftEnd), query);
+    let rightDistance = distance(text.substring(rightStart, end), query);
+    let bestDistance = Math.min(leftDistance, parentDistance, rightDistance);
+    // If parent distance is already the best, use iterative approach
+    if (parentDistance === bestDistance) {
+        return iterativeReduction(text, query, start, end, parentDistance);
+    }
+    // Recursively search the better half
+    if (leftDistance < rightDistance) {
+        return recursiveFuzzyIndexOf(text, query, start, leftEnd, bestDistance);
+    }
+    else {
+        return recursiveFuzzyIndexOf(text, query, rightStart, end, bestDistance);
+    }
+}
+/**
+ * Iteratively refines the best match by reducing the search area
+ * @param text The text to search within
+ * @param query The query string to find
+ * @param start Start index in the text
+ * @param end End index in the text
+ * @param parentDistance Best distance found so far
+ * @returns Object with start and end indices, matched value, and Levenshtein distance
+ */
+function iterativeReduction(text, query, start, end, parentDistance) {
+    const startTime = performance.now();
+    let iterations = 0;
+    // Seed with the measured distance of this slice. For recursive callers
+    // this equals parentDistance (the parent measured exactly this slice), but
+    // a top-level call on text <= 2x query length arrives with Infinity, which
+    // made the first shrink unconditional and a position-0 match unreachable.
+    let bestDistance = distance(text.substring(start, end), query);
+    let bestStart = start;
+    let bestEnd = end;
+    // Improve start position
+    let nextDistance = distance(text.substring(bestStart + 1, bestEnd), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestStart++;
+        const smallerString = text.substring(bestStart + 1, bestEnd);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    // Improve end position
+    nextDistance = distance(text.substring(bestStart, bestEnd - 1), query);
+    while (nextDistance < bestDistance) {
+        bestDistance = nextDistance;
+        bestEnd--;
+        const smallerString = text.substring(bestStart, bestEnd - 1);
+        nextDistance = distance(smallerString, query);
+        iterations++;
+    }
+    lastIterativeMetrics = {
+        execution_time_ms: performance.now() - startTime,
+        iterations: iterations,
+        segment_length: end - start,
+        query_length: query.length,
+        final_distance: bestDistance
+    };
+    return {
+        start: bestStart,
+        end: bestEnd,
+        value: text.substring(bestStart, bestEnd),
+        distance: bestDistance
+    };
+}
+/**
+ * Calculates the similarity ratio between two strings
+ * @param a First string
+ * @param b Second string
+ * @returns Similarity ratio (0-1)
+ */
+export function getSimilarityRatio(a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    if (maxLength === 0)
+        return 1; // Both strings are empty
+    const levenshteinDistance = distance(a, b);
+    return 1 - (levenshteinDistance / maxLength);
+}

package/dist/tools/improved-process-tools.js

@@ -1,4 +1,4 @@
-import { terminalManager } from '../terminal-manager.js';
+import { terminalManager, MAX_BUFFERED_OUTPUT_CHARS } from '../terminal-manager.js';
 import { commandManager } from '../command-manager.js';
 import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
 import { capture } from "../utils/capture.js";
@@ -293,6 +293,13 @@ export async function readProcessOutput(args) {
         // Absolute position read
         statusMessage = `[Reading ${result.readCount} lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
     }
+    // Surface buffer-cap eviction so the model knows the retained output is not
+    // the full output and that line numbers shifted (matches the truncation
+    // markers used by other tools).
+    if (result.evictedLines && result.evictedLines > 0) {
+        const capMB = Math.round(MAX_BUFFERED_OUTPUT_CHARS / 1024 / 1024);
+        statusMessage += `\n[WARNING: output exceeded the ${capMB}MB buffer cap; the ${result.evictedLines} earliest lines were evicted and cannot be read. Line numbers and totals refer to the retained buffer only]`;
+    }
     // Add process state info
     let processStateMessage = '';
     if (result.isComplete) {

package/dist/tools/schemas.d.ts

@@ -72,18 +72,21 @@ export declare const ReadFileArgsSchema: z.ZodObject<{
     sheet: z.ZodOptional<z.ZodString>;
     range: z.ZodOptional<z.ZodString>;
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
     length: number;
     path: string;
     offset: number;
     isUrl: boolean;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     sheet?: string | undefined;
     range?: string | undefined;
 }, {
     path: string;
     length?: number | undefined;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     offset?: number | undefined;
     isUrl?: boolean | undefined;
     sheet?: string | undefined;
@@ -100,13 +103,16 @@ export declare const WriteFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
     mode: z.ZodDefault<z.ZodEnum<["rewrite", "append"]>>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     content: string;
     mode: "rewrite" | "append";
+    origin?: "ui" | "llm" | undefined;
 }, {
     path: string;
     content: string;
+    origin?: "ui" | "llm" | undefined;
     mode?: "rewrite" | "append" | undefined;
 }>;
 export declare const PdfInsertOperationSchema: z.ZodObject<{
@@ -237,11 +243,14 @@ export declare const CreateDirectoryArgsSchema: z.ZodObject<{
 export declare const ListDirectoryArgsSchema: z.ZodObject<{
     path: z.ZodString;
     depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
     path: string;
     depth: number;
+    origin?: "ui" | "llm" | undefined;
 }, {
     path: string;
+    origin?: "ui" | "llm" | undefined;
     depth?: number | undefined;
 }>;
 export declare const MoveFileArgsSchema: z.ZodObject<{
@@ -269,10 +278,12 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
     range: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
     file_path: string;
     expected_replacements: number;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
@@ -280,6 +291,7 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
 }, {
     file_path: string;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
@@ -289,6 +301,7 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
     file_path: string;
     expected_replacements: number;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
@@ -296,6 +309,7 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
 }, {
     file_path: string;
     options?: Record<string, any> | undefined;
+    origin?: "ui" | "llm" | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
@@ -417,3 +431,9 @@ export declare const TrackUiEventArgsSchema: z.ZodObject<{
     params?: Record<string, string | number | boolean | null> | undefined;
     component?: string | undefined;
 }>;
+/**
+ * Map of tool name -> argument schema, used by the dispatcher to detect and warn
+ * about parameters a caller sent that the tool does not support. Keep in sync
+ * with the tool definitions in server.ts.
+ */
+export declare const toolArgSchemas: Record<string, z.ZodTypeAny>;

package/dist/tools/schemas.js

@@ -43,7 +43,10 @@ export const ReadFileArgsSchema = z.object({
     length: z.number().optional().default(1000),
     sheet: z.string().optional(), // String only for MCP client compatibility (Cursor doesn't support union types in JSON Schema)
     range: z.string().optional(),
-    options: z.record(z.any()).optional()
+    options: z.record(z.any()).optional(),
+    // Whether the call came from the file-preview UI (refresh/navigation) or the
+    // LLM. Used only for telemetry attribution; see call_origin in server.ts.
+    origin: z.enum(['ui', 'llm']).optional(),
 });
 export const ReadMultipleFilesArgsSchema = z.object({
     paths: z.array(z.string()),
@@ -52,6 +55,8 @@ export const WriteFileArgsSchema = z.object({
     path: z.string(),
     content: z.string(),
     mode: z.enum(['rewrite', 'append']).default('rewrite'),
+    // Telemetry attribution: 'ui' when fired by the file-preview UI, else 'llm'.
+    origin: z.enum(['ui', 'llm']).optional(),
 });
 // PDF modification schemas - exported for reuse
 export const PdfInsertOperationSchema = z.object({
@@ -92,6 +97,8 @@ export const CreateDirectoryArgsSchema = z.object({
 export const ListDirectoryArgsSchema = z.object({
     path: z.string(),
     depth: z.number().optional().default(2),
+    // Telemetry attribution: 'ui' when fired by the file-preview UI, else 'llm'.
+    origin: z.enum(['ui', 'llm']).optional(),
 });
 export const MoveFileArgsSchema = z.object({
     source: z.string(),
@@ -114,7 +121,9 @@ export const EditBlockArgsSchema = z.object({
     // Structured file range rewrite (Excel, etc.)
     range: z.string().optional(),
     content: z.any().optional(),
-    options: z.record(z.any()).optional()
+    options: z.record(z.any()).optional(),
+    // Telemetry attribution: 'ui' when fired by the file-preview UI, else 'llm'.
+    origin: z.enum(['ui', 'llm']).optional(),
 }).refine(data => {
     // Helper to check if value is actually provided (not undefined, not empty string)
     const hasValue = (v) => v !== undefined && v !== '';
@@ -181,3 +190,37 @@ export const TrackUiEventArgsSchema = z.object({
     component: z.string().optional().default('file_preview'),
     params: z.record(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional().default({}),
 });
+/**
+ * Map of tool name -> argument schema, used by the dispatcher to detect and warn
+ * about parameters a caller sent that the tool does not support. Keep in sync
+ * with the tool definitions in server.ts.
+ */
+export const toolArgSchemas = {
+    get_config: GetConfigArgsSchema,
+    set_config_value: SetConfigValueArgsSchema,
+    read_file: ReadFileArgsSchema,
+    read_multiple_files: ReadMultipleFilesArgsSchema,
+    write_file: WriteFileArgsSchema,
+    write_pdf: WritePdfArgsSchema,
+    create_directory: CreateDirectoryArgsSchema,
+    list_directory: ListDirectoryArgsSchema,
+    move_file: MoveFileArgsSchema,
+    start_search: StartSearchArgsSchema,
+    get_more_search_results: GetMoreSearchResultsArgsSchema,
+    stop_search: StopSearchArgsSchema,
+    list_searches: ListSearchesArgsSchema,
+    get_file_info: GetFileInfoArgsSchema,
+    edit_block: EditBlockArgsSchema,
+    start_process: StartProcessArgsSchema,
+    read_process_output: ReadProcessOutputArgsSchema,
+    interact_with_process: InteractWithProcessArgsSchema,
+    force_terminate: ForceTerminateArgsSchema,
+    list_sessions: ListSessionsArgsSchema,
+    list_processes: ListProcessesArgsSchema,
+    kill_process: KillProcessArgsSchema,
+    get_usage_stats: GetUsageStatsArgsSchema,
+    get_recent_tool_calls: GetRecentToolCallsArgsSchema,
+    give_feedback_to_desktop_commander: GiveFeedbackArgsSchema,
+    get_prompts: GetPromptsArgsSchema,
+    track_ui_event: TrackUiEventArgsSchema,
+};

package/dist/types.d.ts

@@ -18,6 +18,9 @@ export interface TerminalSession {
     lastReadIndex: number;
     isBlocked: boolean;
     startTime: Date;
+    bufferedChars: number;
+    evictedLines: number;
+    evictedChars: number;
 }
 export interface CommandExecutionResult {
     pid: number;
@@ -69,7 +72,6 @@ export interface FilePreviewStructuredContent {
     defaultEditorName?: string;
     defaultEditorPath?: string;
     content?: string;
-    imageData?: string;
     mimeType?: string;
 }
 export interface ServerResult {