@librechat/agents 3.9.3 → 3.9.5

package/src/openai/toolProjection.ts

@@ -0,0 +1,318 @@
+import type {
+  OpenAIChatCompletionChunkChoice,
+  OpenAIToolCall,
+  OpenAIStreamTracker,
+} from './index';
+import type { EventHandler, ModelResponseEvent } from '@/types';
+import { serializeToolArguments } from './arguments';
+import { GraphEvents } from '@/common';
+
+interface OpenAIToolCallStreamOptions {
+  /** Synchronous framing only. Async transport/backpressure is a separate boundary. */
+  emit?: (delta: OpenAIChatCompletionChunkChoice['delta']) => void;
+  signal?: AbortSignal;
+  /** Bound retained complete-before-publish output, not model execution. Default: 1024. */
+  maxToolCalls?: number;
+  /** UTF-8 bytes of serialized arguments, names and IDs retained across accepted responses. Default: 4 MiB. */
+  maxBufferedBytes?: number;
+}
+
+/** Streaming hosts share the finalizer's tracker; map-only hosts collect JSON output. */
+export type OpenAIToolCallStreamConfig = OpenAIToolCallStreamOptions &
+  (
+    | {
+        tracker: OpenAIStreamTracker;
+        toolCalls?: never;
+        emit: NonNullable<OpenAIToolCallStreamOptions['emit']>;
+      }
+    | { toolCalls: Map<number, OpenAIToolCall>; tracker?: never }
+  );
+
+export interface OpenAIToolCallStream {
+  /** Pass directly to Run.create({ customHandlers: stream.handlers }). */
+  handlers: Record<string, EventHandler>;
+  /** Publish only after the host verifies that the entire run completed successfully. */
+  finish: () => void;
+  abort: () => void;
+}
+
+function positiveLimit(value: number | undefined, fallback: number): number {
+  const limit = value ?? fallback;
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error('Tool projection limits must be positive safe integers');
+  }
+  return limit;
+}
+
+/** Serializes finalized, accepted tool calls. No provider fragments or attempt inference. */
+export function createOpenAIToolCallStream(
+  config: OpenAIToolCallStreamConfig
+): OpenAIToolCallStream {
+  const { emit, signal, tracker } = config;
+  const suppliedMap: unknown = config.toolCalls;
+  const suppliedEmitter: unknown = emit;
+  if (tracker != null && typeof suppliedEmitter !== 'function') {
+    throw new Error('A streaming tracker requires an emitter');
+  }
+  if (tracker != null && suppliedMap != null) {
+    throw new Error('Provide a tracker or a tool-call map, not both');
+  }
+  const toolCalls = tracker?.toolCalls ?? config.toolCalls;
+  if (toolCalls == null)
+    throw new Error('Provide a tracker or a tool-call map');
+  if (toolCalls.size !== 0)
+    throw new Error('Tool projection requires an empty output map');
+  let previousChunkKind: OpenAIStreamTracker['lastChunkKind'];
+  let acceptedTerminalKind: OpenAIStreamTracker['lastChunkKind'];
+  const maxCalls = positiveLimit(config.maxToolCalls, 1024);
+  const maxBytes = positiveLimit(config.maxBufferedBytes, 4 * 1024 * 1024);
+  const calls: Array<{
+    id: string;
+    name: string;
+    arguments: string;
+    agentId: string;
+    messageId?: string;
+    acceptedId: string;
+    bytes: number;
+  }> = [];
+  const providerIds = new Set<string>();
+  const acceptedIds = new Set<string>();
+  let bufferedBytes = 0;
+  let phase: 'open' | 'emitting' | 'finished' | 'aborted' = 'open';
+
+  const release = (): void => {
+    calls.length = 0;
+    acceptedIds.clear();
+    providerIds.clear();
+    bufferedBytes = 0;
+  };
+  const discard = (agentId: string, messageId?: string): void => {
+    for (let i = calls.length - 1; i >= 0; i--) {
+      const call = calls[i];
+      if (
+        call.agentId !== agentId ||
+        (messageId != null && call.messageId !== messageId)
+      )
+        continue;
+      bufferedBytes -= call.bytes;
+      calls.splice(i, 1);
+    }
+    acceptedIds.clear();
+    providerIds.clear();
+    for (const call of calls) {
+      acceptedIds.add(call.acceptedId);
+      if (call.id !== '') providerIds.add(call.id);
+    }
+    acceptedTerminalKind = calls.length > 0 ? 'tool_call' : 'text';
+  };
+  const abort = (): void => {
+    const phaseBeforeAbort = phase;
+    if (phase !== 'finished') {
+      phase = 'aborted';
+      toolCalls.clear();
+      if (tracker != null && phaseBeforeAbort === 'emitting')
+        tracker.lastChunkKind = previousChunkKind;
+    }
+    release();
+  };
+  const checkCancellation = (): void => {
+    if (signal?.aborted === true) abort();
+    if (phase === 'aborted') {
+      const error = new Error('Agent response aborted');
+      error.name = 'AbortError';
+      throw error;
+    }
+  };
+  const emitDelta = (delta: OpenAIChatCompletionChunkChoice['delta']): void => {
+    const result: unknown = emit?.(delta);
+    if (
+      result != null &&
+      typeof result === 'object' &&
+      'then' in result &&
+      typeof result.then === 'function'
+    ) {
+      // Observe a mistakenly async sink's rejection, then fail closed. Never silently
+      // publish a successful terminal response before pending writes settle.
+      void Promise.resolve(result).catch(() => undefined);
+      throw new Error('Tool projection requires a synchronous emitter');
+    }
+  };
+  const accept = (result: ModelResponseEvent): void => {
+    if (phase !== 'open') return;
+    try {
+      checkCancellation();
+      if (result.invalidToolCalls.length > 0) {
+        throw new Error('Accepted model response contains invalid tool calls');
+      }
+      const ownership = result.toolCallDispositions;
+      if (
+        !Array.isArray(ownership) ||
+        ownership.length !== result.toolCalls.length ||
+        ownership.some(
+          (value) =>
+            value !== 'sdk' && value !== 'provider' && value !== 'client'
+        )
+      ) {
+        throw new Error('Accepted tool calls lack trusted execution ownership');
+      }
+      const delegated = result.toolCalls.filter(
+        (_call, index) => ownership[index] === 'client'
+      );
+      if (delegated.length === 0) {
+        // A text or internal-only response supersedes this agent's request,
+        // never a sibling's. Neither 'sdk' nor 'provider' enters the wire.
+        discard(result.agentId);
+        return;
+      }
+      if (result.id.trim() === '' || acceptedIds.has(result.id)) {
+        throw new Error('Missing or repeated accepted model response identity');
+      }
+      if (calls.length + delegated.length > maxCalls) {
+        throw new Error('Tool projection call limit exceeded');
+      }
+      acceptedIds.add(result.id);
+      for (const call of delegated) {
+        if (typeof call.name !== 'string' || call.name.trim() === '') {
+          throw new Error('Accepted tool call is missing its name');
+        }
+        const id = call.id ?? '';
+        if (typeof id !== 'string')
+          throw new Error('Accepted tool call ID must be a string');
+        if (id !== '') providerIds.add(id);
+        const identityBytes =
+          Buffer.byteLength(id, 'utf8') + Buffer.byteLength(call.name, 'utf8');
+        const args = serializeToolArguments(
+          call.args,
+          maxBytes - bufferedBytes - identityBytes
+        );
+        const bytes = identityBytes + Buffer.byteLength(args, 'utf8');
+        bufferedBytes += bytes;
+        calls.push({
+          id,
+          name: call.name,
+          arguments: args,
+          bytes,
+          agentId: result.agentId,
+          messageId: result.messageId,
+          acceptedId: result.id,
+        });
+      }
+      acceptedTerminalKind = 'tool_call';
+    } catch (error) {
+      abort();
+      throw error;
+    }
+  };
+
+  return {
+    handlers: {
+      [GraphEvents.ON_MODEL_TOOLS_CLAIMED]: {
+        handle: (event, data): void => {
+          if (
+            event !== GraphEvents.ON_MODEL_TOOLS_CLAIMED ||
+            data == null ||
+            !('type' in data) ||
+            data.type !== 'model_tools_claimed'
+          )
+            return;
+          if (phase !== 'open')
+            throw new Error('Tool projection is already finalized');
+          checkCancellation();
+          discard(data.agentId, data.messageId);
+        },
+      },
+      [GraphEvents.ON_MODEL_RESPONSE]: {
+        handle: (event, data): void => {
+          if (
+            event !== GraphEvents.ON_MODEL_RESPONSE ||
+            data == null ||
+            !('type' in data) ||
+            data.type !== 'model_response'
+          )
+            return;
+          accept(data);
+        },
+      },
+    },
+    abort,
+    finish: (): void => {
+      if (phase === 'finished' || phase === 'emitting') return;
+      checkCancellation();
+      previousChunkKind = tracker?.lastChunkKind;
+      phase = 'emitting';
+      try {
+        if (toolCalls.size !== 0)
+          throw new Error(
+            'Tool projection output was modified during collection'
+          );
+        // Do not allocate synthetic IDs until every accepted response has arrived.
+        // This reserves provider IDs even when they occur in a later invocation.
+        const usedIds = new Set<string>();
+        const ready: OpenAIToolCall[] = [];
+        let reservedBytes = bufferedBytes;
+        let nextSyntheticId = 0;
+        for (const call of calls) {
+          let id = call.id;
+          if (id === '' || usedIds.has(id)) {
+            do {
+              id = `call_${nextSyntheticId++}`;
+            } while (providerIds.has(id) || usedIds.has(id));
+            reservedBytes +=
+              Buffer.byteLength(id, 'utf8') -
+              Buffer.byteLength(call.id, 'utf8');
+            if (reservedBytes > maxBytes)
+              throw new Error('Tool projection buffer limit exceeded');
+          }
+          usedIds.add(id);
+          ready.push(
+            Object.freeze({
+              id,
+              type: 'function',
+              function: Object.freeze({
+                name: call.name,
+                arguments: call.arguments,
+              }),
+            })
+          );
+        }
+        if (tracker != null && ready.length > 0 && !tracker.hasRole) {
+          tracker.hasRole = true;
+          emitDelta({ role: 'assistant' });
+          checkCancellation();
+        }
+        for (let index = 0; index < ready.length; index++) {
+          checkCancellation();
+          const call = ready[index];
+          toolCalls.set(index, call);
+          if (tracker != null) tracker.lastChunkKind = acceptedTerminalKind;
+          emitDelta({
+            tool_calls: [
+              {
+                index,
+                id: call.id,
+                type: 'function',
+                function: { name: call.function.name, arguments: '' },
+              },
+            ],
+          });
+          checkCancellation();
+          emitDelta({
+            tool_calls: [
+              { index, function: { arguments: call.function.arguments } },
+            ],
+          });
+          checkCancellation();
+        }
+        if (tracker != null && acceptedTerminalKind != null) {
+          tracker.lastChunkKind = acceptedTerminalKind;
+        }
+        phase = 'finished';
+      } catch (error) {
+        abort();
+        throw error;
+      } finally {
+        release();
+      }
+    },
+  };
+}

package/src/run.ts

@@ -468,6 +468,7 @@ export class Run<_T extends t.BaseGraphState> {
   private langfuse?: t.LangfuseConfig;
   private toolOutputReferences?: t.ToolOutputReferencesConfig;
   private eagerEventToolExecution?: t.EagerEventToolExecutionConfig;
+  private clientDelegatedToolNames?: readonly string[];
   private codeSessionToolNames?: string[];
   private interruptingToolNames?: string[];
   private toolExecution?: t.ToolExecutionConfig;
@@ -549,12 +550,19 @@ export class Run<_T extends t.BaseGraphState> {
       }
     }
 
+    if (
+      (config.clientDelegatedToolNames?.length ?? 0) > 0 &&
+      handlerRegistry.getHandler(GraphEvents.ON_MODEL_RESPONSE) == null
+    ) {
+      throw new Error('Client tool delegation requires an accepted-result handler');
+    }
     this.handlerRegistry = handlerRegistry;
     this.hookRegistry = config.hooks;
     this.humanInTheLoop = config.humanInTheLoop;
     this.langfuse = config.langfuse;
     this.toolOutputReferences = config.toolOutputReferences;
     this.eagerEventToolExecution = config.eagerEventToolExecution;
+    this.clientDelegatedToolNames = config.clientDelegatedToolNames;
     this.codeSessionToolNames = config.codeSessionToolNames;
     this.interruptingToolNames = config.interruptingToolNames;
     this.toolExecution = config.toolExecution;
@@ -573,6 +581,9 @@ export class Run<_T extends t.BaseGraphState> {
 
     /** Handle different graph types */
     if (config.graphConfig.type === 'multi-agent') {
+      if (this.clientDelegatedToolNames != null && this.clientDelegatedToolNames.length > 0) {
+        throw new Error('Client tool delegation requires a single-agent graph');
+      }
       this.graphRunnable = this.createMultiAgentGraph(config.graphConfig);
       if (this.Graph) {
         this.Graph.handlerRegistry = handlerRegistry;
@@ -663,6 +674,7 @@ export class Run<_T extends t.BaseGraphState> {
         preemption: this.preemption,
         streamLimits: this.streamLimits,
         toolExecution: this.toolExecution,
+        clientDelegatedToolNames: this.clientDelegatedToolNames,
       },
     });
     /** Propagate compile options from graph config */
@@ -1058,6 +1070,11 @@ export class Run<_T extends t.BaseGraphState> {
       ) {
         return;
       }
+      // Accepted results are graph-owned, never inferred from provider/tool callbacks.
+      if (
+        eventName === GraphEvents.ON_MODEL_RESPONSE ||
+        eventName === GraphEvents.ON_MODEL_TOOLS_CLAIMED
+      ) return;
       const handler = this.handlerRegistry?.getHandler(eventName);
       /**
        * Tool completions arriving over the custom-event channel are the only
@@ -1554,6 +1571,10 @@ export class Run<_T extends t.BaseGraphState> {
 
           const modelEndAt =
             eventName === GraphEvents.CHAT_MODEL_END ? Date.now() : undefined;
+          if (
+            eventName === GraphEvents.ON_MODEL_RESPONSE ||
+            eventName === GraphEvents.ON_MODEL_TOOLS_CLAIMED
+          ) continue;
           const handler = this.handlerRegistry?.getHandler(eventName);
           if (handler) {
             await handler.handle(eventName, data, metadata, this.Graph);

package/src/session/AgentSession.ts

@@ -27,6 +27,7 @@ import {
   deriveSessionMessages,
   releaseSessionProjection,
 } from './sessionProjection';
+import { FADING_TIER_VERSION, isFadingTier } from '@/messages/fading';
 import { createSummarizeNode } from '@/summarization/node';
 import { resolveStreamLimits } from '@/llm/streamLimits';
 import { JsonlSessionStore } from './JsonlSessionStore';
@@ -34,7 +35,6 @@ import { AgentContext } from '@/agents/AgentContext';
 import { ContentTypes, GraphEvents } from '@/common';
 import { createRunId, createSessionId } from './ids';
 import { deriveMessages } from './deriveMessages';
-import { isFadingTier } from '@/messages/fading';
 import { createRunHandlers } from './handlers';
 import { Run } from '@/run';
 
@@ -420,7 +420,7 @@ function mergeFadingTier(
     masked !== current.masked ||
     masked !== incoming.masked;
   return {
-    v: 1,
+    v: FADING_TIER_VERSION,
     budgetTokens,
     masked,
     ...(latched ? { latched: true } : {}),

package/src/stream.ts

@@ -56,6 +56,7 @@ import {
   truncateToolResultContent,
 } from '@/utils/truncation';
 import { resolveToolOutcome, outcomeFieldsFromResult } from '@/tools/intentArg';
+import { snapshotValidatedModelChunk } from '@/graphs/acceptedModelResponse';
 import { TOOL_OUTPUT_REF_PATTERN } from '@/tools/toolOutputReferences';
 import { PreparedSubagentError } from '@/tools/preparedSubagents';
 import { isReasoningContentBlock } from '@/messages/core';
@@ -746,6 +747,10 @@ function createEagerToolExecutionPlan(args: {
         toolCall.id == null ||
         toolCall.id === '' ||
         toolCall.name === '' ||
+        // A serialized parsed call is not a prepared executable object;
+        // parsing is permitted only on sealed raw tool_call_chunks.
+        typeof toolCall.args === 'string' ||
+        graph.clientDelegatedToolNames?.has(toolCall.name) === true ||
         (!skipExisting && graph.eagerEventToolExecutions.has(toolCall.id))
     )
   ) {
@@ -794,6 +799,9 @@ function startEagerToolExecutions(args: {
   skipExisting?: boolean;
 }): void {
   const { graph, metadata, agentContext, toolCalls, skipExisting } = args;
+  // A later call in the same model turn may be client-delegated. Do not
+  // pre-execute an earlier SDK call in a run that rejects mixed batches.
+  if ((graph.clientDelegatedToolNames?.size ?? 0) > 0) return;
   const entries = createEagerToolExecutionPlan({
     graph,
     metadata,
@@ -1345,6 +1353,10 @@ function startPreparedSubagents(
   metadata?: Record<string, unknown>
 ): void {
   const attempt = resolveGenerationKey(metadata);
+  if ((graph.clientDelegatedToolNames?.size ?? 0) > 0) return;
+  // A parsed string call is not executable even if the same event carries
+  // sealed raw fragments. Wait for a separately validated complete call.
+  if (chunk.tool_calls?.some((call) => typeof call.args === 'string') === true) return;
   if (
     (graph as Partial<StandardGraph>).canPrestartSubagents?.(agentContext) !==
       true ||
@@ -1389,6 +1401,9 @@ function startPreparedSubagents(
   for (const call of calls) {
     if (
       call.name === Constants.SUBAGENT &&
+      graph.clientDelegatedToolNames?.has(call.name) !== true &&
+      typeof call.args === 'object' &&
+      !Array.isArray(call.args) &&
       !hasToolOutputReference(call.args)
     ) {
       graph.prestartSubagent(call, attempt, agentContext);
@@ -1643,7 +1658,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
-    const chunk = data.chunk as Partial<AIMessageChunk>;
+    let chunk = data.chunk as Partial<AIMessageChunk>;
 
     /** Attempts stamp their breaker epoch into event metadata; a mismatch
      * marks a straggling chunk from a failed run that outlived
@@ -1681,6 +1696,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
       }
     };
 
+    // Callback delivery can beat the producer's iterator. Validate before
+    // accounting, run steps, or eager dispatch reads raw tool descriptors.
+    chunk = snapshotValidatedModelChunk(chunk as AIMessageChunk);
+
     /**
      * Enforced before every content-specific early return below
      * (server-tool results, deferred mixed reasoning, late OpenRouter
@@ -1885,6 +1904,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
           chunk.response_metadata as Record<string, unknown> | undefined
         );
       const canStreamEager =
+        chunk.tool_calls?.some((call) => typeof call.args === 'string') !== true &&
         (allowSequentialSeal || hasExplicitStreamedToolCallSeals(chunk)) &&
         !hasPotentialDirectToolInStreamContext({ graph, agentContext }) &&
         isEagerToolExecutionEnabledForBatch({ graph, metadata, agentContext });

package/src/tools/ArtifactTruncation.ts

@@ -0,0 +1,85 @@
+import type { ArtifactTruncation, ArtifactTruncationReason } from '@/types';
+
+const MAX_REPORTED_TRUNCATED_PATHS = 20;
+const ARTIFACT_TRUNCATION_REASONS = new Set<string>([
+  'max_files',
+  'depth',
+  'size',
+  'path',
+  'unreadable',
+]);
+
+function isNonNegativeInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+
+export function normalizeArtifactTruncation(
+  value: unknown
+): ArtifactTruncation | undefined {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+
+  const candidate = value as Partial<ArtifactTruncation>;
+  if (
+    candidate.code !== 'artifact_truncated' ||
+    !isNonNegativeInteger(candidate.skipped_count) ||
+    candidate.skipped_count === 0 ||
+    candidate.reasons == null ||
+    typeof candidate.reasons !== 'object' ||
+    Array.isArray(candidate.reasons) ||
+    !Array.isArray(candidate.skipped) ||
+    candidate.skipped.length > MAX_REPORTED_TRUNCATED_PATHS ||
+    candidate.skipped.length > candidate.skipped_count ||
+    candidate.skipped.some((path) => typeof path !== 'string')
+  ) {
+    return undefined;
+  }
+
+  const reasons: ArtifactTruncation['reasons'] = {};
+  let reasonTotal = 0;
+  for (const [reason, count] of Object.entries(candidate.reasons)) {
+    if (
+      !ARTIFACT_TRUNCATION_REASONS.has(reason) ||
+      !isNonNegativeInteger(count)
+    ) {
+      return undefined;
+    }
+    reasonTotal += count;
+    if (reasonTotal > candidate.skipped_count) {
+      return undefined;
+    }
+    reasons[reason as ArtifactTruncationReason] = count;
+  }
+
+  if (reasonTotal !== candidate.skipped_count) {
+    return undefined;
+  }
+
+  return {
+    code: candidate.code,
+    reasons,
+    skipped: [...candidate.skipped],
+    skipped_count: candidate.skipped_count,
+  };
+}
+
+export function appendArtifactTruncationWarning(
+  output: string,
+  truncation: ArtifactTruncation | undefined
+): string {
+  if (truncation == null) {
+    return output;
+  }
+
+  const reasons = Object.entries(truncation.reasons)
+    .map(([reason, count]) => `${reason}: ${count}`)
+    .join(', ');
+  const shown = truncation.skipped.length;
+  const paths =
+    shown > 0
+      ? ` Not delivered: ${truncation.skipped.join(', ')}${shown < truncation.skipped_count ? ` (${shown} of ${truncation.skipped_count} shown)` : ''}.`
+      : '';
+  const warning = `Note: ${truncation.skipped_count} file(s) were omitted from delivery${reasons ? ` (${reasons})` : ''}.${paths} Write fewer files per execution or combine them into an archive. The code itself ran; do not rerun automatically because it may have had side effects.`;
+  return `${output.trimEnd()}\n${warning}\n`;
+}

package/src/tools/BashExecutor.ts

@@ -23,14 +23,18 @@ import {
   appendArtifactDeliveryWarning,
   normalizeArtifactDeliveryFailure,
 } from '@/tools/ArtifactDelivery';
-import { logCodeApiDiagnostic } from '@/tools/diagnostics';
+import {
+  appendArtifactTruncationWarning,
+  normalizeArtifactTruncation,
+} from '@/tools/ArtifactTruncation';
 import { appendExecutionArtifactFileSummary } from '@/tools/CodeSessionFileSummary';
 import { resolveAttachedWorkspaceInstanceId } from '@/tools/workspaceIdentity';
+import { prepareBashProgrammaticCode } from './BashProgrammaticToolCalling';
+import { logCodeApiDiagnostic } from '@/tools/diagnostics';
+import { makeRequest } from './ProgrammaticToolCalling';
 import { resolveFetchProxyAgent } from '@/utils/proxy';
 import { INTENT_PROPERTY } from '@/tools/intentArg';
 import { Constants } from '@/common';
-import { prepareBashProgrammaticCode } from './BashProgrammaticToolCalling';
-import { makeRequest } from './ProgrammaticToolCalling';
 
 config();
 
@@ -407,6 +411,13 @@ function createBashExecutionTool(
           outputWithReminder,
           artifactDelivery
         );
+        const artifactTruncation = normalizeArtifactTruncation(
+          result.artifact_truncation
+        );
+        const outputWithWarnings = appendArtifactTruncationWarning(
+          outputWithDeliveryWarning,
+          artifactTruncation
+        );
         const hasFiles = result.files != null && result.files.length > 0;
         const deletionEcho =
           result.deleted_files != null
@@ -422,11 +433,11 @@ function createBashExecutionTool(
         return [
           hasWorkspace
             ? appendExecutionArtifactFileSummary(
-              outputWithDeliveryWarning,
+              outputWithWarnings,
               result.files
             )
             : appendCodeSessionFileSummary(
-              outputWithDeliveryWarning,
+              outputWithWarnings,
               result.files
             ),
           (hasFiles
@@ -436,6 +447,9 @@ function createBashExecutionTool(
               ...(artifactDelivery != null
                 ? { artifact_delivery: artifactDelivery }
                 : {}),
+              ...(artifactTruncation != null
+                ? { artifact_truncation: artifactTruncation }
+                : {}),
               ...deletionEcho,
               ...runtimeEcho,
             }
@@ -444,6 +458,9 @@ function createBashExecutionTool(
               ...(artifactDelivery != null
                 ? { artifact_delivery: artifactDelivery }
                 : {}),
+              ...(artifactTruncation != null
+                ? { artifact_truncation: artifactTruncation }
+                : {}),
               ...deletionEcho,
               ...runtimeEcho,
             }) satisfies t.CodeExecutionArtifact,

package/src/tools/CodeExecutor.ts

@@ -9,6 +9,10 @@ import {
   appendArtifactDeliveryWarning,
   normalizeArtifactDeliveryFailure,
 } from '@/tools/ArtifactDelivery';
+import {
+  appendArtifactTruncationWarning,
+  normalizeArtifactTruncation,
+} from '@/tools/ArtifactTruncation';
 import {
   describeCodeApiError,
   logCodeApiDiagnostic,
@@ -671,6 +675,13 @@ function createCodeExecutionTool(
           outputWithReminder,
           artifactDelivery
         );
+        const artifactTruncation = normalizeArtifactTruncation(
+          result.artifact_truncation
+        );
+        const outputWithWarnings = appendArtifactTruncationWarning(
+          outputWithDeliveryWarning,
+          artifactTruncation
+        );
         const hasFiles = result.files != null && result.files.length > 0;
         const deletionEcho =
           result.deleted_files != null
@@ -687,7 +698,7 @@ function createCodeExecutionTool(
             }
             : {};
         return [
-          appendCodeSessionFileSummary(outputWithDeliveryWarning, result.files),
+          appendCodeSessionFileSummary(outputWithWarnings, result.files),
           (hasFiles
             ? {
               session_id: result.session_id,
@@ -695,6 +706,9 @@ function createCodeExecutionTool(
               ...(artifactDelivery != null
                 ? { artifact_delivery: artifactDelivery }
                 : {}),
+              ...(artifactTruncation != null
+                ? { artifact_truncation: artifactTruncation }
+                : {}),
               ...deletionEcho,
               ...runtimeEcho,
             }
@@ -703,6 +717,9 @@ function createCodeExecutionTool(
               ...(artifactDelivery != null
                 ? { artifact_delivery: artifactDelivery }
                 : {}),
+              ...(artifactTruncation != null
+                ? { artifact_truncation: artifactTruncation }
+                : {}),
               ...deletionEcho,
               ...runtimeEcho,
             }) satisfies t.CodeExecutionArtifact,