@librechat/agents 3.7.10 → 3.7.12

package/src/graphs/Graph.ts

@@ -2620,6 +2620,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         // run_id); `executingAgentId` always identifies the owning agent.
         agentId: this.subagentScope ? agentContext?.agentId : undefined,
         executingAgentId: agentContext?.agentId,
+        executingAgentName: agentContext?.name,
+        rootAgentId: this.defaultAgentId,
+        rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
         toolCallStepIds: this.toolCallStepIds,
         toolRegistry: agentContext?.toolRegistry,
         getDiscoveredToolNames: (): readonly string[] =>
@@ -2697,6 +2700,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       // hooks can attribute the batch even at the top level.
       agentId: this.subagentScope ? agentContext?.agentId : undefined,
       executingAgentId: agentContext?.agentId,
+      executingAgentName: agentContext?.name,
+      rootAgentId: this.defaultAgentId,
+      rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
       toolCallStepIds: this.toolCallStepIds,
       errorHandler: (data, metadata): Promise<boolean> =>
         StandardGraph.handleToolCallErrorStatic(this, data, metadata),
@@ -3815,6 +3821,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         parentMessageId: config.configurable?.requestBody?.parentMessageId,
         agentId,
         agentName: agentContext.name,
+        rootAgentId: this.defaultAgentId,
+        rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
+        activeAgentId: agentId,
+        activeAgentName: agentContext.name,
       });
       let langfuseHandler: CallbackEntry | undefined;
       let invokeConfig = {

package/src/graphs/MultiAgentGraph.ts

@@ -101,6 +101,14 @@ function isTransferToolName(name: unknown): boolean {
   );
 }
 
+function graphToolName(tool: unknown): string | undefined {
+  if (tool == null || typeof tool !== 'object' || !('name' in tool)) {
+    return undefined;
+  }
+  const { name } = tool;
+  return typeof name === 'string' ? name : undefined;
+}
+
 /**
  * Drop transfer `tool_use` content blocks from an AI message's array content.
  * Companion to the reception's tool-call filtering: array-content providers
@@ -287,6 +295,21 @@ function withHandoffGroupMetadata(
   };
 }
 
+function withActiveAgentMetadata(
+  config: LangGraphRunnableConfig | undefined,
+  agentId: string,
+  agentName: string | undefined
+): LangGraphRunnableConfig {
+  return {
+    ...config,
+    metadata: {
+      ...config?.metadata,
+      activeAgentId: agentId,
+      ...(agentName == null ? {} : { activeAgentName: agentName }),
+    },
+  };
+}
+
 /**
  * MultiAgentGraph extends StandardGraph to support dynamic multi-agent workflows
  * with handoffs, fan-in/fan-out, and other composable patterns.
@@ -594,6 +617,24 @@ export class MultiAgentGraph extends StandardGraph {
   private createHandoffTools(): void {
     // Group handoff edges by source agent(s)
     const handoffsByAgent = new Map<string, t.GraphEdge[]>();
+    const tokenAccountingRefresh = new Set<string>();
+
+    /** Transfer tool names are SDK-reserved. Remove externally supplied or
+     * stale transfer tools before deriving the source agent's allowed set
+     * from the graph edges below. */
+    for (const agentContext of this.agentContexts.values()) {
+      const originalTools = agentContext.graphTools;
+      const retainedTools = agentContext.graphTools?.filter(
+        (graphTool) => !isTransferToolName(graphToolName(graphTool))
+      );
+      if (retainedTools?.length !== originalTools?.length) {
+        tokenAccountingRefresh.add(agentContext.agentId);
+      }
+      agentContext.graphTools =
+        retainedTools != null && retainedTools.length > 0
+          ? retainedTools
+          : undefined;
+    }
 
     // Only process handoff edges for tool creation
     for (const edge of this.handoffEdges) {
@@ -643,6 +684,29 @@ export class MultiAgentGraph extends StandardGraph {
       for (const handoffTool of handoffTools) {
         agentContext.graphTools.push(handoffTool);
       }
+      if (handoffTools.length > 0) {
+        tokenAccountingRefresh.add(agentId);
+      }
+    }
+
+    for (const agentId of tokenAccountingRefresh) {
+      const agentContext = this.agentContexts.get(agentId);
+      if (agentContext?.tokenCounter == null) {
+        continue;
+      }
+      const { tokenCounter, baseIndexTokenCountMap } = agentContext;
+      agentContext.tokenCalculationPromise = agentContext
+        .calculateInstructionTokens(tokenCounter)
+        .then(() => {
+          agentContext.updateTokenMapWithInstructions(baseIndexTokenCountMap);
+        })
+        .catch((err) => {
+          // eslint-disable-next-line no-console
+          console.error(
+            'Error recalculating instruction tokens after handoff tool updates:',
+            err
+          );
+        });
     }
   }
 
@@ -1239,10 +1303,16 @@ export class MultiAgentGraph extends StandardGraph {
       ): Promise<t.MultiAgentGraphState | Command> => {
         let result: t.MultiAgentGraphState;
         let inputMessages = state.messages;
-        const memberConfig =
+        const agentContext = this.agentContexts.get(agentId);
+        const recursionLimitedConfig =
           this.memberRecursionLimit == null
             ? config
             : { ...config, recursionLimit: this.memberRecursionLimit };
+        const memberConfig = withActiveAgentMetadata(
+          recursionLimitedConfig,
+          agentId,
+          agentContext?.name
+        );
 
         /**
          * Check if this agent is receiving a handoff.
@@ -1254,7 +1324,6 @@ export class MultiAgentGraph extends StandardGraph {
           state.messages,
           agentId
         );
-        const agentContext = this.agentContexts.get(agentId);
 
         if (
           handoffContext?.sourceAgentName != null &&

package/src/langfuse.ts

@@ -783,17 +783,29 @@ export function createLangfuseTraceMetadata({
   parentMessageId,
   agentId,
   agentName,
+  rootAgentId,
+  rootAgentName,
+  activeAgentId,
+  activeAgentName,
 }: {
   messageId?: unknown;
   parentMessageId?: unknown;
   agentId?: unknown;
   agentName?: unknown;
+  rootAgentId?: unknown;
+  rootAgentName?: unknown;
+  activeAgentId?: unknown;
+  activeAgentName?: unknown;
 }): LangfuseTraceMetadata {
   return createTraceMetadata({
     messageId,
     parentMessageId,
     agentId,
     agentName,
+    rootAgentId,
+    rootAgentName,
+    activeAgentId,
+    activeAgentName,
   });
 }
 

package/src/messages/format.ts

@@ -2771,12 +2771,22 @@ function extractSkillName(args: unknown): string | undefined {
   return typeof name === 'string' && name !== '' ? name : undefined;
 }
 
+function isSdkManagedToolName(name: unknown): name is string {
+  return (
+    typeof name === 'string' &&
+    (name === Constants.SUBAGENT ||
+      name === 'conditional_transfer' ||
+      name.startsWith(Constants.LC_TRANSFER_TO_))
+  );
+}
+
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
  * @param payload - The array of messages to format.
  * @param indexTokenCountMap - Optional map of message indices to token counts.
- * @param tools - Optional set of tool names that are allowed in the request.
+ * @param tools - Optional set of host-managed tool names allowed in the request. SDK-managed tool
+ *   names are preserved independently.
  * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @param options - Optional formatting options (provider, skipSkillBodyNames).
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
@@ -2957,8 +2967,8 @@ export const formatAgentMessages = (
 
     /**
      * If tools set is provided, process tool_calls:
-     * - Keep valid tool_calls (tools in the set or dynamically discovered)
-     * - Convert invalid tool_calls to string representation for context preservation
+     * - Keep valid tool_calls (tools in the set, SDK-managed, or dynamically discovered)
+     * - Omit invalid tool_calls without exposing their output as assistant-authored text
      * - Dynamically expand the set when tool_search results are encountered
      */
     let processedMessage = message;
@@ -2977,8 +2987,6 @@ export const formatAgentMessages = (
         const filteredContent: typeof content = [];
         const filteredSourceContentPartIndices: SourceContentPartIndices[] = [];
         const invalidToolCallIds = new Set<string>();
-        const invalidToolStrings: string[] = [];
-        const invalidToolSourceContentPartIndices: number[] = [];
 
         for (let partIndex = 0; partIndex < content.length; partIndex++) {
           const part = content[partIndex] as
@@ -3029,7 +3037,10 @@ export const formatAgentMessages = (
             }
           }
 
-          if (discoveredTools.has(toolName)) {
+          if (
+            discoveredTools.has(toolName) ||
+            isSdkManagedToolName(toolName)
+          ) {
             filteredContent.push(part);
             filteredSourceContentPartIndices.push(partSourceContentIndices);
             if (
@@ -3042,20 +3053,11 @@ export const formatAgentMessages = (
                 (pendingSkillNames ??= new Set()).add(skillName);
               }
             }
-          } else {
-            /** Invalid tool - convert to string for context preservation */
-            if (
-              typeof part.tool_call.id === 'string' &&
-              part.tool_call.id !== ''
-            ) {
-              invalidToolCallIds.add(part.tool_call.id);
-            }
-            const output = part.tool_call.output ?? '';
-            invalidToolStrings.push(`Tool: ${toolName}, ${output}`);
-            appendSourceContentPartIndices(
-              invalidToolSourceContentPartIndices,
-              partSourceContentIndices
-            );
+          } else if (
+            typeof part.tool_call.id === 'string' &&
+            part.tool_call.id !== ''
+          ) {
+            invalidToolCallIds.add(part.tool_call.id);
           }
         }
 
@@ -3076,57 +3078,8 @@ export const formatAgentMessages = (
           }
         }
 
-        /** Append invalid tool strings to the content for context preservation */
-        if (invalidToolStrings.length > 0) {
-          /** Find the last text part or create one */
-          let lastTextPartIndex = -1;
-          for (let j = filteredContent.length - 1; j >= 0; j--) {
-            if (filteredContent[j].type === ContentTypes.TEXT) {
-              lastTextPartIndex = j;
-              break;
-            }
-          }
-
-          const invalidToolText = invalidToolStrings.join('\n');
-          if (lastTextPartIndex >= 0) {
-            const lastTextPart = filteredContent[lastTextPartIndex] as {
-              type: string;
-              [ContentTypes.TEXT]?: string;
-              text?: string;
-            };
-            const existingText =
-              lastTextPart[ContentTypes.TEXT] ?? lastTextPart.text ?? '';
-            filteredContent[lastTextPartIndex] = {
-              ...lastTextPart,
-              [ContentTypes.TEXT]: existingText
-                ? `${existingText}\n${invalidToolText}`
-                : invalidToolText,
-            };
-            const lastTextSourceContentPartIndices =
-              filteredSourceContentPartIndices[lastTextPartIndex];
-            filteredSourceContentPartIndices[lastTextPartIndex] = [
-              ...(typeof lastTextSourceContentPartIndices === 'number'
-                ? [lastTextSourceContentPartIndices]
-                : lastTextSourceContentPartIndices),
-              ...invalidToolSourceContentPartIndices,
-            ];
-          } else {
-            /** No text part exists, create one */
-            filteredContent.push({
-              type: ContentTypes.TEXT,
-              [ContentTypes.TEXT]: invalidToolText,
-            });
-            filteredSourceContentPartIndices.push(
-              invalidToolSourceContentPartIndices
-            );
-          }
-        }
-
         /** Use filtered content if we made any changes */
-        if (
-          filteredContent.length !== content.length ||
-          invalidToolStrings.length > 0
-        ) {
+        if (filteredContent.length !== content.length) {
           processedMessage = { ...message, content: filteredContent };
           processedSourceContentPartIndices = filteredSourceContentPartIndices;
         }

package/src/run.ts

@@ -1311,6 +1311,10 @@ export class Run<_T extends t.BaseGraphState> {
       parentMessageId: config.configurable?.requestBody?.parentMessageId,
       agentId: graph.defaultAgentId,
       agentName: primaryContext?.name,
+      rootAgentId: graph.defaultAgentId,
+      rootAgentName: primaryContext?.name,
+      activeAgentId: graph.defaultAgentId,
+      activeAgentName: primaryContext?.name,
     });
     const traceName = config.runName ?? getLangfuseTraceName(traceMetadata);
     const streamLangfuseConfig = this.getStreamLangfuseConfig(graph);

package/src/tools/BashProgrammaticToolCalling.ts

@@ -14,11 +14,7 @@ import {
   selectRuntimeSessionHint,
 } from './CodeExecutor';
 import {
-  makeRequest,
-  executeTools,
-  formatCompletedResponse,
-} from './ProgrammaticToolCalling';
-import {
+  assertUnambiguousIdentifiers,
   projectProgrammaticToolMap,
   resolveProgrammaticToolDefinitions,
   selectProgrammaticTools,
@@ -29,6 +25,12 @@ import {
   createCodeApiRunTimeoutSchema,
   resolveCodeApiRunTimeoutMs,
 } from './ptcTimeout';
+import {
+  makeRequest,
+  executeTools,
+  runPlainExecution,
+  formatCompletedResponse,
+} from './ProgrammaticToolCalling';
 import { INTENT_PROPERTY } from '@/tools/intentArg';
 import { Constants } from '@/common';
 
@@ -117,7 +119,7 @@ ${CORE_RULES}`;
 
 const TOOL_MANIFEST_DESCRIPTION =
   'Exact registered tool names used by the code. Required when direct-only tools are configured; ' +
-  'validated before execution starts.';
+  'validated before execution starts. Pass [] when the code calls no tools at all.';
 
 // ============================================================================
 // Schema
@@ -361,22 +363,41 @@ export function createBashProgrammaticToolCallingTool(
         programmaticToolName,
       });
 
-      if (toolMap == null || toolMap.size === 0) {
-        throw new Error(
-          'No toolMap provided. ' +
-            'ToolNode should inject this from AgentContext when invoked through the graph.'
-        );
-      }
+      /* These guard the replay path only. A call that selected no tools never
+       * replays, and event-driven ToolNode configurations legitimately inject
+       * an empty toolMap/toolDefs. Injected context is still required to
+       * conclude that — with nothing injected at all, an empty selection means
+       * the host wired the tool up wrong. */
+      const needsNoTools =
+        effectiveTools.length === 0 &&
+        (params.tool_manifest?.length === 0 ||
+          toolDefs != null ||
+          disallowedToolDefs != null);
+
+      if (!needsNoTools) {
+        if (toolMap == null || toolMap.size === 0) {
+          throw new Error(
+            'No toolMap provided. ' +
+              'ToolNode should inject this from AgentContext when invoked through the graph.'
+          );
+        }
 
-      if (toolDefs == null || toolDefs.length === 0) {
-        throw new Error(
-          'No tool definitions provided. ' +
-            'Either pass tools in the input or ensure ToolNode injects toolDefs.'
-        );
+        if (toolDefs == null || toolDefs.length === 0) {
+          throw new Error(
+            'No tool definitions provided. ' +
+              'Either pass tools in the input or ensure ToolNode injects toolDefs.'
+          );
+        }
       }
 
+      assertUnambiguousIdentifiers(
+        effectiveTools,
+        normalizeToBashIdentifier,
+        programmaticToolName
+      );
+
       const effectiveToolMap = projectProgrammaticToolMap(
-        toolMap,
+        toolMap ?? new Map(),
         effectiveTools
       );
 
@@ -391,7 +412,7 @@ export function createBashProgrammaticToolCallingTool(
           // eslint-disable-next-line no-console
           console.log(
             `[BashPTC Debug] Sending ${effectiveTools.length} tools to API ` +
-              `(selected from ${toolDefs.length})`
+              `(selected from ${toolDefs?.length ?? 0})`
           );
         }
 
@@ -423,6 +444,23 @@ export function createBashProgrammaticToolCallingTool(
             ? selectedRuntimeSessionHint
             : undefined;
 
+        /* Raw `code`, not `preparedCode`: the `$!` guard exists for the
+         * programmatic replay wrapper, which plain `/exec` never applies. */
+        if (needsNoTools) {
+          return await runPlainExecution({
+            baseUrl,
+            lang: 'bash',
+            code,
+            timeout,
+            sessionId: session_id,
+            files,
+            runtimeSessionHint,
+            proxy,
+            authHeaders: initParams.authHeaders,
+            executionProfile: initParams.executionProfile,
+          });
+        }
+
         let response = await makeRequest(
           EXEC_ENDPOINT,
           {

package/src/tools/ProgrammaticCallerPolicy.ts

@@ -43,6 +43,37 @@ export function assertDisallowedToolUsage(
   );
 }
 
+/**
+ * Rejects a stub set holding two tools that collapse to one runtime identifier.
+ *
+ * Stub generation binds by identifier, so such tools are indistinguishable once
+ * emitted — the generated program defines both and the later one wins. Failing
+ * beats dispatching by declaration order.
+ *
+ * Called on the set each backend actually emits, not on the selection: a
+ * definition dropped before codegen never binds an identifier, so a collision
+ * among such definitions is not a conflict.
+ */
+export function assertUnambiguousIdentifiers(
+  selectedToolDefs: readonly t.LCTool[],
+  normalizeIdentifier: (name: string) => string,
+  programmaticToolName: string
+): void {
+  const seen = new Map<string, string>();
+  for (const toolDef of selectedToolDefs) {
+    const identifier = normalizeIdentifier(toolDef.name);
+    const prior = seen.get(identifier);
+    if (prior != null && prior !== toolDef.name) {
+      throw new Error(
+        `Tools "${prior}" and "${toolDef.name}" both become "${identifier}" in ` +
+          `the sandbox, so "${programmaticToolName}" cannot tell which one the ` +
+          'code means. Call them directly, or rename one.'
+      );
+    }
+    seen.set(identifier, toolDef.name);
+  }
+}
+
 export function selectProgrammaticTools(args: {
   requestedToolNames?: string[];
   allowedToolDefs?: t.LCTool[];

package/src/tools/ProgrammaticToolCalling.ts

@@ -22,16 +22,17 @@ import {
   selectRuntimeSessionHint,
 } from './CodeExecutor';
 import {
-  clampCodeApiRunTimeoutMs,
-  createCodeApiRunTimeoutSchema,
-  resolveCodeApiRunTimeoutMs,
-} from './ptcTimeout';
-import {
+  assertUnambiguousIdentifiers,
   projectProgrammaticToolMap,
   resolveProgrammaticToolDefinitions,
   selectProgrammaticTools,
   type ProgrammaticInvocationParams,
 } from './ProgrammaticCallerPolicy';
+import {
+  clampCodeApiRunTimeoutMs,
+  createCodeApiRunTimeoutSchema,
+  resolveCodeApiRunTimeoutMs,
+} from './ptcTimeout';
 import { resolveFetchProxyAgent } from '@/utils/proxy';
 import { INTENT_PROPERTY } from '@/tools/intentArg';
 import { Constants } from '@/common';
@@ -95,7 +96,7 @@ ${CORE_RULES}`;
 
 const TOOL_MANIFEST_DESCRIPTION =
   'Exact registered tool names used by the code. Required when direct-only tools are configured; ' +
-  'validated before execution starts.';
+  'validated before execution starts. Pass [] when the code calls no tools at all.';
 
 export function createProgrammaticToolCallingSchema(
   maxRunTimeoutMs = DEFAULT_RUN_TIMEOUT_MS
@@ -874,6 +875,84 @@ export function formatCompletedResponse(
   ];
 }
 
+/**
+ * Mirrors the Code API's programmatic Python wrapper (`wrapUserCodeInAsync`).
+ *
+ * The programmatic contract promises top-level `await` works; plain `/exec`
+ * applies no wrapper, so forwarding source unchanged would turn valid
+ * programmatic input into a SyntaxError. The wrapper is self-contained, so a
+ * later divergence in the Code API's own copy cannot break this path.
+ */
+export function wrapPythonForPlainExecution(userCode: string): string {
+  const indented = userCode
+    .split('\n')
+    .map((line) => (line.trim() === '' ? '' : `    ${line}`))
+    .join('\n');
+
+  return (
+    'async def __user_main__():\n' +
+    '    """Auto-generated wrapper for user code to support top-level await"""\n' +
+    `${indented}\n` +
+    '\n' +
+    'if __name__ == "__main__":\n' +
+    '    import asyncio\n' +
+    '    asyncio.run(__user_main__())\n'
+  );
+}
+
+/**
+ * Runs code that selected no tools through plain `/exec`.
+ *
+ * `/exec/programmatic` rejects an empty tool manifest outright, and the sandbox
+ * has nothing to inject for such a call anyway — no stubs, no replay round
+ * trips. Routing it here makes a tool-free programmatic call behave exactly like
+ * the equivalent `execute_code`, against every deployed Code API, instead of
+ * failing with a rejection the model cannot act on.
+ */
+export async function runPlainExecution(args: {
+  baseUrl: string;
+  lang: 'bash' | 'py';
+  code: string;
+  /**
+   * Forwarded so the model-supplied cap applies as soon as the Code API honors
+   * it on `/exec`, which does not read `timeout` today. Session affinity and
+   * input files are honored there, so those ride the same body.
+   */
+  timeout?: number;
+  sessionId?: string;
+  files?: t.CodeEnvFile[];
+  runtimeSessionHint?: string;
+  proxy?: string;
+  authHeaders?: t.CodeApiAuthHeaders;
+  executionProfile?: t.CodeApiExecutionProfile;
+}): Promise<[string, t.ProgrammaticExecutionArtifact]> {
+  const response = await makeRequest(
+    buildCodeApiEndpoint(args.baseUrl, 'exec'),
+    {
+      lang: args.lang,
+      code:
+        args.lang === 'py'
+          ? wrapPythonForPlainExecution(args.code)
+          : args.code,
+      ...(args.timeout != null ? { timeout: args.timeout } : {}),
+      ...(args.sessionId != null && args.sessionId !== ''
+        ? { session_id: args.sessionId }
+        : {}),
+      ...(args.files != null && args.files.length > 0
+        ? { files: args.files }
+        : {}),
+      ...(args.runtimeSessionHint != null
+        ? { runtime_session_hint: args.runtimeSessionHint }
+        : {}),
+    },
+    args.proxy,
+    args.authHeaders,
+    args.executionProfile
+  );
+
+  return formatCompletedResponse(response, args.code);
+}
+
 // ============================================================================
 // Tool Factory
 // ============================================================================
@@ -943,22 +1022,41 @@ export function createProgrammaticToolCallingTool(
         programmaticToolName,
       });
 
-      if (toolMap == null || toolMap.size === 0) {
-        throw new Error(
-          'No toolMap provided. ' +
-            'ToolNode should inject this from AgentContext when invoked through the graph.'
-        );
-      }
+      /* These guard the replay path only. A call that selected no tools never
+       * replays, and event-driven ToolNode configurations legitimately inject
+       * an empty toolMap/toolDefs. Injected context is still required to
+       * conclude that — with nothing injected at all, an empty selection means
+       * the host wired the tool up wrong. */
+      const needsNoTools =
+        effectiveTools.length === 0 &&
+        (params.tool_manifest?.length === 0 ||
+          toolDefs != null ||
+          disallowedToolDefs != null);
+
+      if (!needsNoTools) {
+        if (toolMap == null || toolMap.size === 0) {
+          throw new Error(
+            'No toolMap provided. ' +
+              'ToolNode should inject this from AgentContext when invoked through the graph.'
+          );
+        }
 
-      if (toolDefs == null || toolDefs.length === 0) {
-        throw new Error(
-          'No tool definitions provided. ' +
-            'Either pass tools in the input or ensure ToolNode injects toolDefs.'
-        );
+        if (toolDefs == null || toolDefs.length === 0) {
+          throw new Error(
+            'No tool definitions provided. ' +
+              'Either pass tools in the input or ensure ToolNode injects toolDefs.'
+          );
+        }
       }
 
+      assertUnambiguousIdentifiers(
+        effectiveTools,
+        normalizeToPythonIdentifier,
+        programmaticToolName
+      );
+
       const effectiveToolMap = projectProgrammaticToolMap(
-        toolMap,
+        toolMap ?? new Map(),
         effectiveTools
       );
 
@@ -973,7 +1071,7 @@ export function createProgrammaticToolCallingTool(
           // eslint-disable-next-line no-console
           console.log(
             `[PTC Debug] Sending ${effectiveTools.length} tools to API ` +
-              `(selected from ${toolDefs.length})`
+              `(selected from ${toolDefs?.length ?? 0})`
           );
         }
 
@@ -1008,6 +1106,21 @@ export function createProgrammaticToolCallingTool(
             ? selectedRuntimeSessionHint
             : undefined;
 
+        if (needsNoTools) {
+          return await runPlainExecution({
+            baseUrl,
+            lang: 'py',
+            code,
+            timeout,
+            sessionId: session_id,
+            files,
+            runtimeSessionHint,
+            proxy,
+            authHeaders: initParams.authHeaders,
+            executionProfile: initParams.executionProfile,
+          });
+        }
+
         let response = await makeRequest(
           EXEC_ENDPOINT,
           {