fix(cli): Handle ACP read_file for managed local paths

packages/cli/src/acp-integration/acpAgent.ts

@@ -20,6 +20,7 @@ import {
   findProviderById,
   getAllGeminiMdFilenames,
   getAutoMemoryRoot,
+  getUserAutoMemoryRoot,
   getDefaultBaseUrlForProtocol,
   getDefaultModelIds,
   getScopedEnvContents,
@@ -130,6 +131,7 @@ import { pipeline } from 'node:stream/promises';
 import * as fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { createGunzip } from 'node:zlib';
 import type { LoadedSettings } from '../config/settings.js';
 import {
@@ -7627,6 +7629,18 @@ class QwenAgent implements Agent {
       config.getSessionId(),
       this.clientCapabilities.fs,
       config.getFileSystemService(),
+      {
+        localReadRoots: [
+          config.storage.getProjectTempDir(),
+          path.join(config.storage.getProjectDir(), 'subagents'),
+          Storage.getGlobalTempDir(),
+          os.tmpdir(),
+          getAutoMemoryRoot(config.getTargetDir()),
+          getUserAutoMemoryRoot(),
+          ...config.storage.getUserSkillsDirs(),
+          Storage.getUserExtensionsDir(),
+        ],
+      },
     );
     config.setFileSystemService(acpFileSystemService);
   }

packages/cli/src/acp-integration/service/filesystem.test.ts

@@ -8,6 +8,8 @@ import { describe, expect, it, vi } from 'vitest';
 import type { FileSystemService } from '@qwen-code/qwen-code-core';
 import { AcpFileSystemService } from './filesystem.js';
 import type { AgentSideConnection } from '@agentclientprotocol/sdk';
+import os from 'node:os';
+import path from 'node:path';
 
 const RESOURCE_NOT_FOUND_CODE = -32002;
 const INTERNAL_ERROR_CODE = -32603;
@@ -73,7 +75,7 @@ describe('AcpFileSystemService', () => {
       });
     });
 
-    it('re-throws other errors unchanged', async () => {
+    it('preserves code and message for other read errors', async () => {
       const otherError = {
         code: INTERNAL_ERROR_CODE,
         message: 'Internal error',
@@ -97,6 +99,136 @@ describe('AcpFileSystemService', () => {
       });
     });
 
+    it('normalizes plain object ACP errors to Error instances with the original message', async () => {
+      const otherError = {
+        code: INTERNAL_ERROR_CODE,
+        message: 'Internal error',
+      };
+      const client = {
+        readTextFile: vi.fn().mockRejectedValue(otherError),
+      } as unknown as AgentSideConnection;
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-2b',
+        { readTextFile: true, writeTextFile: true },
+        createFallback(),
+      );
+
+      const err = await svc
+        .readTextFile({ path: '/some/file.txt' })
+        .catch((e: unknown) => e);
+
+      expect(err).toBeInstanceOf(Error);
+      expect(err).toMatchObject({
+        code: INTERNAL_ERROR_CODE,
+        message: 'Internal error',
+      });
+      expect(String(err)).toContain('Internal error');
+      expect(String(err)).not.toContain('[object Object]');
+    });
+
+    it('falls back to local reads for allowed local roots when ACP rejects them as outside the workspace', async () => {
+      const skillRoot = path.join(os.homedir(), '.qwen', 'skills');
+      const filePath = path.join(
+        skillRoot,
+        'dataworks-di-data-processor',
+        'instructions',
+        'interaction_norms.md',
+      );
+      const pathOutsideWorkspaceError = {
+        code: INTERNAL_ERROR_CODE,
+        message: `path escapes workspace: ${filePath}`,
+        data: {
+          errorKind: 'path_outside_workspace',
+          status: 400,
+        },
+      };
+      const client = {
+        readTextFile: vi.fn().mockRejectedValue(pathOutsideWorkspaceError),
+      } as unknown as AgentSideConnection;
+      const fallback = createFallback();
+      (fallback.readTextFile as ReturnType<typeof vi.fn>).mockResolvedValue({
+        content: 'skill instructions',
+        _meta: { bom: false, encoding: 'utf-8' },
+      });
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-2c',
+        { readTextFile: true, writeTextFile: true },
+        fallback,
+        { localReadRoots: [skillRoot] },
+      );
+
+      await expect(svc.readTextFile({ path: filePath })).resolves.toEqual({
+        content: 'skill instructions',
+        _meta: { bom: false, encoding: 'utf-8' },
+      });
+      expect(fallback.readTextFile).toHaveBeenCalledWith({ path: filePath });
+    });
+
+    it('does not fall back to local reads outside configured roots', async () => {
+      const localRoot = path.join(os.tmpdir(), 'acp-local-read-root');
+      const filePath = path.join(os.tmpdir(), 'outside-local-root.md');
+      const pathOutsideWorkspaceError = {
+        code: INTERNAL_ERROR_CODE,
+        message: `path escapes workspace: ${filePath}`,
+        data: {
+          errorKind: 'path_outside_workspace',
+          status: 400,
+        },
+      };
+      const client = {
+        readTextFile: vi.fn().mockRejectedValue(pathOutsideWorkspaceError),
+      } as unknown as AgentSideConnection;
+      const fallback = createFallback();
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-2e',
+        { readTextFile: true, writeTextFile: true },
+        fallback,
+        { localReadRoots: [localRoot] },
+      );
+
+      await expect(svc.readTextFile({ path: filePath })).rejects.toMatchObject({
+        code: INTERNAL_ERROR_CODE,
+        message: `path escapes workspace: ${filePath}`,
+      });
+      expect(fallback.readTextFile).not.toHaveBeenCalled();
+    });
+
+    it('ignores empty configured local read roots', async () => {
+      const filePath = path.join(process.cwd(), 'outside-workspace.md');
+      const pathOutsideWorkspaceError = {
+        code: INTERNAL_ERROR_CODE,
+        message: `path escapes workspace: ${filePath}`,
+        data: {
+          errorKind: 'path_outside_workspace',
+          status: 400,
+        },
+      };
+      const client = {
+        readTextFile: vi.fn().mockRejectedValue(pathOutsideWorkspaceError),
+      } as unknown as AgentSideConnection;
+      const fallback = createFallback();
+
+      const svc = new AcpFileSystemService(
+        client,
+        'session-2f',
+        { readTextFile: true, writeTextFile: true },
+        fallback,
+        { localReadRoots: [''] },
+      );
+
+      await expect(svc.readTextFile({ path: filePath })).rejects.toMatchObject({
+        code: INTERNAL_ERROR_CODE,
+        message: `path escapes workspace: ${filePath}`,
+      });
+      expect(fallback.readTextFile).not.toHaveBeenCalled();
+    });
+
     it('uses fallback when readTextFile capability is disabled', async () => {
       const client = {
         readTextFile: vi.fn(),

packages/cli/src/acp-integration/service/filesystem.ts

@@ -16,8 +16,19 @@ import type {
   FileSystemService,
   ReadTextFileResponse,
 } from '@qwen-code/qwen-code-core';
+import { getErrorMessage } from '../../utils/errors.js';
+import path from 'node:path';
 
 const RESOURCE_NOT_FOUND_CODE = -32002;
+const PATH_OUTSIDE_WORKSPACE_KIND = 'path_outside_workspace';
+
+interface AcpFileSystemServiceOptions {
+  localReadRoots?: readonly string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
 
 function getErrorCode(error: unknown): unknown {
   if (error instanceof RequestError) {
@@ -31,6 +42,37 @@ function getErrorCode(error: unknown): unknown {
   return undefined;
 }
 
+function getErrorData(error: unknown): Record<string, unknown> | undefined {
+  const data = isRecord(error) ? error['data'] : undefined;
+  return isRecord(data) ? data : undefined;
+}
+
+function getErrorKind(error: unknown): unknown {
+  const data = getErrorData(error);
+  if (data && typeof data['errorKind'] === 'string') {
+    return data['errorKind'];
+  }
+  if (isRecord(error) && typeof error['errorKind'] === 'string') {
+    return error['errorKind'];
+  }
+  return undefined;
+}
+
+function normalizeError(error: unknown): Error {
+  if (error instanceof Error) return error;
+
+  const normalized = new Error(getErrorMessage(error)) as Error &
+    Record<string, unknown>;
+  if (isRecord(error)) {
+    for (const [key, value] of Object.entries(error)) {
+      if (key !== 'message') {
+        normalized[key] = value;
+      }
+    }
+  }
+  return normalized;
+}
+
 function createEnoentError(filePath: string): NodeJS.ErrnoException {
   const err = new Error(`File not found: ${filePath}`) as NodeJS.ErrnoException;
   err.code = 'ENOENT';
@@ -39,12 +81,25 @@ function createEnoentError(filePath: string): NodeJS.ErrnoException {
   return err;
 }
 
+function isPathWithinRoot(filePath: string, root: string): boolean {
+  if (!root.trim()) return false;
+
+  const relative = path.relative(path.resolve(root), path.resolve(filePath));
+  return (
+    relative === '' ||
+    (!relative.startsWith(`..${path.sep}`) &&
+      relative !== '..' &&
+      !path.isAbsolute(relative))
+  );
+}
+
 export class AcpFileSystemService implements FileSystemService {
   constructor(
     private readonly connection: AgentSideConnection,
     private readonly sessionId: string,
     private readonly capabilities: FileSystemCapability,
     private readonly fallback: FileSystemService,
+    private readonly options: AcpFileSystemServiceOptions = {},
   ) {}
 
   async readTextFile(
@@ -67,7 +122,14 @@ export class AcpFileSystemService implements FileSystemService {
         throw createEnoentError(params.path);
       }
 
-      throw error;
+      if (
+        getErrorKind(error) === PATH_OUTSIDE_WORKSPACE_KIND &&
+        this.isLocalReadFallbackPath(params.path)
+      ) {
+        return this.fallback.readTextFile(params);
+      }
+
+      throw normalizeError(error);
     }
 
     return response;
@@ -97,4 +159,10 @@ export class AcpFileSystemService implements FileSystemService {
   findFiles(fileName: string, searchPaths: readonly string[]): string[] {
     return this.fallback.findFiles(fileName, searchPaths);
   }
+
+  private isLocalReadFallbackPath(filePath: string): boolean {
+    return (this.options.localReadRoots ?? []).some((root) =>
+      isPathWithinRoot(filePath, root),
+    );
+  }
 }

packages/core/src/utils/errors.test.ts

@@ -42,6 +42,20 @@ describe('getErrorMessage cause unwrapping', () => {
     const err = new Error('same', { cause: new Error('same') });
     expect(getErrorMessage(err)).toBe('same');
   });
+
+  it('uses the message from plain error-like objects', () => {
+    expect(
+      getErrorMessage({
+        code: -32603,
+        message: 'path escapes workspace: /root/.qwen/skills/example.md',
+        data: { errorKind: 'path_outside_workspace' },
+      }),
+    ).toBe('path escapes workspace: /root/.qwen/skills/example.md');
+  });
+
+  it('stringifies plain objects without a message', () => {
+    expect(getErrorMessage({ code: -32603 })).toBe('{"code":-32603}');
+  });
 });
 
 describe('isAbortError', () => {

packages/core/src/utils/errors.ts

@@ -88,6 +88,17 @@ export function getErrorMessage(error: unknown): string {
     }
     return error.message;
   }
+  if (error !== null && typeof error === 'object') {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string' && message.trim()) {
+      return message;
+    }
+    try {
+      return JSON.stringify(error) ?? String(error);
+    } catch {
+      return String(error);
+    }
+  }
   try {
     return String(error);
   } catch {

packages/core/src/utils/fileUtils.test.ts

@@ -1055,6 +1055,29 @@ describe('fileUtils', () => {
       expect(result.returnDisplay).toContain('Simulated read error');
     });
 
+    it('should surface messages from plain object text read errors', async () => {
+      actualNodeFs.writeFileSync(testTextFilePath, 'content');
+      vi.spyOn(fsService, 'readTextFile').mockRejectedValueOnce({
+        code: -32603,
+        message:
+          'path escapes workspace: /root/.qwen/skills/dataworks-di-data-processor/instructions/interaction_norms.md',
+        data: {
+          errorKind: 'path_outside_workspace',
+          status: 400,
+        },
+      });
+
+      const result = await processSingleFileContent(
+        testTextFilePath,
+        mockConfig,
+      );
+
+      expect(result.error).toContain('path escapes workspace');
+      expect(result.returnDisplay).toContain('path escapes workspace');
+      expect(result.error).not.toContain('[object Object]');
+      expect(result.returnDisplay).not.toContain('[object Object]');
+    });
+
     it('should handle read errors for image/pdf files', async () => {
       actualNodeFs.writeFileSync(testImageFilePath, 'content'); // File must exist
       mockMimeGetType.mockReturnValue('image/png');

packages/core/src/utils/fileUtils.ts

@@ -18,7 +18,7 @@ import { ToolErrorType } from '../tools/tool-error.js';
 import { BINARY_EXTENSIONS } from './ignorePatterns.js';
 import type { Config } from '../config/config.js';
 import { createDebugLogger } from './debugLogger.js';
-import { isNodeError } from './errors.js';
+import { getErrorMessage, isNodeError } from './errors.js';
 import type { InputModalities } from '../core/contentGenerator.js';
 import { detectEncodingFromBuffer } from './systemEncoding.js';
 import { extractPDFText, parsePDFPageRange } from './pdf.js';
@@ -1242,7 +1242,7 @@ export async function processSingleFileContent(
       }
     }
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMessage = getErrorMessage(error);
     const displayPath = path
       .relative(rootDirectory, filePath)
       .replace(/\\/g, '/');