@librechat/agents 3.1.67-dev.4 → 3.1.68

package/src/messages/formatAgentMessages.skills.test.ts

@@ -1,334 +0,0 @@
-import { HumanMessage } from '@langchain/core/messages';
-import type { TPayload } from '@/types';
-import { formatAgentMessages } from './format';
-import { ContentTypes, Constants } from '@/common';
-
-/** Helper to build a skill tool_call content part */
-function skillToolCall(
-  id: string,
-  skillName: string,
-  output = 'Skill loaded.',
-): Record<string, unknown> {
-  return {
-    type: ContentTypes.TOOL_CALL,
-    tool_call: {
-      id,
-      name: Constants.SKILL_TOOL,
-      args: JSON.stringify({ skillName }),
-      output,
-    },
-  };
-}
-
-describe('formatAgentMessages skill body reconstruction', () => {
-  const skillBodies = new Map([
-    ['pdf-analyzer', '# PDF Analyzer\nAnalyze PDF files step by step.'],
-    ['code-review', '# Code Review\nReview the code for issues.'],
-  ]);
-
-  describe('with discoveredTools (tools filtering active)', () => {
-    const tools = new Set([Constants.SKILL_TOOL, 'web_search']);
-
-    it('reconstructs HumanMessage after skill ToolMessage', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Analyze this PDF' },
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: ContentTypes.TEXT,
-              [ContentTypes.TEXT]: 'I\'ll invoke the skill.',
-              tool_call_ids: ['call_1'],
-            },
-            skillToolCall('call_1', 'pdf-analyzer'),
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      // user, AI, ToolMessage, injected HumanMessage
-      expect(messages.length).toBeGreaterThanOrEqual(4);
-      const last = messages[messages.length - 1];
-      expect(last).toBeInstanceOf(HumanMessage);
-      expect(last.content).toBe('# PDF Analyzer\nAnalyze PDF files step by step.');
-      expect((last as HumanMessage).additional_kwargs.source).toBe('skill');
-      expect((last as HumanMessage).additional_kwargs.skillName).toBe('pdf-analyzer');
-      expect((last as HumanMessage).additional_kwargs.isMeta).toBe(true);
-    });
-
-    it('does NOT inject body when skill tool is not in discoveredTools', () => {
-      const restrictedTools = new Set(['web_search']); // skill NOT allowed
-      const payload: TPayload = [
-        { role: 'user', content: 'Analyze this' },
-        {
-          role: 'assistant',
-          content: [skillToolCall('call_1', 'pdf-analyzer')],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, restrictedTools, skillBodies);
-
-      const humanMessages = messages.filter((m) => m instanceof HumanMessage);
-      // Only the user message, no injected skill body
-      expect(humanMessages).toHaveLength(1);
-    });
-
-    it('does not inject when skill name is not in skills Map', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [skillToolCall('call_1', 'unknown-skill')],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const humanMessages = messages.filter((m) => m instanceof HumanMessage);
-      expect(humanMessages).toHaveLength(1); // only the user message
-    });
-  });
-
-  describe('without discoveredTools (no tools filtering)', () => {
-    it('reconstructs HumanMessage when skills Map provided', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Review my code' },
-        {
-          role: 'assistant',
-          content: [skillToolCall('call_1', 'code-review')],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, undefined, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(1);
-      expect(injected[0].content).toBe('# Code Review\nReview the code for issues.');
-    });
-
-    it('no injection when skills Map is undefined', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [skillToolCall('call_1', 'pdf-analyzer')],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, undefined, undefined);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(0);
-    });
-
-    it('no injection when skills Map is empty', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [skillToolCall('call_1', 'pdf-analyzer')],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, undefined, new Map());
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(0);
-    });
-  });
-
-  describe('extractSkillName edge cases', () => {
-    const tools = new Set([Constants.SKILL_TOOL]);
-
-    it('handles object args (not stringified)', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Go' },
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: ContentTypes.TOOL_CALL,
-              tool_call: {
-                id: 'call_1',
-                name: Constants.SKILL_TOOL,
-                args: { skillName: 'pdf-analyzer' }, // object, not string
-                output: 'Loaded.',
-              },
-            },
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(1);
-    });
-
-    it('gracefully skips malformed JSON args', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Go' },
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: ContentTypes.TOOL_CALL,
-              tool_call: {
-                id: 'call_1',
-                name: Constants.SKILL_TOOL,
-                args: '{bad json',
-                output: 'Loaded.',
-              },
-            },
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(0); // gracefully skipped
-    });
-
-    it('skips empty skillName', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Go' },
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: ContentTypes.TOOL_CALL,
-              tool_call: {
-                id: 'call_1',
-                name: Constants.SKILL_TOOL,
-                args: JSON.stringify({ skillName: '' }),
-                output: 'Loaded.',
-              },
-            },
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(0);
-    });
-  });
-
-  describe('deduplication', () => {
-    const tools = new Set([Constants.SKILL_TOOL]);
-
-    it('injects body only once when same skill invoked twice in one message', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Go' },
-        {
-          role: 'assistant',
-          content: [
-            skillToolCall('call_1', 'pdf-analyzer'),
-            skillToolCall('call_2', 'pdf-analyzer'),
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(1);
-    });
-
-    it('injects body for each distinct skill invoked', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Go' },
-        {
-          role: 'assistant',
-          content: [
-            skillToolCall('call_1', 'pdf-analyzer'),
-            skillToolCall('call_2', 'code-review'),
-          ],
-        },
-      ];
-
-      const { messages } = formatAgentMessages(payload, undefined, tools, skillBodies);
-
-      const injected = messages.filter(
-        (m) => m instanceof HumanMessage && (m as HumanMessage).additional_kwargs?.source === 'skill',
-      );
-      expect(injected).toHaveLength(2);
-      const names = injected.map((m) => (m as HumanMessage).additional_kwargs.skillName);
-      expect(names).toContain('pdf-analyzer');
-      expect(names).toContain('code-review');
-    });
-  });
-
-  describe('indexTokenCountMap distribution', () => {
-    const tools = new Set([Constants.SKILL_TOOL]);
-
-    it('excludes injected HumanMessages from assistant token distribution', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Analyze this' },
-        {
-          role: 'assistant',
-          content: [
-            {
-              type: ContentTypes.TEXT,
-              [ContentTypes.TEXT]: 'Invoking skill.',
-              tool_call_ids: ['call_1'],
-            },
-            skillToolCall('call_1', 'pdf-analyzer'),
-          ],
-        },
-      ];
-
-      const inputTokenMap: Record<number, number | undefined> = {
-        0: 100, // user message
-        1: 500, // assistant message
-      };
-
-      const { messages, indexTokenCountMap } = formatAgentMessages(
-        payload,
-        inputTokenMap,
-        tools,
-        skillBodies,
-      );
-
-      // There should be messages: user, AI, ToolMessage, injected HumanMessage
-      expect(messages.length).toBeGreaterThanOrEqual(4);
-      const lastMsg = messages[messages.length - 1];
-      expect(lastMsg).toBeInstanceOf(HumanMessage);
-      expect((lastMsg as HumanMessage).additional_kwargs.source).toBe('skill');
-
-      // Token map must be defined when input was provided
-      expect(indexTokenCountMap).toBeDefined();
-
-      // The injected HumanMessage's index should NOT be in the token map
-      const injectedIndex = messages.length - 1;
-      expect(indexTokenCountMap![injectedIndex]).toBeUndefined();
-
-      // The assistant's 500 tokens should be distributed only across
-      // the AI + ToolMessage, NOT the injected HumanMessage
-      let assistantTotal = 0;
-      for (const [idx, count] of Object.entries(indexTokenCountMap!)) {
-        if (Number(idx) > 0 && Number(idx) < injectedIndex) {
-          assistantTotal += count ?? 0;
-        }
-      }
-      expect(assistantTotal).toBe(500);
-    });
-  });
-});

package/src/scripts/multi-agent-subagent.ts

@@ -1,246 +0,0 @@
-import { config } from 'dotenv';
-config();
-
-import { HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import type * as t from '@/types';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { Providers, GraphEvents, Constants } from '@/common';
-import { Run } from '@/run';
-
-/**
- * Manual verification script for the subagent primitive.
- *
- * Configures a supervisor agent with two subagent types (researcher, coder),
- * sends a query, and confirms:
- * 1. The parent agent delegates to a subagent via the `subagent` tool
- * 2. The child executes with isolated context (fresh message history)
- * 3. Only the filtered text result returns to the parent
- * 4. The parent incorporates the result and responds
- *
- * Usage:
- *   OPENAI_API_KEY=... npx ts-node -r tsconfig-paths/register src/scripts/multi-agent-subagent.ts
- *
- * Or with Anthropic:
- *   ANTHROPIC_API_KEY=... npx ts-node -r tsconfig-paths/register src/scripts/multi-agent-subagent.ts --provider anthropic
- */
-
-const useAnthropic =
-  process.argv.includes('--provider') &&
-  process.argv[process.argv.indexOf('--provider') + 1] === 'anthropic';
-
-const provider = useAnthropic ? Providers.ANTHROPIC : Providers.OPENAI;
-const apiKey = useAnthropic
-  ? process.env.ANTHROPIC_API_KEY
-  : process.env.OPENAI_API_KEY;
-const modelName = useAnthropic ? 'claude-sonnet-4-20250514' : 'gpt-5.4';
-
-if (!apiKey) {
-  console.error(
-    `Missing ${useAnthropic ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'} environment variable`
-  );
-  process.exit(1);
-}
-
-async function testSubagentPrimitive() {
-  console.log('=== Subagent Primitive Manual Verification ===\n');
-  console.log(`Provider: ${provider}`);
-  console.log(`Model: ${modelName}\n`);
-
-  const { aggregateContent } = createContentAggregator();
-
-  const parentAgent: t.AgentInputs = {
-    agentId: 'supervisor',
-    provider,
-    clientOptions: { modelName, apiKey },
-    instructions: `You are a supervisor agent. You have access to specialized subagents.
-
-When the user asks a research question, delegate it to the "researcher" subagent.
-When the user asks for code, delegate it to the "coder" subagent.
-
-After receiving the subagent's result, synthesize it into a clear final answer for the user.
-Always use a subagent for research or coding tasks — do not answer directly.`,
-    maxContextTokens: 16000,
-    subagentConfigs: [
-      {
-        type: 'researcher',
-        name: 'Research Specialist',
-        description:
-          'Researches topics and provides detailed summaries with sources.',
-        agentInputs: {
-          agentId: 'researcher',
-          provider,
-          clientOptions: { modelName, apiKey },
-          instructions: `You are a research specialist working in an isolated context.
-You receive a single task description and must answer it thoroughly.
-Be concise but comprehensive. Include key facts and details.`,
-          maxContextTokens: 8000,
-        },
-      },
-      {
-        type: 'coder',
-        name: 'Coding Specialist',
-        description:
-          'Writes, reviews, and explains code in any programming language.',
-        agentInputs: {
-          agentId: 'coder',
-          provider,
-          clientOptions: { modelName, apiKey },
-          instructions: `You are a coding specialist working in an isolated context.
-You receive a single task description and must provide working code.
-Include brief explanations. Use clean, idiomatic code.`,
-          maxContextTokens: 8000,
-        },
-      },
-    ],
-  };
-
-  const customHandlers: Record<string, t.EventHandler> = {
-    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
-    [GraphEvents.TOOL_END]: new ToolEndHandler(),
-    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStep,
-        });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStep,
-        });
-      },
-    },
-    [GraphEvents.ON_RUN_STEP_DELTA]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.RunStepDeltaEvent,
-        });
-      },
-    },
-    [GraphEvents.ON_MESSAGE_DELTA]: {
-      handle: (event: string, data: t.StreamEventData): void => {
-        aggregateContent({
-          event: event as GraphEvents,
-          data: data as t.MessageDeltaEvent,
-        });
-      },
-    },
-  };
-
-  const run = await Run.create<t.IState>({
-    runId: `subagent-manual-${Date.now()}`,
-    graphConfig: {
-      type: 'standard',
-      agents: [parentAgent],
-    },
-    returnContent: true,
-    customHandlers,
-  });
-
-  console.log('--- Run created ---');
-  console.log(
-    `Subagent tool present: ${
-      (
-        (run.Graph as import('@/graphs/Graph').StandardGraph).agentContexts.get(
-          'supervisor'
-        )?.graphTools as t.GenericTool[] | undefined
-      )?.some((t) => 'name' in t && t.name === Constants.SUBAGENT) ?? false
-    }\n`
-  );
-
-  const conversationHistory: BaseMessage[] = [];
-
-  // Turn 1: Research question (should delegate to researcher subagent)
-  console.log('=== Turn 1: Research Question ===\n');
-  console.log(
-    'User: What are the three laws of thermodynamics? Explain briefly.\n'
-  );
-
-  const userMessage = new HumanMessage(
-    'What are the three laws of thermodynamics? Explain briefly.'
-  );
-  conversationHistory.push(userMessage);
-
-  const callerConfig = {
-    configurable: { thread_id: 'subagent-verify' },
-    streamMode: 'values' as const,
-    version: 'v2' as const,
-  };
-
-  console.log('--- Streaming response ---\n');
-  const result = await run.processStream(
-    { messages: conversationHistory },
-    callerConfig
-  );
-
-  const runMessages = run.getRunMessages();
-  console.log('\n\n--- Run Messages ---\n');
-
-  if (runMessages) {
-    for (const msg of runMessages) {
-      const type = msg._getType();
-      if (type === 'tool') {
-        const name = 'name' in msg ? msg.name : 'unknown';
-        const rawContent =
-          typeof msg.content === 'string'
-            ? msg.content
-            : JSON.stringify(msg.content);
-        const content = rawContent.slice(0, 200);
-        const truncated = rawContent.length > 200 ? '...' : '';
-        console.log(`[ToolMessage] name=${name}`);
-        console.log(`  content: ${content}${truncated}\n`);
-      } else if (type === 'ai') {
-        const content =
-          typeof msg.content === 'string'
-            ? msg.content.slice(0, 300)
-            : JSON.stringify(msg.content).slice(0, 300);
-        const toolCalls = 'tool_calls' in msg ? msg.tool_calls : undefined;
-        console.log(`[AIMessage]`);
-        if (toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
-          for (const tc of toolCalls) {
-            console.log(
-              `  tool_call: ${tc.name}(${JSON.stringify(tc.args).slice(0, 100)}...)`
-            );
-          }
-        }
-        console.log(
-          `  content: ${content}${content.length >= 300 ? '...' : ''}\n`
-        );
-      }
-    }
-
-    const subagentToolMessages = runMessages.filter(
-      (msg) =>
-        msg._getType() === 'tool' &&
-        'name' in msg &&
-        msg.name === Constants.SUBAGENT
-    );
-    console.log(`\n--- Verification ---`);
-    console.log(`Subagent tool calls found: ${subagentToolMessages.length}`);
-    console.log(`Total run messages: ${runMessages.length}`);
-    console.log(`Result content parts: ${result?.length ?? 0}`);
-
-    if (subagentToolMessages.length > 0) {
-      console.log(
-        '\nSUCCESS: Subagent was invoked and returned a filtered result.'
-      );
-      console.log(
-        'The child context was isolated — only the final text came back.'
-      );
-    } else {
-      console.log('\nNOTE: No subagent tool calls detected.');
-      console.log('The LLM may have answered directly without delegating.');
-    }
-  }
-
-  console.log('\n=== Done ===');
-}
-
-testSubagentPrimitive().catch(console.error);