@wonderwhy-er/desktop-commander 0.2.41 → 0.2.43

package/README.md

@@ -17,8 +17,6 @@ Work with code and text, run processes, and automate tasks, going far beyond oth
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Desktop Commander MCP" />
 </a>
 
-## 👋 We’re hiring — come build with us: https://desktopcommander.app/careers/
-
 ## 🖥️ Try the Desktop Commander App (Beta)
 
 **Want a better experience?** The Desktop Commander App gives you everything the MCP server does, plus:

package/dist/handlers/filesystem-handlers.js

@@ -1,4 +1,4 @@
-import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, getFileInfo, writePdf } from '../tools/filesystem.js';
+import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory, moveFile, getFileInfo, writePdf, getDefaultEditorMetadata } from '../tools/filesystem.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { configManager } from '../config-manager.js';
@@ -99,6 +99,8 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'unsupported',
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
                     content: pdfContent
                         .filter((item) => item.type === "text")
                         .map((item) => item.text)
@@ -108,8 +110,9 @@ export async function handleReadFile(args) {
         }
         // Handle image files
         if (fileResult.metadata?.isImage) {
-            // For image files, keep content payload text-only for broad host compatibility.
-            // The preview widget reads image bytes from structuredContent.
+            // Return the image bytes in the MCP content array so the host model can
+            // actually see the image. structuredContent additionally carries the bytes
+            // for the preview widget to render.
             const imageData = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('base64');
@@ -119,14 +122,22 @@ export async function handleReadFile(args) {
                     {
                         type: "text",
                         text: imageSummary
+                    },
+                    {
+                        type: "image",
+                        data: imageData,
+                        mimeType: fileResult.mimeType
                     }
                 ],
                 structuredContent: {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType: 'image',
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
+                    // Image bytes for the preview widget, carried once. Deduped from the
+                    // old `content` + `imageData` pair down to this single `content` field.
                     content: imageData,
-                    imageData,
                     mimeType: fileResult.mimeType
                 }
             };
@@ -145,6 +156,8 @@ export async function handleReadFile(args) {
                     fileName: path.basename(resolvedFilePath),
                     filePath: resolvedFilePath,
                     fileType,
+                    sourceTool: 'read_file',
+                    ...await getDefaultEditorMetadata(resolvedFilePath),
                     content: textContent,
                 },
             };
@@ -252,6 +265,8 @@ export async function handleWriteFile(args) {
                 fileName: path.basename(resolvedWritePath),
                 filePath: resolvedWritePath,
                 fileType: resolvePreviewFileType(resolvedWritePath),
+                sourceTool: 'write_file',
+                ...await getDefaultEditorMetadata(resolvedWritePath),
             },
         };
     }
@@ -293,6 +308,11 @@ export async function handleListDirectory(args) {
                 fileName: path.basename(resolvedPath),
                 filePath: resolvedPath,
                 fileType: 'directory',
+                sourceTool: 'list_directory',
+                // Carry the listing in structuredContent too. Chat reads the text
+                // content array, but structuredContent-only consumers (e.g. Cowork)
+                // render from here and would otherwise show an empty directory.
+                content: resultText,
             },
         };
     }

package/dist/remote-device/remote-channel.d.ts

@@ -20,6 +20,8 @@ export declare class RemoteChannel {
     private onToolCall;
     private lastDeviceStatus;
     private lastChannelState;
+    private reconnectAttempt;
+    private isRecreatingChannel;
     private _user;
     get user(): User | null;
     initialize(url: string, key: string): void;
@@ -50,10 +52,22 @@ export declare class RemoteChannel {
      * This is used for both initial subscription and recreation after socket reconnects.
      */
     private createChannel;
+    /**
+     * Compact connection state for logs — e.g. "socket=open(1) ch=errored attempt=3".
+     * readyState 1=OPEN (a 1 while joins keep failing = a half-open socket being reused),
+     * 3=CLOSED, '-'=no socket. Reads realtime-js internals defensively; never throws.
+     */
+    private connState;
     /**
      * Check if channel is connected, recreate if not.
      */
     private checkConnectionHealth;
+    /**
+     * Run an async op but reject if it doesn't settle within `ms`, so a hung await
+     * can't leave isRecreatingChannel stuck true and disable the watchdog. Mirrors
+     * closeWithTimeout() in desktop-commander-integration.ts.
+     */
+    private withTimeout;
     /**
      * Recreate the channel by destroying old one and creating fresh instance.
      */

package/dist/remote-device/remote-channel.js

@@ -1,6 +1,9 @@
 import { createClient } from '@supabase/supabase-js';
 import { captureRemote } from '../utils/capture.js';
 const HEARTBEAT_INTERVAL = 15000;
+// Cap a single channel recreate so a hung await can't pin the re-entrancy guard
+// true (which would silently disable the connection watchdog).
+const RECREATE_TIMEOUT_MS = 30000;
 export class RemoteChannel {
     constructor() {
         this.client = null;
@@ -14,6 +17,9 @@ export class RemoteChannel {
         this.lastDeviceStatus = 'offline';
         // Track last channel state for debug logging
         this.lastChannelState = null;
+        // Reconnect diagnostics + guard (see connState() / recreateChannel())
+        this.reconnectAttempt = 0; // recreateChannel() attempts since last success
+        this.isRecreatingChannel = false; // a recreate is in flight (re-entrancy guard)
         this._user = null;
     }
     get user() { return this._user; }
@@ -128,7 +134,7 @@ export class RemoteChannel {
             console.debug('[DEBUG] Calling createChannel()');
             // ! Ignore silently in Initialization to reconnect after
             await this.createChannel().catch((error) => {
-                console.debug('[DEBUG] Failed to create channel, will retry after socket reconnect', error);
+                console.debug(`[DEBUG] Failed to create channel, will retry after socket reconnect: ${error?.message || error} — ${this.connState()}`);
             });
         }
         else {
@@ -162,9 +168,11 @@ export class RemoteChannel {
             })
                 .subscribe((status, err) => {
                 // Debug: Log all subscription status events
-                console.debug(`[DEBUG] Channel subscription status: ${status}${err ? ' (error: ' + err + ')' : ''}`);
+                console.debug(`[DEBUG] Channel subscription status: ${status}${err ? ' (error: ' + (err?.message || err) + ')' : ''} — ${this.connState()}`);
                 if (status === 'SUBSCRIBED') {
-                    console.log('✅ Channel subscribed');
+                    const recovered = this.reconnectAttempt;
+                    this.reconnectAttempt = 0;
+                    console.log(`✅ Channel subscribed${recovered > 0 ? ` (recovered after ${recovered} attempt${recovered === 1 ? '' : 's'})` : ''}`);
                     // Update device status on successful connection
                     if (this.deviceId) {
                         this.setOnlineStatus(this.deviceId, 'online').catch(e => {
@@ -174,20 +182,43 @@ export class RemoteChannel {
                     resolve();
                 }
                 else if (status === 'CHANNEL_ERROR') {
-                    // console.error('❌ Channel subscription failed:', err);
+                    // CHANNEL_ERROR is the only status carrying a real error message.
+                    console.error(`❌ Channel error: ${err?.message || 'unknown'} — ${this.connState()}`);
                     this.setOnlineStatus(this.deviceId, 'offline');
-                    captureRemote('remote_channel_subscription_error', { error: err || 'Channel error' }).catch(() => { });
+                    captureRemote('remote_channel_subscription_error', { error: err?.message || 'Channel error' }).catch(() => { });
                     reject(err || new Error('Failed to initialize tool call channel subscription'));
                 }
                 else if (status === 'TIMED_OUT') {
-                    console.error('⏱️ Channel subscription timed out, Reconnecting...');
+                    console.error(`⏱️ Channel subscription timed out, Reconnecting... — ${this.connState()}`);
                     this.setOnlineStatus(this.deviceId, 'offline');
-                    captureRemote('remote_channel_subscription_timeout', {}).catch(() => { });
+                    captureRemote('remote_channel_subscription_timeout', { attempt: this.reconnectAttempt }).catch(() => { });
                     reject(new Error('Tool call channel subscription timed out'));
                 }
+                else if (status === 'CLOSED') {
+                    // Settle the promise so an in-flight recreateChannel() can't await
+                    // forever (which would wedge the re-entrancy guard / watchdog), and
+                    // mark the device offline like the other degraded states.
+                    console.warn(`⚠️ Channel closed — ${this.connState()}`);
+                    this.setOnlineStatus(this.deviceId, 'offline');
+                    reject(new Error('Tool call channel closed during subscribe'));
+                }
             });
         });
     }
+    /**
+     * Compact connection state for logs — e.g. "socket=open(1) ch=errored attempt=3".
+     * readyState 1=OPEN (a 1 while joins keep failing = a half-open socket being reused),
+     * 3=CLOSED, '-'=no socket. Reads realtime-js internals defensively; never throws.
+     */
+    connState() {
+        let socket = '?';
+        try {
+            const rt = this.client?.realtime;
+            socket = `${rt?.connectionState?.() ?? '?'}(${rt?.conn?.readyState ?? '-'})`;
+        }
+        catch { /* best effort */ }
+        return `socket=${socket} ch=${this.channel?.state ?? '-'} attempt=${this.reconnectAttempt}`;
+    }
     /**
      * Check if channel is connected, recreate if not.
      */
@@ -198,41 +229,89 @@ export class RemoteChannel {
         const state = this.channel.state;
         // Debug: Log current channel state (only if changed)
         if (!this.lastChannelState || this.lastChannelState !== state) {
-            console.debug(`[DEBUG] channel state: ${state}`);
+            console.debug(`[DEBUG] channel state: ${state} — ${this.connState()}`);
             this.lastChannelState = state;
         }
-        // Aggressive health check: Only 'joined' is considered healthy
-        // Any other state (joining, leaving, closed, errored, etc.) triggers recreation
-        if (state !== 'joined') {
-            captureRemote('remote_channel_state_health', { state });
-            console.debug(`[DEBUG] ⚠️ Channel in unhealthy state '${state}' - recreating...`);
-            this.recreateChannel();
+        // 'joined' = healthy, 'joining' = transitional — let realtime-js's own rejoin
+        // backoff converge instead of tearing the channel down mid-join. (FIX: previously
+        // recreated on every non-joined state, which amputated that backoff.)
+        if (state === 'joined' || state === 'joining')
+            return;
+        // Unhealthy: closed, errored, leaving — recreate
+        captureRemote('remote_channel_state_health', { state, attempt: this.reconnectAttempt });
+        console.debug(`[DEBUG] ⚠️ Channel in unhealthy state '${state}' - recreating... — ${this.connState()}`);
+        this.recreateChannel();
+    }
+    /**
+     * Run an async op but reject if it doesn't settle within `ms`, so a hung await
+     * can't leave isRecreatingChannel stuck true and disable the watchdog. Mirrors
+     * closeWithTimeout() in desktop-commander-integration.ts.
+     */
+    async withTimeout(op, ms, name) {
+        let timer;
+        try {
+            return await Promise.race([
+                op(),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`${name} timed out after ${ms}ms`)), ms);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
         }
     }
     /**
      * Recreate the channel by destroying old one and creating fresh instance.
      */
-    recreateChannel() {
+    async recreateChannel() {
         if (!this.client || !this.user?.id || !this.onToolCall) {
             console.warn('Cannot recreate channel - missing parameters');
             console.debug('[DEBUG] recreateChannel() aborted - missing prerequisites');
             return;
         }
-        // Destroy old channel
-        if (this.channel) {
-            console.debug('[DEBUG] Destroying old channel');
-            this.client.removeChannel(this.channel);
-            this.channel = null;
+        // FIX: re-entrancy guard so a 10s health tick can't stack a second recreate
+        // on top of an in-flight one.
+        if (this.isRecreatingChannel) {
+            console.debug('[DEBUG] recreateChannel() skipped - already in progress');
+            return;
         }
+        this.isRecreatingChannel = true;
+        this.reconnectAttempt++;
         // Create fresh channel
-        console.log('🔄 Recreating channel...');
-        console.debug('[DEBUG] Calling createChannel() for recreation');
-        this.createChannel().catch(err => {
-            captureRemote('remote_channel_recreate_error', { err });
-            console.debug('[DEBUG] Channel recreation failed:', err.message);
-            // TODO: enable only for debug mode
-            // console.error('Failed to recreate channel:', err);
-        });
+        console.log(`🔄 Recreating channel... (attempt ${this.reconnectAttempt}) — ${this.connState()}`);
+        try {
+            // Cap the whole recreate: a never-settling await (e.g. a subscribe that only
+            // ever emits CLOSED) must not pin isRecreatingChannel=true and silently disable
+            // the 10s watchdog. On timeout we reject -> catch -> finally clears the guard.
+            await this.withTimeout(async () => {
+                // Destroy old channel — AWAIT it so the channel registry empties before we
+                // rebuild. (The un-awaited version raced the synchronous new-channel push, so
+                // realtime-js never tore the socket down and a half-open one got reused.)
+                if (this.channel) {
+                    console.debug('[DEBUG] Destroying old channel');
+                    await this.client.removeChannel(this.channel);
+                    this.channel = null;
+                }
+                // FIX (core): force a brand-new WebSocket. After idle / wifi-loss the socket can
+                // be HALF-OPEN (readyState OPEN but dead); reusing it made every join TIME_OUT
+                // forever. disconnect() drops it so the next subscribe() dials a fresh one.
+                try {
+                    await this.client.realtime?.disconnect?.();
+                }
+                catch { /* best effort */ }
+                console.debug('[DEBUG] Calling createChannel() for recreation');
+                await this.createChannel();
+            }, RECREATE_TIMEOUT_MS, 'recreateChannel');
+        }
+        catch (err) {
+            captureRemote('remote_channel_recreate_error', { errMsg: err?.message, attempt: this.reconnectAttempt });
+            console.debug(`[DEBUG] Channel recreation failed: ${err?.message} — ${this.connState()}`);
+        }
+        finally {
+            this.isRecreatingChannel = false;
+        }
     }
     async markCallExecuting(callId) {
         if (!this.client)

package/dist/server.d.ts

@@ -38,4 +38,9 @@ declare let currentClient: {
     name: string;
     version: string;
 };
-export { currentClient };
+declare let currentCallIsRemote: boolean;
+declare let currentRemoteClient: {
+    name?: string;
+    version?: string;
+} | null;
+export { currentClient, currentCallIsRemote, currentRemoteClient };

package/dist/server.js

@@ -8,7 +8,8 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
-import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, WritePdfArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, WritePdfArgsSchema, toolArgSchemas, } from './tools/schemas.js';
+import { detectUnsupportedParams, getSupportedParams, buildUnsupportedParamsWarning, } from './utils/unsupportedParams.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -21,8 +22,9 @@ import { handleWelcomePageOnboarding } from './utils/welcome-onboarding.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
-import { buildUiToolMeta, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI } from './ui/contracts.js';
+import { buildUiToolMeta, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI, } from './ui/contracts.js';
 import { listUiResources, readUiResource } from './ui/resources.js';
+import { shouldShowMcpUiPreviews } from './utils/mcp-ui-ab-test.js';
 // Store startup messages to send after initialization
 const deferredMessages = [];
 function deferLog(level, message) {
@@ -70,6 +72,34 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
 });
 // Store current client info (simple variable)
 let currentClient = { name: 'uninitialized', version: 'uninitialized' };
+// Tracks whether the in-flight tool call originated from a remote device.
+// Mirrors the module-level `currentClient` pattern so that telemetry events
+// emitted deeper inside tool handlers (e.g. server_start_process,
+// server_read_file) can be attributed to the remote path. The CallTool
+// handler sets this on every call (true when _meta.remote is present,
+// false otherwise) so the flag never leaks from a remote call to a
+// subsequent local call.
+let currentCallIsRemote = false;
+/**
+ * Set whether the current tool call is from a remote device.
+ * Called once per tool call by the CallTool handler.
+ */
+function setCurrentCallIsRemote(isRemote) {
+    currentCallIsRemote = isRemote;
+}
+// The remote caller's client for the in-flight tool call (e.g. openai-mcp,
+// claude-ai). Set per CallTool when the call is remote; null for local calls.
+// Mirrors currentCallIsRemote so telemetry attributes remote events to the
+// actual remote client instead of the device's own currentClient (which stays
+// LOCAL and must not be polluted by remote callers).
+let currentRemoteClient = null;
+/**
+ * Set the remote caller's client for the current tool call (null when local).
+ * Called once per tool call by the CallTool handler.
+ */
+function setCurrentRemoteClient(clientInfo) {
+    currentRemoteClient = clientInfo;
+}
 /**
  * Unified way to update client information
  */
@@ -131,7 +161,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
     }
 });
 // Export current client info for access by other modules
-export { currentClient };
+export { currentClient, currentCallIsRemote, currentRemoteClient };
 deferLog('info', 'Setting up request handlers...');
 /**
  * Check if a tool should be included based on current client
@@ -150,6 +180,7 @@ function shouldIncludeTool(toolName) {
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
         // logToStderr('debug', 'Generating tools list...');
+        const showMcpUiPreviews = await shouldShowMcpUiPreviews();
         // Build complete tools array
         const allTools = [
             // Configuration tools
@@ -169,7 +200,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(GetConfigArgsSchema),
-                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(CONFIG_EDITOR_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Get Configuration",
                     readOnlyHint: true,
@@ -262,7 +293,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Read File or URL",
                     readOnlyHint: true,
@@ -330,7 +361,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Write File",
                     readOnlyHint: false,
@@ -451,7 +482,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "List Directory Contents",
                     readOnlyHint: true,
@@ -710,7 +741,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
                 inputSchema: zodToJsonSchema(EditBlockArgsSchema),
-                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true),
+                _meta: buildUiToolMeta(FILE_PREVIEW_RESOURCE_URI, true, showMcpUiPreviews),
                 annotations: {
                     title: "Edit Block",
                     readOnlyHint: false,
@@ -1091,28 +1122,54 @@ import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
+    // Hoisted above the try so the finally block can read them when emitting the
+    // server_call_tool completion event (duration + status), even on the crash path.
+    let telemetryData = { tool_name: name };
+    let result;
+    let isError = false;
     try {
-        // Prepare telemetry data - add config key for set_config_value
-        const telemetryData = { tool_name: name };
-        // Extract metadata from _meta field if present
+        // telemetryData declared above; extract metadata from _meta field if present
         const metadata = request.params._meta;
-        if (metadata && typeof metadata === 'object') {
-            // add remote flag if present (convert to string for GA4)
-            if (metadata.remote) {
-                telemetryData.remote = String(metadata.remote);
-            }
-            // Dynamically update client info if provided in _meta
-            // To use in capture later
-            if (metadata.clientInfo) {
-                await updateCurrentClient(metadata.clientInfo);
-                telemetryData.client_name = metadata.clientInfo.name;
-                telemetryData.client_version = metadata.clientInfo.version;
-            }
+        // Reset remote attribution for every call so a prior remote call never
+        // leaks its flag onto a subsequent local call. Set to true only when
+        // this call carries the remote marker in _meta.
+        const isRemoteCall = !!(metadata && typeof metadata === 'object' && metadata.remote);
+        setCurrentCallIsRemote(isRemoteCall);
+        if (isRemoteCall) {
+            // add remote flag (convert to string for telemetry)
+            telemetryData.remote = String(metadata.remote);
+            // Remote calls carry the originating MCP client (e.g. openai-mcp,
+            // claude-ai) in _meta.clientInfo. Attribute this call to that remote
+            // client — NOT the device's own currentClient. Fall back to a sentinel
+            // when it's absent so the call is visibly remote-but-unattributed
+            // rather than masquerading as the local device client. We deliberately
+            // do NOT call updateCurrentClient here: currentClient tracks the LOCAL
+            // client and must not be polluted (nor its transport reconfigured) by
+            // remote callers.
+            const remoteClient = metadata.clientInfo && (metadata.clientInfo.name || metadata.clientInfo.version)
+                ? metadata.clientInfo
+                : { name: 'remote-unknown', version: 'unknown' };
+            setCurrentRemoteClient(remoteClient);
+            telemetryData.client_name = remoteClient.name;
+            telemetryData.client_version = remoteClient.version;
+        }
+        else {
+            // Local call — clear any remote attribution left by a prior call.
+            setCurrentRemoteClient(null);
         }
         if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
             telemetryData.set_config_value_key_name = args.key;
             telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
         }
+        // Attribute file-surface tool calls to the file-preview UI vs the LLM.
+        // The UI passes origin:'ui' when it fires these tools to refresh/navigate
+        // (pagination, folder expansion, link resolution, in-preview edits); the
+        // first read_file that opens a file comes from the LLM and is recorded as
+        // 'llm'. Lets us separate UI-refresh churn from genuine model-driven reads.
+        if ((name === 'read_file' || name === 'write_file' || name === 'edit_block' || name === 'list_directory') &&
+            args && typeof args === 'object') {
+            telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
+        }
         if (name === 'get_prompts' && args && typeof args === 'object') {
             const promptArgs = args;
             telemetryData.action = promptArgs.action;
@@ -1124,11 +1181,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 telemetryData.prompt_id = promptArgs.promptId;
             }
         }
-        capture_call_tool('server_call_tool', telemetryData);
         // Track tool call
         trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
-        let result;
+        // (result is declared above so the finally block can read execution status)
         switch (name) {
             // Config tools
             case "get_config":
@@ -1320,6 +1376,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
         const duration = Date.now() - startTime;
+        isError = !!result.isError;
         const EXCLUDED_TOOLS = [
             'get_recent_tool_calls',
             'track_ui_event'
@@ -1410,9 +1467,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Check if should prompt about Docker environment
             result = await processDockerPrompt(result, name);
         }
+        // If the caller sent parameters this tool does not support, Zod silently
+        // strips them. Prepend a corrective warning so the model knows they were
+        // ignored and which parameters are actually supported.
+        try {
+            const argSchema = toolArgSchemas[name];
+            if (argSchema && result && Array.isArray(result.content)) {
+                const unsupported = detectUnsupportedParams(args, argSchema);
+                if (unsupported.length > 0) {
+                    const warning = buildUnsupportedParamsWarning(name, unsupported, getSupportedParams(argSchema));
+                    result.content = [
+                        { type: "text", text: warning },
+                        ...result.content,
+                    ];
+                }
+            }
+        }
+        catch {
+            // Never let the advisory warning break an otherwise-successful call.
+        }
         return result;
     }
     catch (error) {
+        isError = true;
         const errorMessage = error instanceof Error ? error.message : String(error);
         // Track the failure
         await usageTracker.trackFailure(name);
@@ -1424,6 +1501,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             isError: true,
         };
     }
+    finally {
+        // Single tool-call telemetry event, fired AFTER execution so it can carry
+        // timing. In a finally so it still fires on the hard-crash path (the catch
+        // above). Only missed if a tool never returns or throws (a true hang).
+        capture_call_tool('server_call_tool', {
+            ...telemetryData,
+            duration_ms: Date.now() - startTime,
+            is_error: String(isError),
+        });
+    }
 });
 // Add no-op handlers so Visual Studio initialization succeeds
 server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({ resourceTemplates: [] }));