@librechat/agents 3.4.2 → 3.4.4

package/src/specs/activity-phase-label.test.ts

@@ -0,0 +1,306 @@
+import { AIMessage, HumanMessage } from '@langchain/core/messages';
+import { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT } from '@/langfuseToolOutputTracing';
+import { Providers } from '@/common';
+import { Run } from '@/run';
+
+const invoke = jest.fn();
+
+jest.mock('@/llm/init', () => ({
+  initializeModel: jest.fn(() => ({ invoke })),
+}));
+
+async function createRun(): Promise<Run<never>> {
+  return Run.create({
+    runId: 'phase-run',
+    graphConfig: {
+      type: 'standard',
+      agents: [
+        {
+          agentId: 'agent-1',
+          name: 'Phase Agent',
+          provider: Providers.OPENAI,
+          clientOptions: { model: 'gpt-4.1-mini' },
+          tools: [],
+        },
+      ],
+    },
+  });
+}
+
+describe('generateActivityPhaseLabel', () => {
+  beforeEach(() => {
+    invoke.mockReset();
+    invoke.mockResolvedValue(
+      new AIMessage('"Fixed session refresh handling and verified auth tests."')
+    );
+  });
+
+  it('does not spend a model call on one logical activity', async () => {
+    const run = await createRun();
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [{ label: 'Inspected session refresh middleware' }],
+      })
+    ).resolves.toEqual({});
+    expect(invoke).not.toHaveBeenCalled();
+  });
+
+  it('summarizes two activities and normalizes the persisted row', async () => {
+    const run = await createRun();
+    if (run.Graph != null) {
+      run.Graph.messages = [
+        new HumanMessage({
+          content: [
+            {
+              type: 'input_text',
+              text: 'Why is session refresh failing?',
+            } as never,
+          ],
+        }),
+        new HumanMessage({
+          content: 'Internal routing instructions',
+          additional_kwargs: {
+            role: 'user',
+            isMeta: true,
+            source: 'routing',
+          },
+        }),
+      ];
+    }
+    const handleChainStart = jest.fn();
+    const handleChainEnd = jest.fn();
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [
+          { label: 'Inspected session refresh middleware' },
+          { label: 'Fixed refresh token validation' },
+        ],
+        assistantContext: ['I am checking the auth path.'],
+        closingTextPhase: 'final_answer',
+        chainOptions: {
+          callbacks: [{ handleChainStart, handleChainEnd }],
+          configurable: {
+            requestBody: { parentMessageId: 'parent-message-1' },
+          },
+        },
+      })
+    ).resolves.toEqual({
+      label: 'Fixed session refresh handling and verified auth tests',
+    });
+    expect(invoke).toHaveBeenCalledTimes(1);
+    const messages = invoke.mock.calls[0][0] as AIMessage[];
+    expect(String(messages[1].content)).toContain(
+      'Inspected session refresh middleware'
+    );
+    expect(String(messages[1].content)).toContain(
+      'Fixed refresh token validation'
+    );
+    expect(String(messages[1].content)).not.toContain(
+      'Why is session refresh failing?'
+    );
+    const modelConfig = invoke.mock.calls[0][1] as {
+      callbacks?: { getParentRunId?: () => string | undefined };
+      tags?: string[];
+      metadata?: Record<string, unknown>;
+    };
+    expect(modelConfig.callbacks?.getParentRunId?.()).toEqual(
+      expect.any(String)
+    );
+    expect(modelConfig.tags).toEqual(
+      expect.arrayContaining(['activity-phase', 'agent'])
+    );
+    expect(modelConfig.metadata).toEqual(
+      expect.objectContaining({
+        agentId: 'agent-1',
+        agentName: 'Phase Agent',
+        parentMessageId: 'parent-message-1',
+      })
+    );
+    expect(handleChainStart.mock.calls[0]?.[1]).toEqual(
+      expect.objectContaining({
+        messages: expect.arrayContaining([
+          expect.objectContaining({
+            content: 'Why is session refresh failing?',
+          }),
+        ]),
+      })
+    );
+    expect(JSON.stringify(handleChainStart.mock.calls[0]?.[1])).not.toContain(
+      'Internal routing instructions'
+    );
+    expect(handleChainEnd.mock.calls[0]?.[0]).toEqual(
+      expect.objectContaining({
+        messages: expect.arrayContaining([
+          expect.objectContaining({
+            content: 'Fixed session refresh handling and verified auth tests',
+          }),
+        ]),
+      })
+    );
+  });
+
+  it('does not call the model when retained activities have no evidence', async () => {
+    const run = await createRun();
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [
+          ...Array.from({ length: 12 }, () => ({ status: 'success' as const })),
+          { label: 'Evidence beyond the prompt cap' },
+        ],
+      })
+    ).resolves.toEqual({});
+    expect(invoke).not.toHaveBeenCalled();
+  });
+
+  it('preserves the phase parent when retrying without a failing callback', async () => {
+    invoke.mockRejectedValueOnce(new Error('event stream callback failed'));
+    const run = await createRun();
+
+    await expect(
+      run.generateActivityPhaseLabel({
+        provider: Providers.OPENAI,
+        activities: [
+          { label: 'Inspected session refresh middleware' },
+          { label: 'Fixed refresh token validation' },
+        ],
+        chainOptions: {
+          callbacks: [{ handleChainStart: jest.fn() }],
+        },
+      })
+    ).resolves.toEqual({
+      label: 'Fixed session refresh handling and verified auth tests',
+    });
+
+    expect(invoke).toHaveBeenCalledTimes(2);
+    const firstCallbacks = invoke.mock.calls[0][1].callbacks as {
+      getParentRunId: () => string | undefined;
+      handlers: unknown[];
+    };
+    const retryCallbacks = invoke.mock.calls[1][1].callbacks as {
+      getParentRunId: () => string | undefined;
+      handlers: unknown[];
+    };
+    expect(firstCallbacks.getParentRunId()).toEqual(expect.any(String));
+    expect(retryCallbacks.getParentRunId()).toBe(
+      firstCallbacks.getParentRunId()
+    );
+    expect(retryCallbacks.handlers).toHaveLength(0);
+  });
+
+  it('applies every agent redaction policy when any activity is unattributed', async () => {
+    const run = await Run.create({
+      runId: 'mixed-attribution-phase-run',
+      graphConfig: {
+        type: 'multi-agent',
+        agents: [
+          {
+            agentId: 'agent-1',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+          },
+          {
+            agentId: 'agent-2',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+            langfuse: {
+              toolOutputTracing: { redactedToolNames: ['secret_tool'] },
+            },
+          },
+        ],
+        edges: [],
+      },
+    });
+
+    await run.generateActivityPhaseLabel({
+      provider: Providers.OPENAI,
+      activities: [
+        { agentId: 'agent-1', label: 'Inspected public session behavior' },
+        {
+          entries: [
+            {
+              toolName: 'secret_tool',
+              toolInput: { key: 'public-key' },
+              toolOutput: 'STRICT_AGENT_SECRET',
+              status: 'success',
+            },
+          ],
+        },
+      ],
+    });
+
+    const messages = invoke.mock.calls[0][0] as AIMessage[];
+    expect(String(messages[1].content)).not.toContain('STRICT_AGENT_SECRET');
+    expect(String(messages[1].content)).toContain(
+      LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT
+    );
+  });
+
+  it('applies every policy when omitted activities have no complete agent list', async () => {
+    const run = await Run.create({
+      runId: 'omitted-attribution-phase-run',
+      graphConfig: {
+        type: 'multi-agent',
+        agents: [
+          {
+            agentId: 'agent-1',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+          },
+          {
+            agentId: 'agent-2',
+            provider: Providers.OPENAI,
+            clientOptions: { model: 'gpt-4.1-mini' },
+            tools: [],
+            langfuse: {
+              toolOutputTracing: { redactedToolNames: ['secret_tool'] },
+            },
+          },
+        ],
+        edges: [],
+      },
+    });
+
+    await run.generateActivityPhaseLabel({
+      provider: Providers.OPENAI,
+      activities: [
+        {
+          agentId: 'agent-1',
+          entries: [
+            {
+              toolName: 'public_lookup',
+              toolInput: { id: 'one' },
+              toolOutput: 'public-one',
+              status: 'success',
+            },
+          ],
+        },
+        {
+          agentId: 'agent-1',
+          entries: [
+            {
+              toolName: 'public_lookup',
+              toolInput: { id: 'two' },
+              toolOutput: 'public-two',
+              status: 'success',
+            },
+          ],
+        },
+      ],
+      totalActivityCount: 3,
+      assistantContext: ['OMITTED_AGENT_SECRET'],
+    });
+
+    const messages = invoke.mock.calls[0][0] as AIMessage[];
+    expect(String(messages[1].content)).not.toContain('OMITTED_AGENT_SECRET');
+    expect(String(messages[1].content)).toContain('public-one');
+  });
+});

package/src/stream.ts

@@ -3,8 +3,19 @@ import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { ChatOpenAIReasoningSummary } from '@langchain/openai';
 import type { AIMessageChunk } from '@langchain/core/messages';
 import type { AgentContext } from '@/agents/AgentContext';
+import type { RunBreakerScope } from '@/llm/streamLimits';
 import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
+import {
+  claimStreamLimitCharge,
+  combineCompleteToolCalls,
+  enforceCompleteToolCallArgLimit,
+  enforceStreamedToolCallArgLimit,
+  enforceStreamDeltaEventLimit,
+  requiresStreamLimitAccounting,
+  StreamLimitExceededError,
+  STREAM_LIMIT_EPOCH_KEY,
+} from '@/llm/streamLimits';
 import {
   getStreamedToolCallSeal,
   getStreamedToolCallAdapter,
@@ -21,6 +32,10 @@ import {
   CODE_EXECUTION_TOOLS,
   LOCAL_CODING_BUNDLE_NAMES,
 } from '@/common';
+import {
+  getMessageCreationContentMetadata,
+  splitAssistantTextContentByPhase,
+} from '@/messages/assistantPhase';
 import {
   buildToolExecutionRequestPlan,
   coerceRecordArgs,
@@ -39,17 +54,6 @@ import {
   calculateMaxToolResultChars,
   truncateToolResultContent,
 } from '@/utils/truncation';
-import type { RunBreakerScope } from '@/llm/streamLimits';
-import {
-  claimStreamLimitCharge,
-  combineCompleteToolCalls,
-  enforceCompleteToolCallArgLimit,
-  enforceStreamedToolCallArgLimit,
-  enforceStreamDeltaEventLimit,
-  requiresStreamLimitAccounting,
-  StreamLimitExceededError,
-  STREAM_LIMIT_EPOCH_KEY,
-} from '@/llm/streamLimits';
 import { resolveToolOutcome, outcomeFieldsFromResult } from '@/tools/intentArg';
 import { TOOL_OUTPUT_REF_PATTERN } from '@/tools/toolOutputReferences';
 import { safeDispatchCustomEvent } from '@/utils/events';
@@ -521,10 +525,14 @@ function shouldStartFreshMessageStepAfterGoogleServerSideTool({
 async function dispatchMessageCreationStep({
   graph,
   stepKey,
+  content,
+  contentType,
   metadata,
 }: {
   graph: StandardGraph;
   stepKey: string;
+  content?: string | t.MessageContentComplex[];
+  contentType?: ContentTypes.TEXT | ContentTypes.THINK;
   metadata?: Record<string, unknown>;
 }): Promise<string> {
   const messageId = getMessageId(stepKey, graph, true) ?? '';
@@ -534,6 +542,7 @@ async function dispatchMessageCreationStep({
       type: StepTypes.MESSAGE_CREATION,
       message_creation: {
         message_id: messageId,
+        ...getMessageCreationContentMetadata(content, contentType),
       },
     },
     metadata
@@ -555,6 +564,7 @@ async function dispatchMessageContentParts({
     const currentStepId = await dispatchMessageCreationStep({
       graph,
       stepKey,
+      content: [contentPart],
       metadata,
     });
     if (isGoogleServerSideToolContentPart(contentPart)) {
@@ -587,6 +597,8 @@ async function dispatchReasoningContentParts({
   const currentStepId = await dispatchMessageCreationStep({
     graph,
     stepKey,
+    content,
+    contentType: ContentTypes.THINK,
     metadata,
   });
   await graph.dispatchReasoningDelta(
@@ -1811,14 +1823,53 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
+    if (Array.isArray(content) && content.every(isTextContentPart)) {
+      const contentGroups = splitAssistantTextContentByPhase(content);
+      const currentStepId = graph.stepKeyIds?.get(stepKey)?.at(-1);
+      const currentStep =
+        currentStepId == null ? undefined : graph.getRunStep(currentStepId);
+      const currentPhase =
+        currentStep?.stepDetails.type === StepTypes.MESSAGE_CREATION
+          ? currentStep.stepDetails.message_creation.phase
+          : undefined;
+      const nextPhase = getMessageCreationContentMetadata(
+        contentGroups[0]
+      ).phase;
+      const phaseChanged =
+        currentPhase != null &&
+        nextPhase != null &&
+        currentPhase !== nextPhase;
+      if (contentGroups.length > 1 || phaseChanged) {
+        for (const contentGroup of contentGroups) {
+          const currentStepId = await dispatchMessageCreationStep({
+            graph,
+            stepKey,
+            content: contentGroup,
+            metadata,
+          });
+          await graph.dispatchMessageDelta(
+            currentStepId,
+            { content: contentGroup },
+            metadata
+          );
+        }
+        return;
+      }
+    }
+
     const message_id = getMessageId(stepKey, graph) ?? '';
     if (message_id) {
+      const fallbackContentType =
+        agentContext.currentTokenType === ContentTypes.TEXT
+          ? ContentTypes.TEXT
+          : ContentTypes.THINK;
       await graph.dispatchRunStep(
         stepKey,
         {
           type: StepTypes.MESSAGE_CREATION,
           message_creation: {
             message_id,
+            ...getMessageCreationContentMetadata(content, fallbackContentType),
           },
         },
         metadata
@@ -1835,7 +1886,12 @@ export class ChatModelStreamHandler implements t.EventHandler {
         content,
       })
     ) {
-      stepId = await dispatchMessageCreationStep({ graph, stepKey, metadata });
+      stepId = await dispatchMessageCreationStep({
+        graph,
+        stepKey,
+        content,
+        metadata,
+      });
       runStep = graph.getRunStep(stepId);
     }
     if (!runStep) {
@@ -1906,6 +1962,7 @@ hasToolCallChunks: ${hasToolCallChunks}
               type: StepTypes.MESSAGE_CREATION,
               message_creation: {
                 message_id,
+                content_type: ContentTypes.TEXT,
               },
             },
             metadata