@librechat/agents 3.1.85 → 3.1.87

package/src/agents/AgentContext.ts

@@ -758,8 +758,13 @@ export class AgentContext {
       return messages.length;
     }
 
-    if (messages[lastIndex].getType() === 'human') {
-      return lastIndex;
+    for (let index = lastIndex; index >= 0; index--) {
+      if (messages[index].getType() === 'human') {
+        if (promptCacheProvider === Providers.OPENROUTER && index === 0) {
+          return 1;
+        }
+        return index;
+      }
     }
 
     return messages.length;

package/src/agents/__tests__/AgentContext.test.ts

@@ -368,7 +368,7 @@ describe('AgentContext', () => {
       expect(result[4].content).toBe('Latest');
     });
 
-    it('does not place Anthropic dynamic instructions between tool calls and results', async () => {
+    it('keeps Anthropic dynamic instructions attached to the latest user turn during tool follow-up', async () => {
       const ctx = createBasicContext({
         agentConfig: {
           provider: Providers.ANTHROPIC,
@@ -401,10 +401,115 @@ describe('AgentContext', () => {
         }),
       ]);
 
-      expect(result[1].content).toBe('Use the tool');
-      expect((result[2] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
-      expect(result[3].getType()).toBe('tool');
-      expect(result[4].content).toBe('Dynamic instructions');
+      expect(result[1].content).toBe('Dynamic instructions');
+      expect(result[2].content).toBe('Use the tool');
+      expect((result[3] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[4].getType()).toBe('tool');
+    });
+
+    it('keeps Anthropic stable history cacheable before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.ANTHROPIC,
+          clientOptions: {
+            model: 'claude-3-5-sonnet',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Earlier'),
+        new AIMessage('Earlier assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+      const stableAssistant = result[2].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('Earlier');
+      expect(stableAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'Earlier assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Dynamic instructions');
+      expect(result[4].content).toBe('Use the tool');
+      expect((result[5] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[6].getType()).toBe('tool');
+    });
+
+    it('keeps Anthropic dynamic context on latest no-tool turn after mixed prior turns', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.ANTHROPIC,
+          clientOptions: {
+            model: 'claude-3-5-sonnet',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('First turn, no tools'),
+        new AIMessage('First assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+        new AIMessage('4'),
+        new HumanMessage('Now answer without tools'),
+      ]);
+      const firstAssistant = result[2].content as TestSystemContentBlock[];
+      const toolAnswer = result[6].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('First turn, no tools');
+      expect(firstAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'First assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Use the tool');
+      expect((result[4] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[5].getType()).toBe('tool');
+      expect(toolAnswer[0]).toMatchObject({
+        type: 'text',
+        text: '4',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[7].content).toBe('Dynamic instructions');
+      expect(result[8].content).toBe('Now answer without tools');
     });
 
     it('caches stable OpenRouter history before dynamic instructions', async () => {
@@ -437,6 +542,150 @@ describe('AgentContext', () => {
       expect(result[4].content).toBe('Latest');
     });
 
+    it('keeps OpenRouter opening user message before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+
+      expect(result[1].content).toBe('Use the tool');
+      expect(result[2].content).toBe('Dynamic instructions');
+      expect((result[3] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[4].getType()).toBe('tool');
+    });
+
+    it('keeps OpenRouter stable history cacheable before dynamic tool-follow-up context', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('Earlier'),
+        new AIMessage('Earlier assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+      ]);
+      const stableAssistant = result[2].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('Earlier');
+      expect(stableAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'Earlier assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Dynamic instructions');
+      expect(result[4].content).toBe('Use the tool');
+      expect((result[5] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[6].getType()).toBe('tool');
+    });
+
+    it('keeps OpenRouter dynamic context on latest no-tool turn after mixed prior turns', async () => {
+      const ctx = createBasicContext({
+        agentConfig: {
+          provider: Providers.OPENROUTER,
+          clientOptions: {
+            model: 'anthropic/claude-haiku-4.5',
+            promptCache: true,
+          },
+          instructions: 'Stable instructions',
+          additional_instructions: 'Dynamic instructions',
+        },
+      });
+
+      const result = await ctx.systemRunnable!.invoke([
+        new HumanMessage('First turn, no tools'),
+        new AIMessage('First assistant response'),
+        new HumanMessage('Use the tool'),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            {
+              id: 'call_1',
+              name: 'calculator',
+              args: { expression: '2+2' },
+              type: 'tool_call',
+            },
+          ],
+        }),
+        new ToolMessage({
+          content: '4',
+          name: 'calculator',
+          tool_call_id: 'call_1',
+        }),
+        new AIMessage('4'),
+        new HumanMessage('Now answer without tools'),
+      ]);
+      const firstAssistant = result[2].content as TestSystemContentBlock[];
+      const toolAnswer = result[6].content as TestSystemContentBlock[];
+
+      expect(result[1].content).toBe('First turn, no tools');
+      expect(firstAssistant[0]).toMatchObject({
+        type: 'text',
+        text: 'First assistant response',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[3].content).toBe('Use the tool');
+      expect((result[4] as AIMessage).tool_calls?.[0]?.id).toBe('call_1');
+      expect(result[5].getType()).toBe('tool');
+      expect(toolAnswer[0]).toMatchObject({
+        type: 'text',
+        text: '4',
+        cache_control: { type: 'ephemeral' },
+      });
+      expect(result[7].content).toBe('Dynamic instructions');
+      expect(result[8].content).toBe('Now answer without tools');
+    });
+
     it('adds OpenRouter body cache points when there is no dynamic tail', async () => {
       const ctx = createBasicContext({
         agentConfig: {

package/src/events.ts

@@ -21,6 +21,35 @@ export class HandlerRegistry {
   }
 }
 
+export function composeEventHandlers(
+  ...handlerSets: Array<Record<string, t.EventHandler> | undefined>
+): Record<string, t.EventHandler> {
+  const composed: Partial<Record<string, t.EventHandler>> = {};
+
+  for (const handlerSet of handlerSets) {
+    if (!handlerSet) {
+      continue;
+    }
+    for (const [eventType, handler] of Object.entries(handlerSet)) {
+      const previous = composed[eventType];
+      if (previous === undefined) {
+        composed[eventType] = handler;
+        continue;
+      }
+      composed[eventType] = {
+        handle: async (
+          ...args: Parameters<t.EventHandler['handle']>
+        ): Promise<void> => {
+          await previous.handle(...args);
+          await handler.handle(...args);
+        },
+      };
+    }
+  }
+
+  return composed as Record<string, t.EventHandler>;
+}
+
 export class ModelEndHandler implements t.EventHandler {
   collectedUsage?: UsageMetadata[];
   constructor(collectedUsage?: UsageMetadata[]) {