@librechat/agents 3.1.66-dev.0 → 3.1.67

package/src/agents/AgentContext.ts

@@ -664,6 +664,17 @@ export class AgentContext {
     this.indexTokenCountMap = { ...baseTokenMap };
   }
 
+  /** Active tool definitions for token accounting (excludes deferred-and-undiscovered entries). */
+  private getActiveToolDefinitions(): t.LCTool[] {
+    if (!this.toolDefinitions) {
+      return [];
+    }
+    return this.toolDefinitions.filter(
+      (def) =>
+        def.defer_loading !== true || this.discoveredToolNames.has(def.name)
+    );
+  }
+
   /**
    * Calculate tool tokens and add to instruction tokens
    * Note: System message tokens are calculated during systemRunnable creation
@@ -697,21 +708,19 @@ export class AgentContext {
       }
     }
 
-    if (this.toolDefinitions && this.toolDefinitions.length > 0) {
-      for (const def of this.toolDefinitions) {
-        if (countedToolNames.has(def.name)) {
-          continue;
-        }
-        const schema = {
-          type: 'function',
-          function: {
-            name: def.name,
-            description: def.description ?? '',
-            parameters: def.parameters ?? {},
-          },
-        };
-        toolTokens += tokenCounter(new SystemMessage(JSON.stringify(schema)));
+    for (const def of this.getActiveToolDefinitions()) {
+      if (countedToolNames.has(def.name)) {
+        continue;
       }
+      const schema = {
+        type: 'function',
+        function: {
+          name: def.name,
+          description: def.description ?? '',
+          parameters: def.parameters ?? {},
+        },
+      };
+      toolTokens += tokenCounter(new SystemMessage(JSON.stringify(schema)));
     }
 
     const isAnthropic =
@@ -860,11 +869,15 @@ export class AgentContext {
   /**
    * Returns a structured breakdown of how the context token budget is consumed.
    * Useful for diagnostics when context overflow or pruning issues occur.
+   *
+   * Note: `toolCount` reflects discoveries immediately, but `toolSchemaTokens`
+   * is a snapshot taken during `calculateInstructionTokens` and is not
+   * recomputed when `markToolsAsDiscovered` is called mid-run.
    */
   getTokenBudgetBreakdown(messages?: BaseMessage[]): t.TokenBudgetBreakdown {
     const maxContextTokens = this.maxContextTokens ?? 0;
     const toolCount =
-      (this.tools?.length ?? 0) + (this.toolDefinitions?.length ?? 0);
+      (this.tools?.length ?? 0) + this.getActiveToolDefinitions().length;
     const messageCount = messages?.length ?? 0;
 
     let messageTokens = 0;

package/src/agents/__tests__/AgentContext.test.ts

@@ -375,6 +375,116 @@ describe('AgentContext', () => {
 
       expect(ctx.instructionTokens).toBeGreaterThan(initialTokens);
     });
+
+    it('excludes deferred-undiscovered toolDefinitions from toolSchemaTokens', async () => {
+      const activeDef: t.LCTool = {
+        name: 'active_tool',
+        description: 'Always loaded',
+        parameters: { type: 'object', properties: {} },
+      };
+      const deferredDef: t.LCTool = {
+        name: 'deferred_tool',
+        description: 'Loaded via tool search',
+        parameters: { type: 'object', properties: {} },
+        defer_loading: true,
+      };
+
+      const ctxBase = createBasicContext({
+        agentConfig: { toolDefinitions: [activeDef] },
+        tokenCounter: mockTokenCounter,
+      });
+      const ctxWithDeferred = createBasicContext({
+        agentConfig: { toolDefinitions: [activeDef, deferredDef] },
+        tokenCounter: mockTokenCounter,
+      });
+
+      await ctxBase.tokenCalculationPromise;
+      await ctxWithDeferred.tokenCalculationPromise;
+
+      expect(ctxWithDeferred.toolSchemaTokens).toBe(ctxBase.toolSchemaTokens);
+    });
+
+    it('includes deferred toolDefinitions once discovered via discoveredTools input', async () => {
+      const toolDefinitions: t.LCTool[] = [
+        {
+          name: 'deferred_tool',
+          description: 'Loaded via tool search',
+          parameters: { type: 'object', properties: {} },
+          defer_loading: true,
+        },
+      ];
+
+      const ctxUndiscovered = createBasicContext({
+        agentConfig: { toolDefinitions },
+        tokenCounter: mockTokenCounter,
+      });
+      const ctxDiscovered = createBasicContext({
+        agentConfig: { toolDefinitions, discoveredTools: ['deferred_tool'] },
+        tokenCounter: mockTokenCounter,
+      });
+
+      await ctxUndiscovered.tokenCalculationPromise;
+      await ctxDiscovered.tokenCalculationPromise;
+
+      expect(ctxUndiscovered.toolSchemaTokens).toBe(0);
+      expect(ctxDiscovered.toolSchemaTokens).toBeGreaterThan(0);
+    });
+
+    it('getTokenBudgetBreakdown toolCount excludes deferred-undiscovered toolDefinitions', () => {
+      const toolDefinitions: t.LCTool[] = [
+        {
+          name: 'active',
+          parameters: { type: 'object', properties: {} },
+        },
+        {
+          name: 'deferred',
+          defer_loading: true,
+          parameters: { type: 'object', properties: {} },
+        },
+      ];
+
+      const ctx = createBasicContext({ agentConfig: { toolDefinitions } });
+
+      expect(ctx.getTokenBudgetBreakdown().toolCount).toBe(1);
+    });
+
+    it('getTokenBudgetBreakdown toolCount reflects newly discovered deferred tools', () => {
+      const toolDefinitions: t.LCTool[] = [
+        {
+          name: 'deferred',
+          defer_loading: true,
+          parameters: { type: 'object', properties: {} },
+        },
+      ];
+
+      const ctx = createBasicContext({ agentConfig: { toolDefinitions } });
+
+      expect(ctx.getTokenBudgetBreakdown().toolCount).toBe(0);
+      ctx.markToolsAsDiscovered(['deferred']);
+      expect(ctx.getTokenBudgetBreakdown().toolCount).toBe(1);
+    });
+
+    it('toolSchemaTokens snapshot does not auto-update after markToolsAsDiscovered', async () => {
+      const toolDefinitions: t.LCTool[] = [
+        {
+          name: 'deferred',
+          description: 'Loaded via tool search',
+          parameters: { type: 'object', properties: {} },
+          defer_loading: true,
+        },
+      ];
+
+      const ctx = createBasicContext({
+        agentConfig: { toolDefinitions },
+        tokenCounter: mockTokenCounter,
+      });
+
+      await ctx.tokenCalculationPromise;
+      expect(ctx.toolSchemaTokens).toBe(0);
+
+      ctx.markToolsAsDiscovered(['deferred']);
+      expect(ctx.toolSchemaTokens).toBe(0);
+    });
   });
 
   describe('reset()', () => {

package/src/common/enum.ts

@@ -182,20 +182,8 @@ export enum Constants {
   MCP_DELIMITER = '_mcp_',
   /** Anthropic server tool ID prefix (web_search, code_execution, etc.) */
   ANTHROPIC_SERVER_TOOL_PREFIX = 'srvtoolu_',
-  SKILL_TOOL = 'skill',
-  READ_FILE = 'read_file',
-  BASH_TOOL = 'bash_tool',
-  BASH_PROGRAMMATIC_TOOL_CALLING = 'run_tools_with_bash',
 }
 
-/** Tool names that use the code execution environment (shared session, file tracking). */
-export const CODE_EXECUTION_TOOLS: ReadonlySet<string> = new Set([
-  Constants.EXECUTE_CODE,
-  Constants.BASH_TOOL,
-  Constants.PROGRAMMATIC_TOOL_CALLING,
-  Constants.BASH_PROGRAMMATIC_TOOL_CALLING,
-]);
-
 export enum TitleMethod {
   STRUCTURED = 'structured',
   FUNCTIONS = 'functions',

package/src/graphs/Graph.ts

@@ -53,7 +53,6 @@ import { isThinkingEnabled } from '@/llm/request';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
 import { ChatOpenAI } from '@/llm/openai';
-import type { HookRegistry } from '@/hooks';
 
 const { AGENT, TOOLS, SUMMARIZE } = GraphNodeKeys;
 
@@ -124,7 +123,6 @@ export abstract class Graph<
   /** Set of invoked tool call IDs from non-message run steps completed mid-run, if any */
   invokedToolIds?: Set<string>;
   handlerRegistry: HandlerRegistry | undefined;
-  hookRegistry: HookRegistry | undefined;
   /**
    * Tool session contexts for automatic state persistence across tool invocations.
    * Keyed by tool name (e.g., Constants.EXECUTE_CODE).
@@ -149,7 +147,6 @@ export abstract class Graph<
     this.prelimMessageIdsByStepKey = new Map();
     this.invokedToolIds = undefined;
     this.handlerRegistry = undefined;
-    this.hookRegistry = undefined;
     this.sessions.clear();
   }
 }
@@ -509,7 +506,6 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         agentId: agentContext?.agentId,
         toolCallStepIds: this.toolCallStepIds,
         toolRegistry: agentContext?.toolRegistry,
-        hookRegistry: this.hookRegistry,
         directToolNames: directToolNames.size > 0 ? directToolNames : undefined,
         maxContextTokens: agentContext?.maxContextTokens,
         maxToolResultChars: agentContext?.maxToolResultChars,

package/src/index.ts

@@ -14,12 +14,7 @@ export * from './summarization';
 /* Tools */
 export * from './tools/Calculator';
 export * from './tools/CodeExecutor';
-export * from './tools/BashExecutor';
 export * from './tools/ProgrammaticToolCalling';
-export * from './tools/BashProgrammaticToolCalling';
-export * from './tools/SkillTool';
-export * from './tools/ReadFile';
-export * from './tools/skillCatalog';
 export * from './tools/ToolSearch';
 export * from './tools/ToolNode';
 export * from './tools/schema';
@@ -30,9 +25,6 @@ export * from './tools/search';
 export * from './common';
 export * from './utils';
 
-/* Hooks */
-export * from './hooks';
-
 /* Types */
 export type * from './types';
 

package/src/messages/format.ts

@@ -797,39 +797,18 @@ function contentPartCharLength(part: MessageContentComplex): number {
   return len;
 }
 
-/** Extracts the skillName from a skill tool_call's args (string or object). */
-function extractSkillName(args: unknown): string | undefined {
-  let parsed: Record<string, unknown> | undefined;
-  if (typeof args === 'string') {
-    try {
-      parsed = JSON.parse(args) as Record<string, unknown>;
-    } catch {
-      /* malformed args — skip */
-    }
-  } else {
-    parsed = args as Record<string, unknown> | undefined;
-  }
-  const name = parsed?.skillName;
-  return typeof name === 'string' && name !== '' ? name : undefined;
-}
-
 /**
  * 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 skills - Optional map of skill name to body for reconstructing skill HumanMessages.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export const formatAgentMessages = (
   payload: TPayload,
   indexTokenCountMap?: Record<number, number | undefined>,
-  tools?: Set<string>,
-  /** Pre-resolved skill bodies keyed by skill name. When present, HumanMessages
-   *  are reconstructed after skill ToolMessages to restore skill instructions
-   *  that were only in LangGraph state during the original run. */
-  skills?: Map<string, string>
+  tools?: Set<string>
 ): {
   messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
   indexTokenCountMap?: Record<number, number>;
@@ -923,7 +902,6 @@ export const formatAgentMessages = (
      * - Dynamically expand the set when tool_search results are encountered
      */
     let processedMessage = message;
-    let pendingSkillNames: Set<string> | undefined;
     if (discoveredTools) {
       const content = message.content;
       if (content != null && Array.isArray(content)) {
@@ -972,17 +950,8 @@ export const formatAgentMessages = (
           }
 
           if (discoveredTools.has(toolName)) {
+            /** Valid tool - keep it */
             filteredContent.push(part);
-            if (
-              toolName === Constants.SKILL_TOOL &&
-              skills?.size != null &&
-              skills.size > 0
-            ) {
-              const skillName = extractSkillName(part.tool_call.args) ?? '';
-              if (skillName) {
-                (pendingSkillNames ??= new Set()).add(skillName);
-              }
-            }
           } else {
             /** Invalid tool - convert to string for context preservation */
             if (
@@ -1058,25 +1027,6 @@ export const formatAgentMessages = (
       }
     }
 
-    /** When tools filtering is off, still detect skill tool_calls for body reconstruction */
-    if (!discoveredTools && skills?.size != null && skills.size > 0) {
-      const content = processedMessage.content;
-      if (Array.isArray(content)) {
-        for (const part of content) {
-          if (
-            part.type !== ContentTypes.TOOL_CALL ||
-            part.tool_call?.name !== Constants.SKILL_TOOL
-          ) {
-            continue;
-          }
-          const skillName = extractSkillName(part.tool_call.args) ?? '';
-          if (skillName) {
-            (pendingSkillNames ??= new Set()).add(skillName);
-          }
-        }
-      }
-    }
-
     const formattedMessages = formatAssistantMessage(processedMessage);
     if (sourceMessageId != null && sourceMessageId !== '') {
       for (const formattedMessage of formattedMessages) {
@@ -1085,29 +1035,9 @@ export const formatAgentMessages = (
     }
     messages.push(...formattedMessages);
 
-    // Capture index range BEFORE skill body injection so injected
-    // HumanMessages are excluded from the assistant's token distribution.
+    // Update the index mapping for this assistant message
+    // Store all indices that were created from this original message
     const endMessageIndex = messages.length;
-
-    if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
-      for (const skillName of pendingSkillNames) {
-        const body = skills?.get(skillName) ?? '';
-        if (body) {
-          messages.push(
-            new HumanMessage({
-              content: body,
-              additional_kwargs: {
-                role: 'user',
-                isMeta: true,
-                source: 'skill',
-                skillName,
-              },
-            })
-          );
-        }
-      }
-    }
-
     const resultIndices = [];
     for (let j = startMessageIndex; j < endMessageIndex; j++) {
       resultIndices.push(j);

package/src/run.ts

@@ -22,10 +22,8 @@ import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import { StandardGraph } from '@/graphs/Graph';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
-import { executeHooks } from '@/hooks';
 import { isOpenAILike } from '@/utils/llm';
 import { isPresent } from '@/utils/misc';
-import type { HookRegistry } from '@/hooks';
 
 export const defaultOmitOptions = new Set([
   'stream',
@@ -44,7 +42,6 @@ export class Run<_T extends t.BaseGraphState> {
   id: string;
   private tokenCounter?: t.TokenCounter;
   private handlerRegistry?: HandlerRegistry;
-  private hookRegistry?: HookRegistry;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
   graphRunnable?: t.CompiledStateWorkflow;
@@ -77,7 +74,6 @@ export class Run<_T extends t.BaseGraphState> {
     }
 
     this.handlerRegistry = handlerRegistry;
-    this.hookRegistry = config.hooks;
 
     if (!config.graphConfig) {
       throw new Error('Graph config not provided');
@@ -99,12 +95,6 @@ export class Run<_T extends t.BaseGraphState> {
       }
     }
 
-    if (config.initialSessions && this.Graph) {
-      for (const [key, value] of config.initialSessions) {
-        this.Graph.sessions.set(key, value);
-      }
-    }
-
     this.returnContent = config.returnContent ?? false;
     this.skipCleanup = config.skipCleanup ?? false;
   }
@@ -153,7 +143,6 @@ export class Run<_T extends t.BaseGraphState> {
     });
     /** Propagate compile options from graph config */
     standardGraph.compileOptions = config.compileOptions;
-    standardGraph.hookRegistry = this.hookRegistry;
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();
   }
@@ -176,7 +165,6 @@ export class Run<_T extends t.BaseGraphState> {
       multiAgentGraph.compileOptions = compileOptions;
     }
 
-    multiAgentGraph.hookRegistry = this.hookRegistry;
     this.Graph = multiAgentGraph;
     return multiAgentGraph.createWorkflow();
   }
@@ -344,47 +332,6 @@ export class Run<_T extends t.BaseGraphState> {
       run_id: this.id,
     });
 
-    const threadId = config.configurable.thread_id as string | undefined;
-
-    if (this.hookRegistry != null) {
-      await executeHooks({
-        registry: this.hookRegistry,
-        input: {
-          hook_event_name: 'RunStart',
-          runId: this.id,
-          threadId,
-          agentId: this.Graph.defaultAgentId,
-          messages: inputs.messages,
-        },
-        sessionId: this.id,
-      });
-
-      const lastHuman = findLastMessageOfType(inputs.messages, 'human');
-      if (lastHuman != null) {
-        const promptResult = await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'UserPromptSubmit',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            prompt: extractPromptText(lastHuman),
-            // attachments: not yet wired — Phase 2 will extract
-            // non-text content blocks (images, files) from messages
-          },
-          sessionId: this.id,
-        });
-        if (
-          promptResult.decision === 'deny' ||
-          promptResult.decision === 'ask'
-        ) {
-          this.hookRegistry.clearSession(this.id);
-          config.callbacks = undefined;
-          return undefined;
-        }
-      }
-    }
-
     const stream = this.graphRunnable.streamEvents(inputs, config, {
       raiseError: true,
       /**
@@ -414,45 +361,7 @@ export class Run<_T extends t.BaseGraphState> {
           await handler.handle(eventName, data, metadata, this.Graph);
         }
       }
-
-      if (this.hookRegistry?.hasHookFor('Stop', this.id) === true) {
-        await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'Stop',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            messages: this.Graph.getRunMessages() ?? inputs.messages,
-            stopHookActive: false, // will be true when stop is triggered by a hook (Phase 2)
-          },
-          sessionId: this.id,
-        }).catch(() => {
-          /* Stop hook errors must not masquerade as stream failures */
-        });
-      }
-    } catch (err) {
-      if (this.hookRegistry?.hasHookFor('StopFailure', this.id) === true) {
-        const runMessages = this.Graph.getRunMessages() ?? [];
-        await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'StopFailure',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            error: err instanceof Error ? err.message : String(err),
-            lastAssistantMessage: findLastMessageOfType(runMessages, 'ai'),
-          },
-          sessionId: this.id,
-        }).catch(() => {
-          /* swallow hook errors — the original error must propagate */
-        });
-      }
-      throw err;
     } finally {
-      this.hookRegistry?.clearSession(this.id);
-
       /**
        * Break the reference chain that keeps heavy data alive via
        * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
@@ -648,38 +557,3 @@ export class Run<_T extends t.BaseGraphState> {
     }
   }
 }
-
-function findLastMessageOfType(
-  messages: BaseMessage[],
-  type: string
-): BaseMessage | undefined {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].getType() === type) {
-      return messages[i];
-    }
-  }
-  return undefined;
-}
-
-function extractPromptText(message: BaseMessage): string {
-  const content = message.content;
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return String(content);
-  }
-  const parts: string[] = [];
-  for (const block of content) {
-    if (
-      typeof block === 'object' &&
-      'type' in block &&
-      block.type === 'text' &&
-      'text' in block &&
-      typeof block.text === 'string'
-    ) {
-      parts.push(block.text);
-    }
-  }
-  return parts.join('\n');
-}