@librechat/agents 3.4.7 → 3.5.1

package/src/scripts/search.ts

@@ -1,147 +0,0 @@
-/* eslint-disable no-console */
-// src/scripts/cli.ts
-import { config } from 'dotenv';
-config();
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { createSearchTool } from '@/tools/search';
-
-import { getArgs } from '@/scripts/args';
-import { Run } from '@/run';
-import { GraphEvents, Callback, Providers } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
-
-const conversationHistory: BaseMessage[] = [];
-async function testStandardStreaming(): 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 => {
-        aggregateContent({ event, data: data as t.RunStep });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (
-        event: GraphEvents.ON_RUN_STEP_DELTA,
-        data: t.StreamEventData
-      ): void => {
-        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
-      },
-    },
-    [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (
-        event: GraphEvents.ON_MESSAGE_DELTA,
-        data: t.StreamEventData
-      ): void => {
-        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);
-
-  if (llmConfig.provider === Providers.BEDROCK) {
-    (llmConfig as t.BedrockAnthropicInput).promptCache = true;
-  }
-
-  const run = await Run.create<t.IState>({
-    runId: 'test-run-id',
-    graphConfig: {
-      type: 'standard',
-      llmConfig,
-      tools: [
-        createSearchTool({
-          scraperProvider: 'serper',
-        }),
-      ],
-      instructions:
-        'You are a friendly AI assistant. Always address the user by their name.',
-      // additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-    },
-    returnContent: true,
-    skipCleanup: true,
-    customHandlers,
-  });
-
-  const config = {
-    configurable: {
-      provider,
-      thread_id: 'conversation-num-1',
-    },
-    streamMode: 'values',
-    version: 'v2' as const,
-  };
-
-  console.log('Test 1: Search query (search tool test)');
-
-  // const userMessage = `
-  // Make a search for the weather in ${location} today, which is ${currentDate}.
-  // Before making the search, please let me know what you're about to do, then immediately start searching without hesitation.
-  // Make sure to always refer to me by name, which is ${userName}.
-  // After giving me a thorough summary, tell me a joke about the weather forecast we went over.
-  // `;
-  // const userMessage = 'Are massage guns good?';
-  // const userMessage = 'What is functional programming?';
-  const userMessage = "Get me today's trending news.";
-  // const userMessage = "search recent italy earthquake volcano activity";
-  // const userMessage =
-  //   "use 'Trump' as the exact search query and tell me what you find.";
-
-  conversationHistory.push(new HumanMessage(userMessage));
-
-  const inputs = {
-    messages: conversationHistory,
-  };
-  const finalContentParts = await run.processStream(inputs, config);
-  const finalMessages = run.getRunMessages();
-  if (finalMessages) {
-    conversationHistory.push(...finalMessages);
-    console.dir(conversationHistory, { depth: null });
-  }
-  // console.dir(finalContentParts, { depth: null });
-  console.log('\n\n====================\n\n');
-  // console.dir(contentParts, { depth: null });
-}
-
-process.on('unhandledRejection', (reason, promise) => {
-  console.warn('Unhandled Rejection (non-fatal):', reason);
-});
-
-testStandardStreaming().catch((err) => {
-  console.error(err);
-  console.log('Conversation history:');
-  console.dir(conversationHistory, { depth: null });
-  process.exit(1);
-});

package/src/scripts/sequential-full-metadata-test.ts

@@ -1,198 +0,0 @@
-import { config } from 'dotenv';
-config();
-
-import { HumanMessage, BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { Providers, GraphEvents } from '@/common';
-import { sleep } from '@/utils/run';
-import { Run } from '@/run';
-
-const conversationHistory: BaseMessage[] = [];
-
-/**
- * Dump ALL metadata for SEQUENTIAL execution to compare with parallel
- */
-async function testSequentialMetadata() {
-  console.log('Dumping FULL metadata for SEQUENTIAL execution...\n');
-
-  const { contentParts, aggregateContent } = createContentAggregator();
-
-  const allMetadata: Array<{
-    event: string;
-    timestamp: number;
-    metadata: Record<string, unknown>;
-  }> = [];
-  const startTime = Date.now();
-
-  // Sequential chain: agent_a -> agent_b
-  const agents: t.AgentInputs[] = [
-    {
-      agentId: 'agent_a',
-      provider: Providers.ANTHROPIC,
-      clientOptions: {
-        modelName: 'claude-haiku-4-5',
-        apiKey: process.env.ANTHROPIC_API_KEY,
-      },
-      instructions: `You are Agent A. Just say "Hello from A" in one sentence.`,
-    },
-    {
-      agentId: 'agent_b',
-      provider: Providers.ANTHROPIC,
-      clientOptions: {
-        modelName: 'claude-haiku-4-5',
-        apiKey: process.env.ANTHROPIC_API_KEY,
-      },
-      instructions: `You are Agent B. Just say "Hello from B" in one sentence.`,
-    },
-  ];
-
-  // Sequential edge: A -> B (using edgeType not type)
-  const edges: t.GraphEdge[] = [
-    { from: 'agent_a', to: 'agent_b', edgeType: 'direct' },
-  ];
-
-  const captureMetadata = (
-    eventName: string,
-    metadata?: Record<string, unknown>
-  ) => {
-    if (metadata) {
-      allMetadata.push({
-        event: eventName,
-        timestamp: Date.now() - startTime,
-        metadata: { ...metadata },
-      });
-    }
-  };
-
-  const customHandlers = {
-    [GraphEvents.CHAT_MODEL_END]: {
-      handle: (
-        _event: string,
-        _data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        captureMetadata('CHAT_MODEL_END', metadata);
-      },
-    },
-    [GraphEvents.CHAT_MODEL_START]: {
-      handle: (
-        _event: string,
-        _data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        captureMetadata('CHAT_MODEL_START', metadata);
-      },
-    },
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.ON_RUN_STEP]: {
-      handle: (
-        event: GraphEvents.ON_RUN_STEP,
-        data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        captureMetadata('ON_RUN_STEP', metadata);
-        aggregateContent({ event, data: data as t.RunStep });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (
-        event: GraphEvents.ON_RUN_STEP_DELTA,
-        data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
-      },
-    },
-    [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (
-        event: GraphEvents.ON_MESSAGE_DELTA,
-        data: t.StreamEventData,
-        metadata?: Record<string, unknown>
-      ): void => {
-        aggregateContent({ event, data: data as t.MessageDeltaEvent });
-      },
-    },
-  };
-
-  const runConfig: t.RunConfig = {
-    runId: `sequential-metadata-${Date.now()}`,
-    graphConfig: {
-      type: 'multi-agent',
-      agents,
-      edges,
-    },
-    customHandlers,
-    returnContent: true,
-    skipCleanup: true,
-  };
-
-  try {
-    const run = await Run.create(runConfig);
-
-    const userMessage = `Hi`;
-    conversationHistory.push(new HumanMessage(userMessage));
-
-    const config = {
-      configurable: {
-        thread_id: 'sequential-metadata-test-1',
-      },
-      streamMode: 'values',
-      version: 'v2' as const,
-    };
-
-    await run.processStream({ messages: conversationHistory }, config);
-
-    // Print ALL CHAT_MODEL_START metadata (don't dedupe)
-    console.log(
-      '\n\n========== ALL CHAT_MODEL_START EVENTS (SEQUENTIAL) ==========\n'
-    );
-    for (const entry of allMetadata) {
-      if (entry.event === 'CHAT_MODEL_START') {
-        const node = entry.metadata.langgraph_node as string;
-        console.log(`\n--- ${node} (at ${entry.timestamp}ms) ---`);
-        console.dir(entry.metadata, { depth: null });
-      }
-    }
-
-    console.log('\n\n========== ALL EVENTS ==========\n');
-    for (const entry of allMetadata) {
-      console.log(
-        `[${entry.timestamp}ms] ${entry.event}: ${entry.metadata.langgraph_node}`
-      );
-    }
-
-    // Key comparison
-    console.log(
-      '\n\n========== KEY FIELDS COMPARISON (SEQUENTIAL) ==========\n'
-    );
-
-    const agentMetadataMap = new Map<string, Record<string, unknown>>();
-    for (const entry of allMetadata) {
-      if (entry.event === 'CHAT_MODEL_START') {
-        const node = entry.metadata.langgraph_node as string;
-        if (!agentMetadataMap.has(node)) {
-          agentMetadataMap.set(node, entry.metadata);
-        }
-      }
-    }
-
-    for (const [node, meta] of agentMetadataMap) {
-      console.log(`${node}:`);
-      console.log(`  langgraph_step: ${meta.langgraph_step}`);
-      console.log(
-        `  langgraph_triggers: ${JSON.stringify(meta.langgraph_triggers)}`
-      );
-      console.log(`  checkpoint_ns: ${meta.checkpoint_ns}`);
-      console.log(`  __pregel_task_id: ${meta.__pregel_task_id}`);
-      console.log(`  langgraph_path: ${JSON.stringify(meta.langgraph_path)}`);
-      console.log();
-    }
-
-    await sleep(1000);
-  } catch (error) {
-    console.error('Error:', error);
-  }
-}
-
-testSequentialMetadata();