fix(core): truncate model-facing tool output

packages/core/src/core/coreToolScheduler.ts

@@ -3405,7 +3405,12 @@ export class CoreToolScheduler {
             this.config,
             toolName,
             content,
-            { threshold: perToolMax, lines: perToolLines, keep: perToolKeep },
+            {
+              threshold: perToolMax,
+              lines: perToolLines,
+              keep: perToolKeep,
+              callId,
+            },
             promptIdForTruncation,
           );
           content = truncated.content;
@@ -3460,6 +3465,7 @@ export class CoreToolScheduler {
                   threshold: baseThreshold * 2,
                   lines: combinedLines,
                   keep: perToolKeep,
+                  callId,
                 },
                 promptIdForTruncation,
               );

packages/core/src/telemetry/loggers.test.ts

@@ -1311,11 +1311,15 @@ describe('loggers', () => {
 
     it('should log a tool output truncated event', () => {
       const event = new ToolOutputTruncatedEvent('prompt-id-1', {
+        callId: 'call-id-1',
         toolName: 'test-tool',
         originalContentLength: 1000,
         truncatedContentLength: 100,
         threshold: 500,
         lines: 10,
+        outputFileSaved: false,
+        saveErrorCode: 'EACCES',
+        saveErrorMessage: 'permission denied',
       });
 
       logToolOutputTruncated(mockConfig, event);
@@ -1328,11 +1332,15 @@ describe('loggers', () => {
           'event.timestamp': '2025-01-01T00:00:00.000Z',
           eventName: 'tool_output_truncated',
           prompt_id: 'prompt-id-1',
+          call_id: 'call-id-1',
           tool_name: 'test-tool',
           original_content_length: 1000,
           truncated_content_length: 100,
           threshold: 500,
           lines: 10,
+          output_file_saved: false,
+          save_error_code: 'EACCES',
+          save_error_message: 'permission denied',
         },
       });
     });

packages/core/src/telemetry/qwen-logger/qwen-logger.ts

@@ -595,10 +595,14 @@ export class QwenLogger {
         tool_name: event.tool_name,
       },
       snapshots: JSON.stringify({
+        call_id: event.call_id,
         original_content_length: event.original_content_length,
         truncated_content_length: event.truncated_content_length,
         threshold: event.threshold,
         lines: event.lines,
+        output_file_saved: event.output_file_saved,
+        save_error_code: event.save_error_code,
+        save_error_message: event.save_error_message,
       }),
     });
 

packages/core/src/telemetry/types.ts

@@ -765,24 +765,36 @@ export class ToolOutputTruncatedEvent implements BaseTelemetryEvent {
   threshold: number;
   lines: number;
   prompt_id: string;
+  call_id?: string;
+  output_file_saved: boolean;
+  save_error_code?: string;
+  save_error_message?: string;
 
   constructor(
     prompt_id: string,
     details: {
+      callId?: string;
       toolName: string;
       originalContentLength: number;
       truncatedContentLength: number;
       threshold: number;
       lines: number;
+      outputFileSaved?: boolean;
+      saveErrorCode?: string;
+      saveErrorMessage?: string;
     },
   ) {
     this['event.name'] = this.eventName;
     this.prompt_id = prompt_id;
+    this.call_id = details.callId;
     this.tool_name = details.toolName;
     this.original_content_length = details.originalContentLength;
     this.truncated_content_length = details.truncatedContentLength;
     this.threshold = details.threshold;
     this.lines = details.lines;
+    this.output_file_saved = details.outputFileSaved ?? true;
+    this.save_error_code = details.saveErrorCode;
+    this.save_error_message = details.saveErrorMessage;
   }
 }
 

packages/core/src/tools/shell.test.ts

@@ -1450,62 +1450,21 @@ describe('ShellTool', () => {
         expect(result.llmContent).not.toContain('foreground command ran for');
       });
 
-      it('appends the hint AFTER truncation (so it survives `truncateToolOutput`)', async () => {
-        // `truncateToolOutput` wraps over-budget output in a "Truncated
-        // part of the output:" envelope. If the hint were appended
-        // inside that envelope (i.e. before truncation), the LLM might
-        // read the advisory as part of the command's own output. Pin
-        // the post-truncation insertion order: the hint must appear
-        // outside the truncation marker.
-        //
-        // Mock `truncateToolOutput` directly rather than driving real
-        // truncation — the real path needs `fs.writeFile` to actually
-        // succeed (the catch fallback returns no `outputFile`, so the
-        // shell.ts replacement branch never fires). Mocking here pins
-        // ordering, which is all this test cares about.
-        const truncationModule = await import('../utils/truncation.js');
-        const spy = vi
-          .spyOn(truncationModule, 'truncateToolOutput')
-          .mockResolvedValue({
-            content:
-              'Tool output was too large and has been truncated.\n[mocked truncated body]',
-            outputFile: '/tmp/qwen-temp/shell_mocked.output',
-          });
-
-        try {
-          const invocation = shellTool.build({
-            command: 'long-output-cmd',
-            is_background: false,
-          });
-          const promise = invocation.execute(mockAbortSignal);
-          await vi.advanceTimersByTimeAsync(60_000);
-          resolveShellExecution({ output: 'A'.repeat(500), exitCode: 0 });
-          const result = await promise;
+      it('appends the hint after command output is assembled', async () => {
+        const invocation = shellTool.build({
+          command: 'long-output-cmd',
+          is_background: false,
+        });
+        const promise = invocation.execute(mockAbortSignal);
+        await vi.advanceTimersByTimeAsync(60_000);
+        resolveShellExecution({ output: 'A'.repeat(500), exitCode: 0 });
+        const result = await promise;
 
-          const content = result.llmContent as string;
-          // Hint present.
-          expect(content).toContain('foreground command ran for 60s');
-          // Truncation envelope present (proves the truncation branch
-          // actually ran in shell.ts — `outputFile` was set so the
-          // replacement happened).
-          expect(content).toContain(
-            'Tool output was too large and has been truncated.',
-          );
-          // Hint comes AFTER the truncation marker — pins the
-          // post-truncation insertion order so a regression that
-          // moves the append back inside the non-aborted llmContent
-          // builder (where it'd get wrapped by the truncation
-          // envelope on long output) would fail loudly.
-          const truncIdx = content.indexOf(
-            'Tool output was too large and has been truncated.',
-          );
-          const hintIdx = content.indexOf('foreground command ran for');
-          expect(hintIdx).toBeGreaterThan(truncIdx);
-        } finally {
-          // Restore even if assertions throw — otherwise the
-          // truncateToolOutput spy leaks into subsequent tests.
-          spy.mockRestore();
-        }
+        const content = result.llmContent as string;
+        const outputIdx = content.indexOf('A'.repeat(20));
+        const hintIdx = content.indexOf('foreground command ran for');
+        expect(outputIdx).toBeGreaterThanOrEqual(0);
+        expect(hintIdx).toBeGreaterThan(outputIdx);
       });
 
       it('truncates shell output char-only so the line cap cannot undercut the char budget', async () => {

packages/core/src/utils/truncation.ts

@@ -200,6 +200,7 @@ export async function truncateToolOutput(
     threshold?: number;
     lines?: number;
     keep?: 'head' | 'tail' | 'both';
+    callId?: string;
   },
   promptId?: string,
 ): Promise<{ content: string; outputFile?: string }> {
@@ -234,16 +235,18 @@ export async function truncateToolOutput(
     keep,
   );
 
-  if (result.outputFile) {
+  if (result.content !== content) {
     try {
       logToolOutputTruncated(
         config,
         new ToolOutputTruncatedEvent(promptId ?? '', {
+          callId: limits?.callId,
           toolName,
           originalContentLength: originalLength,
           truncatedContentLength: result.content.length,
           threshold,
           lines,
+          outputFileSaved: Boolean(result.outputFile),
         }),
       );
     } catch {
@@ -271,6 +274,7 @@ export async function truncateLlmContent(
     threshold?: number;
     lines?: number;
     keep?: 'head' | 'tail' | 'both';
+    callId?: string;
   },
   promptId?: string,
 ): Promise<{ content: PartListUnion; outputFile?: string }> {