fix(ts-sdk): add error handling for JSON.parse and use async file I/O in ModelClient

- Add try/catch for JSON.parse in parseRequestLine and parseResponseLine
  to handle corrupted log files gracefully with meaningful error messages
- Replace readFileSync/appendFileSync with async readFile/appendFile
  from fs/promises to avoid blocking the event loop
- Re-throw parse errors immediately in popRequest instead of retrying
- Add tests for JSON parse error handling and async file I/O usage

Fixes PR alibaba#492 review feedback

Author: Timandes

rock/ts-sdk/src/model/client.test.ts

@@ -159,6 +159,59 @@ describe('ModelClient timeout and cancellation', () => {
     });
   });
 
+  describe('async file I/O', () => {
+    it('should import readFile from fs/promises (not readFileSync from fs)', async () => {
+      // Read the client.ts source to verify imports
+      const { readFileSync: readSource } = await import('fs');
+      const sourceCode = readSource(require.resolve('./client.js'), 'utf-8');
+
+      // Should import from fs/promises
+      expect(sourceCode).toMatch(/from ['"]fs\/promises['"]/);
+
+      // Should import readFile
+      expect(sourceCode).toMatch(/import\s+\{[^}]*readFile[^}]*\}\s+from\s+['"]fs\/promises['"]/);
+
+      // Should NOT import readFileSync
+      expect(sourceCode).not.toMatch(/readFileSync/);
+    });
+
+    it('should import appendFile from fs/promises (not appendFileSync from fs)', async () => {
+      // Read the client.ts source to verify imports
+      const { readFileSync: readSource } = await import('fs');
+      const sourceCode = readSource(require.resolve('./client.js'), 'utf-8');
+
+      // Should import appendFile from fs/promises
+      expect(sourceCode).toMatch(/import\s+\{[^}]*appendFile[^}]*\}\s+from\s+['"]fs\/promises['"]/);
+
+      // Should NOT import appendFileSync
+      expect(sourceCode).not.toMatch(/appendFileSync/);
+    });
+  });
+
+  describe('JSON parse error handling', () => {
+    it('should throw meaningful error when request line has corrupted JSON', async () => {
+      // Create log file with corrupted JSON in meta section
+      const content = `${REQUEST_START_MARKER}test-request${REQUEST_END_MARKER}{invalid json}\n`;
+      writeFileSync(logFile, content);
+
+      // Should throw "Invalid request line format" immediately
+      // NOT retry until timeout, NOT throw raw SyntaxError
+      await expect(client.popRequest(1, { timeout: 5 })).rejects.toThrow('Invalid request line format');
+    });
+
+    it('should throw meaningful error when response line has corrupted JSON', async () => {
+      // Create log file with request and corrupted response
+      const RESPONSE_START_MARKER = '__RESPONSE_START__';
+      const RESPONSE_END_MARKER = '__RESPONSE_END__';
+      const content = `${REQUEST_START_MARKER}test-request${REQUEST_END_MARKER}{"index":0}\n${RESPONSE_START_MARKER}response${RESPONSE_END_MARKER}{bad}\n`;
+      writeFileSync(logFile, content);
+
+      // pushResponse internally calls parseResponseLine
+      // Should throw "Invalid response line format"
+      await expect(client.pushResponse(1, 'new-response')).rejects.toThrow('Invalid response line format');
+    });
+  });
+
   describe('backward compatibility', () => {
     it('should use default timeout when not specified', async () => {
       // This test verifies backward compatibility

rock/ts-sdk/src/model/client.ts

@@ -2,7 +2,8 @@
  * Model client for LLM interaction
  */
 
-import { existsSync, readFileSync, appendFileSync } from 'fs';
+import { existsSync } from 'fs';
+import { readFile, appendFile } from 'fs/promises';
 import { initLogger } from '../logger.js';
 import { envVars } from '../env_vars.js';
 import { sleep } from '../utils/retry.js';
@@ -82,7 +83,7 @@ export class ModelClient {
     const lastResponseLine = await this.readLastResponseLine();
 
     if (lastResponseLine === null) {
-      this.appendResponse(content);
+      await this.appendResponse(content);
       return;
     }
 
@@ -98,7 +99,7 @@ export class ModelClient {
       return;
     }
 
-    this.appendResponse(content);
+    await this.appendResponse(content);
   }
 
   /**
@@ -139,9 +140,15 @@ export class ModelClient {
         logger.debug(`Last request is not the index ${index} we want, waiting...`);
         await sleep(1000);
       } catch (e) {
-        // Re-throw abort errors
-        if (e instanceof Error && e.message.includes('aborted')) {
-          throw e;
+        // Re-throw abort errors and parse errors immediately
+        if (e instanceof Error) {
+          if (e.message.includes('aborted')) {
+            throw e;
+          }
+          // Re-throw parse errors (invalid format) immediately - don't retry
+          if (e.message.includes('Invalid request line format')) {
+            throw e;
+          }
         }
         // For other errors (like file not found), wait and retry
         logger.debug(`Error reading request: ${e}, waiting...`);
@@ -177,7 +184,7 @@ export class ModelClient {
         continue;
       }
 
-      const content = readFileSync(this.logFile, 'utf-8');
+      const content = await readFile(this.logFile, 'utf-8');
       const lines = content.split('\n').filter((l) => l.trim());
 
       if (lines.length === 0) {
@@ -195,25 +202,35 @@ export class ModelClient {
       return { requestJson: SESSION_END_MARKER, meta: {} };
     }
 
-    const parts = lineContent.split(REQUEST_END_MARKER);
-    const metaJson = parts[1] ?? '';
-    const requestJson = parts[0]?.split(REQUEST_START_MARKER)[1] ?? '';
-    const meta = JSON.parse(metaJson);
+    try {
+      const parts = lineContent.split(REQUEST_END_MARKER);
+      const metaJson = parts[1] ?? '';
+      const requestJson = parts[0]?.split(REQUEST_START_MARKER)[1] ?? '';
+      const meta = JSON.parse(metaJson);
 
-    return { requestJson, meta };
+      return { requestJson, meta };
+    } catch (e) {
+      logger.error(`Failed to parse request line: ${lineContent}, error: ${e}`);
+      throw new Error(`Invalid request line format: ${e}`);
+    }
   }
 
   private parseResponseLine(lineContent: string): { responseJson: string; meta: Record<string, unknown> } {
-    const parts = lineContent.split(RESPONSE_END_MARKER);
-    const metaJson = parts[1] ?? '';
-    const responseJson = parts[0]?.split(RESPONSE_START_MARKER)[1] ?? '';
-    const meta = JSON.parse(metaJson);
-
-    return { responseJson, meta };
+    try {
+      const parts = lineContent.split(RESPONSE_END_MARKER);
+      const metaJson = parts[1] ?? '';
+      const responseJson = parts[0]?.split(RESPONSE_START_MARKER)[1] ?? '';
+      const meta = JSON.parse(metaJson);
+
+      return { responseJson, meta };
+    } catch (e) {
+      logger.error(`Failed to parse response line: ${lineContent}, error: ${e}`);
+      throw new Error(`Invalid response line format: ${e}`);
+    }
   }
 
   private async readLastRequestLine(): Promise<string> {
-    const content = readFileSync(this.logFile, 'utf-8');
+    const content = await readFile(this.logFile, 'utf-8');
     const lines = content.split('\n').filter((l) => l.trim());
 
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -227,7 +244,7 @@ export class ModelClient {
   }
 
   private async readLastResponseLine(): Promise<string | null> {
-    const content = readFileSync(this.logFile, 'utf-8');
+    const content = await readFile(this.logFile, 'utf-8');
     const lines = content.split('\n').filter((l) => l.trim());
 
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -240,8 +257,8 @@ export class ModelClient {
     return null;
   }
 
-  private appendResponse(content: string): void {
-    appendFileSync(this.logFile, content);
+  private async appendResponse(content: string): Promise<void> {
+    await appendFile(this.logFile, content);
   }
 
   private constructResponse(lastResponse: string, index: number): string {