@librechat/agents 3.1.67 → 3.1.68-dev.0

package/dist/cjs/main.cjs

@@ -19,7 +19,14 @@ var MultiAgentGraph = require('./graphs/MultiAgentGraph.cjs');
 var index$2 = require('./summarization/index.cjs');
 var Calculator = require('./tools/Calculator.cjs');
 var CodeExecutor = require('./tools/CodeExecutor.cjs');
+var BashExecutor = require('./tools/BashExecutor.cjs');
 var ProgrammaticToolCalling = require('./tools/ProgrammaticToolCalling.cjs');
+var BashProgrammaticToolCalling = require('./tools/BashProgrammaticToolCalling.cjs');
+var SkillTool = require('./tools/SkillTool.cjs');
+var SubagentTool = require('./tools/SubagentTool.cjs');
+var SubagentExecutor = require('./tools/subagent/SubagentExecutor.cjs');
+var ReadFile = require('./tools/ReadFile.cjs');
+var skillCatalog = require('./tools/skillCatalog.cjs');
 var ToolSearch = require('./tools/ToolSearch.cjs');
 var ToolNode = require('./tools/ToolNode.cjs');
 var schema$1 = require('./tools/schema.cjs');
@@ -37,6 +44,10 @@ var tokens = require('./utils/tokens.cjs');
 var schema$2 = require('./utils/schema.cjs');
 var truncation = require('./utils/truncation.cjs');
 var errors = require('./utils/errors.cjs');
+var HookRegistry = require('./hooks/HookRegistry.cjs');
+var executeHooks = require('./hooks/executeHooks.cjs');
+var matchers = require('./hooks/matchers.cjs');
+var types = require('./hooks/types.cjs');
 var index$1 = require('./llm/openai/index.cjs');
 var index = require('./llm/openrouter/index.cjs');
 var providers = require('./llm/providers.cjs');
@@ -102,6 +113,7 @@ exports.messagesStateReducer = reducer.messagesStateReducer;
 exports.Graph = Graph.Graph;
 exports.StandardGraph = Graph.StandardGraph;
 exports.MultiAgentGraph = MultiAgentGraph.MultiAgentGraph;
+exports._resetUnrecognizedTriggerWarnings = index$2._resetUnrecognizedTriggerWarnings;
 exports.shouldTriggerSummarization = index$2.shouldTriggerSummarization;
 exports.Calculator = Calculator.Calculator;
 exports.CalculatorSchema = Calculator.CalculatorSchema;
@@ -115,6 +127,11 @@ exports.CodeExecutionToolSchema = CodeExecutor.CodeExecutionToolSchema;
 exports.createCodeExecutionTool = CodeExecutor.createCodeExecutionTool;
 exports.getCodeBaseURL = CodeExecutor.getCodeBaseURL;
 exports.imageExtRegex = CodeExecutor.imageExtRegex;
+exports.BashExecutionToolDefinition = BashExecutor.BashExecutionToolDefinition;
+exports.BashExecutionToolDescription = BashExecutor.BashExecutionToolDescription;
+exports.BashExecutionToolName = BashExecutor.BashExecutionToolName;
+exports.BashExecutionToolSchema = BashExecutor.BashExecutionToolSchema;
+exports.createBashExecutionTool = BashExecutor.createBashExecutionTool;
 exports.ProgrammaticToolCallingDefinition = ProgrammaticToolCalling.ProgrammaticToolCallingDefinition;
 exports.ProgrammaticToolCallingDescription = ProgrammaticToolCalling.ProgrammaticToolCallingDescription;
 exports.ProgrammaticToolCallingName = ProgrammaticToolCalling.ProgrammaticToolCallingName;
@@ -128,6 +145,34 @@ exports.formatCompletedResponse = ProgrammaticToolCalling.formatCompletedRespons
 exports.makeRequest = ProgrammaticToolCalling.makeRequest;
 exports.normalizeToPythonIdentifier = ProgrammaticToolCalling.normalizeToPythonIdentifier;
 exports.unwrapToolResponse = ProgrammaticToolCalling.unwrapToolResponse;
+exports.BashProgrammaticToolCallingDefinition = BashProgrammaticToolCalling.BashProgrammaticToolCallingDefinition;
+exports.BashProgrammaticToolCallingDescription = BashProgrammaticToolCalling.BashProgrammaticToolCallingDescription;
+exports.BashProgrammaticToolCallingName = BashProgrammaticToolCalling.BashProgrammaticToolCallingName;
+exports.BashProgrammaticToolCallingSchema = BashProgrammaticToolCalling.BashProgrammaticToolCallingSchema;
+exports.createBashProgrammaticToolCallingTool = BashProgrammaticToolCalling.createBashProgrammaticToolCallingTool;
+exports.extractUsedBashToolNames = BashProgrammaticToolCalling.extractUsedBashToolNames;
+exports.filterBashToolsByUsage = BashProgrammaticToolCalling.filterBashToolsByUsage;
+exports.normalizeToBashIdentifier = BashProgrammaticToolCalling.normalizeToBashIdentifier;
+exports.SkillToolDefinition = SkillTool.SkillToolDefinition;
+exports.SkillToolDescription = SkillTool.SkillToolDescription;
+exports.SkillToolName = SkillTool.SkillToolName;
+exports.SkillToolSchema = SkillTool.SkillToolSchema;
+exports.SubagentToolDefinition = SubagentTool.SubagentToolDefinition;
+exports.SubagentToolDescription = SubagentTool.SubagentToolDescription;
+exports.SubagentToolName = SubagentTool.SubagentToolName;
+exports.SubagentToolSchema = SubagentTool.SubagentToolSchema;
+exports.buildSubagentToolParams = SubagentTool.buildSubagentToolParams;
+exports.createSubagentToolDefinition = SubagentTool.createSubagentToolDefinition;
+exports.SubagentExecutor = SubagentExecutor.SubagentExecutor;
+exports.buildChildInputs = SubagentExecutor.buildChildInputs;
+exports.filterSubagentResult = SubagentExecutor.filterSubagentResult;
+exports.resolveSubagentConfigs = SubagentExecutor.resolveSubagentConfigs;
+exports.summarizeEvent = SubagentExecutor.summarizeEvent;
+exports.ReadFileToolDefinition = ReadFile.ReadFileToolDefinition;
+exports.ReadFileToolDescription = ReadFile.ReadFileToolDescription;
+exports.ReadFileToolName = ReadFile.ReadFileToolName;
+exports.ReadFileToolSchema = ReadFile.ReadFileToolSchema;
+exports.formatSkillCatalog = skillCatalog.formatSkillCatalog;
 exports.ToolSearchToolDefinition = ToolSearch.ToolSearchToolDefinition;
 exports.ToolSearchToolDescription = ToolSearch.ToolSearchToolDescription;
 exports.ToolSearchToolName = ToolSearch.ToolSearchToolName;
@@ -174,6 +219,7 @@ exports.querySchema = schema.querySchema;
 exports.videosSchema = schema.videosSchema;
 exports.ANTHROPIC_TOOL_TOKEN_MULTIPLIER = constants.ANTHROPIC_TOOL_TOKEN_MULTIPLIER;
 exports.DEFAULT_TOOL_TOKEN_MULTIPLIER = constants.DEFAULT_TOOL_TOKEN_MULTIPLIER;
+exports.CODE_EXECUTION_TOOLS = _enum.CODE_EXECUTION_TOOLS;
 Object.defineProperty(exports, "Callback", {
 	enumerable: true,
 	get: function () { return _enum.Callback; }
@@ -248,6 +294,14 @@ exports.truncateToolResultContent = truncation.truncateToolResultContent;
 exports.extractErrorMessage = errors.extractErrorMessage;
 exports.isContextOverflowError = errors.isContextOverflowError;
 exports.isLikelyContextOverflowError = errors.isLikelyContextOverflowError;
+exports.HookRegistry = HookRegistry.HookRegistry;
+exports.DEFAULT_HOOK_TIMEOUT_MS = executeHooks.DEFAULT_HOOK_TIMEOUT_MS;
+exports.executeHooks = executeHooks.executeHooks;
+exports.MAX_CACHE_SIZE = matchers.MAX_CACHE_SIZE;
+exports.MAX_PATTERN_LENGTH = matchers.MAX_PATTERN_LENGTH;
+exports.hasNestedQuantifier = matchers.hasNestedQuantifier;
+exports.matchesQuery = matchers.matchesQuery;
+exports.HOOK_EVENTS = types.HOOK_EVENTS;
 exports.CustomOpenAIClient = index$1.CustomOpenAIClient;
 exports.ChatOpenRouter = index.ChatOpenRouter;
 exports.getChatModelClass = providers.getChatModelClass;

package/dist/cjs/main.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"main.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/messages/format.cjs

@@ -555,16 +555,38 @@ function contentPartCharLength(part) {
     }
     return len;
 }
+/** Extracts the skillName from a skill tool_call's args (string or object). */
+function extractSkillName(args) {
+    let parsed;
+    if (typeof args === 'string') {
+        try {
+            parsed = JSON.parse(args);
+        }
+        catch {
+            /* malformed args — skip */
+        }
+    }
+    else {
+        parsed = args;
+    }
+    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.
  */
-const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
-    const messages = [];
+const formatAgentMessages = (payload, indexTokenCountMap, tools, 
+/** 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) => {
+    const messages$1 = [];
     // If indexTokenCountMap is provided, create a new map to track the updated indices
     const updatedIndexTokenCountMap = {};
     let boundaryTokenAdjustment;
@@ -612,13 +634,13 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
             if (sourceMessageId != null && sourceMessageId !== '') {
                 formattedMessage.id = sourceMessageId;
             }
-            messages.push(formattedMessage);
+            messages$1.push(formattedMessage);
             // Update the index mapping for this message
-            indexMapping[i] = [messages.length - 1];
+            indexMapping[i] = [messages$1.length - 1];
             continue;
         }
         // For assistant messages, track the starting index before processing
-        const startMessageIndex = messages.length;
+        const startMessageIndex = messages$1.length;
         /**
          * If tools set is provided, process tool_calls:
          * - Keep valid tool_calls (tools in the set or dynamically discovered)
@@ -626,6 +648,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
          * - Dynamically expand the set when tool_search results are encountered
          */
         let processedMessage = message;
+        let pendingSkillNames;
         if (discoveredTools) {
             const content = message.content;
             if (content != null && Array.isArray(content)) {
@@ -661,8 +684,15 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
                         }
                     }
                     if (discoveredTools.has(toolName)) {
-                        /** Valid tool - keep it */
                         filteredContent.push(part);
+                        if (toolName === _enum.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 */
@@ -722,16 +752,48 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
                 }
             }
         }
+        /** 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 !== _enum.ContentTypes.TOOL_CALL ||
+                        part.tool_call?.name !== _enum.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) {
                 formattedMessage.id = sourceMessageId;
             }
         }
-        messages.push(...formattedMessages);
-        // Update the index mapping for this assistant message
-        // Store all indices that were created from this original message
-        const endMessageIndex = messages.length;
+        messages$1.push(...formattedMessages);
+        // Capture index range BEFORE skill body injection so injected
+        // HumanMessages are excluded from the assistant's token distribution.
+        const endMessageIndex = messages$1.length;
+        if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
+            for (const skillName of pendingSkillNames) {
+                const body = skills?.get(skillName) ?? '';
+                if (body) {
+                    messages$1.push(new messages.HumanMessage({
+                        content: body,
+                        additional_kwargs: {
+                            role: 'user',
+                            isMeta: true,
+                            source: 'skill',
+                            skillName,
+                        },
+                    }));
+                }
+            }
+        }
         const resultIndices = [];
         for (let j = startMessageIndex; j < endMessageIndex; j++) {
             resultIndices.push(j);
@@ -785,7 +847,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
             const lastIdx = msgCount - 1;
             const lengths = new Array(msgCount);
             for (let k = 0; k < msgCount; k++) {
-                const msg = messages[resultIndices[k]];
+                const msg = messages$1[resultIndices[k]];
                 const { content } = msg;
                 let len = 0;
                 if (typeof content === 'string') {
@@ -843,7 +905,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
         }
     }
     return {
-        messages,
+        messages: messages$1,
         indexTokenCountMap: indexTokenCountMap
             ? updatedIndexTokenCountMap
             : undefined,