@librechat/agents 2.2.8 → 2.2.9

package/src/scripts/code_exec_files.ts

@@ -0,0 +1,162 @@
+// src/scripts/cli.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler, createMetadataAggregator } from '@/events';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { GraphEvents } from '@/common';
+import { Run } from '@/run';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+
+const conversationHistory: BaseMessage[] = [];
+
+async function testCodeExecution(): Promise<void> {
+  const { userName, location, provider, currentDate } = await getArgs();
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_RUN_STEP_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_MESSAGE_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
+        console.log('====== TOOL_START ======');
+        console.dir(data, { depth: null });
+      }
+    },
+  };
+
+  const llmConfig = getLLMConfig(provider);
+
+  const run = await Run.create<t.IState>({
+    runId: 'message-num-1',
+    graphConfig: {
+      type: 'standard',
+      llmConfig,
+      tools: [createCodeExecutionTool()],
+      instructions: 'You are a friendly AI assistant with coding capabilities. Always address the user by their name.',
+      additional_instructions: `The user's name is ${userName} and they are located in ${location}. The current date is ${currentDate}.`,
+    },
+    returnContent: true,
+    customHandlers,
+  });
+
+  const config: Partial<RunnableConfig> & { version: 'v1' | 'v2'; run_id?: string; streamMode: string } = {
+    configurable: {
+      provider,
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+    // recursionLimit: 3,
+  };
+
+  console.log('Test 1: Create Project Plan');
+
+  const userMessage1 = `
+  Hi ${userName} here. We are testing your file capabilities.
+  
+  1. Create a text file named "project_plan.txt" that contains: "This is a project plan for a new software development project."
+  
+  Please generate this file so I can review it.
+  `;
+
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  let inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts1 = await run.processStream(inputs, config);
+  const finalMessages1 = run.getRunMessages();
+  if (finalMessages1) {
+    conversationHistory.push(...finalMessages1);
+  }
+  console.log('\n\n====================\n\n');
+  console.dir(contentParts, { depth: null });
+
+  console.log('Test 2: Edit Project Plan');
+
+  const userMessage2 = `
+  Thanks for creating the project plan. Now I'd like you to edit the same plan to:
+  
+  1. Add a new section called "Technology Stack" that contains: "The technology stack for this project includes the following technologies" and nothing more.
+  
+`;
+
+  // Make sure to pass the file ID of the previous file you created and explicitly duplicate or rename the file in your code so we can then access it. Also print the contents of the new file to ensure we did what we wanted.`;
+
+  conversationHistory.push(new HumanMessage(userMessage2));
+
+  inputs = {
+    messages: conversationHistory,
+  };
+  const finalContentParts2 = await run.processStream(inputs, config);
+  const finalMessages2 = run.getRunMessages();
+  if (finalMessages2) {
+    conversationHistory.push(...finalMessages2);
+  }
+  console.log('\n\n====================\n\n');
+  console.dir(contentParts, { depth: null });
+
+  const { handleLLMEnd, collected } = createMetadataAggregator();
+  const titleResult = await run.generateTitle({
+    inputText: userMessage2,
+    contentParts,
+    chainOptions: {
+      callbacks: [{
+        handleLLMEnd,
+      }],
+    },
+  });
+  console.log('Generated Title:', titleResult);
+  console.log('Collected metadata:', collected);
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testCodeExecution().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  process.exit(1);
+});

package/src/specs/thinking-prune.test.ts

@@ -0,0 +1,393 @@
+// src/specs/thinking-prune.test.ts
+import { HumanMessage, AIMessage, SystemMessage, BaseMessage, ToolMessage } from '@langchain/core/messages';
+import type * as t from '@/types';
+import { createPruneMessages } from '@/messages/prune';
+
+// Create a simple token counter for testing
+const createTestTokenCounter = (): t.TokenCounter => {
+  return (message: BaseMessage): number => {
+    // Use type assertion to help TypeScript understand the type
+    const content = message.content as string | Array<any> | undefined;
+    
+    // Handle string content
+    if (typeof content === 'string') {
+      return content.length;
+    }
+    
+    // Handle array content
+    if (Array.isArray(content)) {
+      let totalLength = 0;
+      
+      for (const item of content) {
+        if (typeof item === 'string') {
+          totalLength += item.length;
+        } else if (item && typeof item === 'object') {
+          if (item.type === 'thinking' && typeof item.thinking === 'string') {
+            totalLength += item.thinking.length;
+          } else if ('text' in item && typeof item.text === 'string') {
+            totalLength += item.text.length;
+          } else if ('input' in item && typeof item.input === 'string') {
+            totalLength += item.input.length;
+          }
+        }
+      }
+      
+      return totalLength;
+    }
+    
+    // Default case - if content is null, undefined, or any other type
+    return 0;
+  };
+};
+
+describe('Prune Messages with Thinking Mode Tests', () => {
+  jest.setTimeout(30000);
+  
+  it('should preserve thinking blocks when pruning with thinking mode enabled', () => {
+    // Create a token counter
+    const tokenCounter = createTestTokenCounter();
+    
+    // Create messages based on the example provided
+    const userMessage = new HumanMessage({
+      content: [
+        {
+          type: "text",
+          text: "/home/danny/LibreChat/gistfile1.txt\n\nread it 200 lines at a time\n\nthere are 5000 lines\n\ndo not stop until done",
+        },
+      ],
+    });
+    
+    const assistantMessageWithThinking = new AIMessage({
+      content: [
+        {
+          type: "thinking",
+          thinking: "The user is asking me to read a file located at `/home/danny/LibreChat/gistfile1.txt` in chunks of 200 lines at a time, mentioning that the file has 5000 lines total. They want me to continue reading through the entire file without stopping.\n\nI'll need to use the text editor tool to view the file in chunks of 200 lines each. Since the file has 5000 lines, I'll need to view it in 25 chunks (5000 ÷ 200 = 25).\n\nI'll need to make multiple calls to the text editor with the `view` command, specifying different line ranges for each call.\n\nLet me plan out the approach:\n1. Start with lines 1-200\n2. Then 201-400\n3. Then 401-600\n4. And so on until I reach 4801-5000\n\nFor each call, I'll use the `view` command with the specific line range in the `view_range` parameter. I'll continue until I've shown all 5000 lines as requested.",
+        },
+        {
+          type: "text",
+          text: "I'll read the file for you in chunks of 200 lines at a time until all 5000 lines are displayed.\n\nLet me start with the first 200 lines:",
+        },
+        {
+          type: "tool_use",
+          id: "toolu_01YApWuFsEQCuBFDgYXmcmeZ",
+          name: "text_editor_mcp_textEditor",
+          input: "{\"command\": \"view\", \"path\": \"/home/danny/LibreChat/gistfile1.txt\", \"description\": \"Viewing lines 1-200 of the file\", \"view_range\": [1,200]}",
+        },
+      ],
+    });
+    
+    const toolResponseMessage1 = new ToolMessage({
+      content: [
+        {
+          type: "text",
+          text: "{\"success\":true,\"message\":\"File content (truncated):\"",
+        },
+      ],
+      tool_call_id: "toolu_01YApWuFsEQCuBFDgYXmcmeZ",
+      name: "text_editor_mcp_textEditor",
+    });
+    
+    const assistantMessage2 = new AIMessage({
+      content: [
+        {
+          type: "text",
+          text: "It looks like the file content is clipped in the response. I'll continue with the next chunks:",
+        },
+        {
+          type: "tool_use",
+          id: "toolu_01VnyMQ4CvEd6zLDxxtTd6d4",
+          name: "text_editor_mcp_textEditor",
+          input: "{\"command\": \"view\", \"path\": \"/home/danny/LibreChat/gistfile1.txt\", \"description\": \"Viewing lines 201-400 of the file\", \"view_range\": [201,400]}",
+        },
+      ],
+    });
+    
+    const toolResponseMessage2 = new ToolMessage({
+      content: [
+        {
+          type: "text",
+          text: "{\"success\":true,\"message\":\"File content (truncated):\"",
+        },
+      ],
+      tool_call_id: "toolu_01VnyMQ4CvEd6zLDxxtTd6d4",
+      name: "text_editor_mcp_textEditor",
+    });
+    
+    const assistantMessage3 = new AIMessage({
+      content: [
+        {
+          type: "text",
+          text: "Continuing with the next chunk:",
+        },
+        {
+          type: "tool_use",
+          id: "toolu_01TZKs4nnBc58BYXKz1Mw4fp",
+          name: "text_editor_mcp_textEditor",
+          input: "{\"command\": \"view\", \"path\": \"/home/danny/LibreChat/gistfile1.txt\", \"description\": \"Viewing lines 401-600 of the file\", \"view_range\": [401,600]}",
+        },
+      ],
+    });
+    
+    const toolResponseMessage3 = new ToolMessage({
+      content: [
+        {
+          type: "text",
+          text: "{\"success\":true,\"message\":\"File content (truncated):\"",
+        },
+      ],
+      tool_call_id: "toolu_01TZKs4nnBc58BYXKz1Mw4fp",
+      name: "text_editor_mcp_textEditor",
+    });
+    
+    const assistantMessage4 = new AIMessage({
+      content: [
+        {
+          type: "text",
+          text: "Let's continue with the next chunk:",
+        },
+        {
+          type: "tool_use",
+          id: "toolu_01TZgBacNxjx1QNUpJg9hca5",
+          name: "text_editor_mcp_textEditor",
+          input: "{\"command\": \"view\", \"path\": \"/home/danny/LibreChat/gistfile1.txt\", \"description\": \"Viewing lines 601-800 of the file\", \"view_range\": [601,800]}",
+        },
+      ],
+    });
+    
+    const toolResponseMessage4 = new ToolMessage({
+      content: [
+        {
+          type: "text",
+          text: "{\"success\":true,\"message\":\"File content (truncated):\"",
+        },
+      ],
+      tool_call_id: "toolu_01TZgBacNxjx1QNUpJg9hca5",
+      name: "text_editor_mcp_textEditor",
+    });
+    
+    const messages = [
+      userMessage,
+      assistantMessageWithThinking,
+      toolResponseMessage1,
+      assistantMessage2,
+      toolResponseMessage2,
+      assistantMessage3,
+      toolResponseMessage3,
+      assistantMessage4,
+      toolResponseMessage4,
+    ];
+    
+    // Create indexTokenCountMap based on the example provided
+    const indexTokenCountMap = {
+      "0": 617, // userMessage
+      "1": 52,  // assistantMessageWithThinking
+      "2": 4995, // toolResponseMessage1
+      "3": 307, // assistantMessage2
+      "4": 9359, // toolResponseMessage2
+      "5": 178, // assistantMessage3
+      "6": 5463, // toolResponseMessage3
+      "7": 125, // assistantMessage4
+      "8": 4264, // toolResponseMessage4
+    };
+    
+    // Create pruneMessages function with thinking mode enabled
+    const pruneMessages = createPruneMessages({
+      maxTokens: 19800,
+      startIndex: 0,
+      tokenCounter,
+      indexTokenCountMap: { ...indexTokenCountMap },
+      thinkingEnabled: true,
+    });
+    
+    // Prune messages
+    const result = pruneMessages({ 
+      messages,
+      usageMetadata: {
+        input_tokens: 25254,
+        output_tokens: 106,
+        total_tokens: 25360,
+        input_token_details: {
+          cache_read: 0,
+          cache_creation: 0,
+        },
+      },
+      startOnMessageType: 'human',
+    });
+    
+    // Verify that the first assistant message in the pruned context has a thinking block
+    expect(result.context.length).toBeGreaterThan(0);
+    
+    // Find the first assistant message in the pruned context
+    const firstAssistantIndex = result.context.findIndex(msg => msg.getType() === 'ai');
+    expect(firstAssistantIndex).toBe(0);
+    
+    const firstAssistantMsg = result.context[firstAssistantIndex];
+    expect(Array.isArray(firstAssistantMsg.content)).toBe(true);
+    
+    // Verify that the first assistant message has a thinking block
+    const hasThinkingBlock = (firstAssistantMsg.content as any[]).some(item => 
+      item && typeof item === 'object' && item.type === 'thinking');
+    expect(hasThinkingBlock).toBe(true);
+    
+    // Verify that the thinking block is from the original assistant message
+    const thinkingBlock = (firstAssistantMsg.content as any[]).find(item => 
+      item && typeof item === 'object' && item.type === 'thinking');
+    expect(thinkingBlock).toBeDefined();
+    expect(thinkingBlock.thinking).toContain("The user is asking me to read a file");
+  });
+  
+  it('should handle token recalculation when inserting thinking blocks', () => {
+    // Create a token counter
+    const tokenCounter = createTestTokenCounter();
+    
+    // Create a message with thinking block
+    const assistantMessageWithThinking = new AIMessage({
+      content: [
+        {
+          type: "thinking",
+          thinking: "This is a thinking block",
+        },
+        {
+          type: "text",
+          text: "Response with thinking",
+        },
+      ],
+    });
+    
+    // Create a message without thinking block
+    const assistantMessageWithoutThinking = new AIMessage({
+      content: [
+        {
+          type: "text",
+          text: "Response without thinking",
+        },
+      ],
+    });
+    
+    const messages = [
+      new SystemMessage("System instruction"),
+      new HumanMessage("Hello"),
+      assistantMessageWithThinking,
+      new HumanMessage("Next message"),
+      assistantMessageWithoutThinking,
+    ];
+    
+    // Calculate token counts for each message
+    const indexTokenCountMap: Record<string, number> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+    
+    // Create pruneMessages function with thinking mode enabled
+    const pruneMessages = createPruneMessages({
+      maxTokens: 50, // Set a low token limit to force pruning
+      startIndex: 0,
+      tokenCounter,
+      indexTokenCountMap: { ...indexTokenCountMap },
+      thinkingEnabled: true,
+    });
+    
+    // Prune messages
+    const result = pruneMessages({ messages });
+    
+    // Verify that the pruned context has fewer messages than the original
+    expect(result.context.length).toBeLessThan(messages.length);
+    
+    // Find the first assistant message in the pruned context
+    const firstAssistantIndex = result.context.findIndex(msg => msg.getType() === 'ai');
+    expect(firstAssistantIndex).toBeGreaterThan(-1);
+    
+    const firstAssistantMsg = result.context[firstAssistantIndex];
+    expect(Array.isArray(firstAssistantMsg.content)).toBe(true);
+    
+    // Verify that the first assistant message has a thinking block
+    const hasThinkingBlock = (firstAssistantMsg.content as any[]).some(item => 
+      item && typeof item === 'object' && item.type === 'thinking');
+    expect(hasThinkingBlock).toBe(true);
+  });
+  
+  it('should not modify messages when under token limit', () => {
+    // Create a token counter
+    const tokenCounter = createTestTokenCounter();
+    
+    // Create a message with thinking block
+    const assistantMessageWithThinking = new AIMessage({
+      content: [
+        {
+          type: "thinking",
+          thinking: "This is a thinking block",
+        },
+        {
+          type: "text",
+          text: "Response with thinking",
+        },
+      ],
+    });
+    
+    const messages = [
+      new SystemMessage("System instruction"),
+      new HumanMessage("Hello"),
+      assistantMessageWithThinking,
+    ];
+    
+    // Calculate token counts for each message
+    const indexTokenCountMap: Record<string, number> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+    
+    // Create pruneMessages function with thinking mode enabled
+    const pruneMessages = createPruneMessages({
+      maxTokens: 1000, // Set a high token limit to avoid pruning
+      startIndex: 0,
+      tokenCounter,
+      indexTokenCountMap: { ...indexTokenCountMap },
+      thinkingEnabled: true,
+    });
+    
+    // Prune messages
+    const result = pruneMessages({ messages });
+    
+    // Verify that all messages are preserved
+    expect(result.context.length).toBe(messages.length);
+    expect(result.context).toEqual(messages);
+  });
+  
+  it('should handle the case when no thinking blocks are found', () => {
+    // Create a token counter
+    const tokenCounter = createTestTokenCounter();
+    
+    // Create messages without thinking blocks
+    const messages = [
+      new SystemMessage("System instruction"),
+      new HumanMessage("Hello"),
+      new AIMessage("Response without thinking"),
+      new HumanMessage("Next message"),
+      new AIMessage("Another response without thinking"),
+    ];
+    
+    // Calculate token counts for each message
+    const indexTokenCountMap: Record<string, number> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = tokenCounter(messages[i]);
+    }
+    
+    // Create pruneMessages function with thinking mode enabled
+    const pruneMessages = createPruneMessages({
+      maxTokens: 50, // Set a low token limit to force pruning
+      startIndex: 0,
+      tokenCounter,
+      indexTokenCountMap: { ...indexTokenCountMap },
+      thinkingEnabled: true,
+    });
+    
+    // Prune messages
+    const result = pruneMessages({ messages });
+    
+    // Verify that the pruned context has fewer messages than the original
+    expect(result.context.length).toBeLessThan(messages.length);
+    
+    // The function should not throw an error even though no thinking blocks are found
+    expect(() => pruneMessages({ messages })).not.toThrow();
+  });
+});