@lobehub/chat 1.141.7 → 1.141.9

package/packages/agent-runtime/src/core/UsageCounter.ts

@@ -0,0 +1,248 @@
+import { ModelUsage } from '@lobechat/types';
+
+import { Cost, Usage } from '../types/usage';
+
+/**
+ * UsageCounter - Pure accumulator for usage and cost tracking
+ * Focuses only on usage/cost calculations without managing state
+ */
+/* eslint-disable unicorn/no-static-only-class */
+export class UsageCounter {
+  /**
+   * Create default usage statistics
+   */
+  private static createDefaultUsage(): Usage {
+    return {
+      humanInteraction: {
+        approvalRequests: 0,
+        promptRequests: 0,
+        selectRequests: 0,
+        totalWaitingTimeMs: 0,
+      },
+      llm: {
+        apiCalls: 0,
+        processingTimeMs: 0,
+        tokens: {
+          input: 0,
+          output: 0,
+          total: 0,
+        },
+      },
+      tools: {
+        byTool: [],
+        totalCalls: 0,
+        totalTimeMs: 0,
+      },
+    };
+  }
+
+  /**
+   * Create default cost statistics
+   */
+  private static createDefaultCost(): Cost {
+    return {
+      calculatedAt: new Date().toISOString(),
+      currency: 'USD',
+      llm: {
+        byModel: [],
+        currency: 'USD',
+        total: 0,
+      },
+      tools: {
+        byTool: [],
+        currency: 'USD',
+        total: 0,
+      },
+      total: 0,
+    };
+  }
+
+  /**
+   * Merge two ModelUsage objects by accumulating token counts
+   * @param previous - Previous usage statistics
+   * @param current - Current usage statistics to add
+   * @returns Merged usage statistics
+   */
+  private static mergeModelUsage(
+    previous: ModelUsage | undefined,
+    current: ModelUsage,
+  ): ModelUsage {
+    if (!previous) return current;
+
+    const merged: ModelUsage = { ...current };
+
+    // Accumulate all numeric token fields
+    const numericFields: (keyof ModelUsage)[] = [
+      'inputCachedTokens',
+      'inputCacheMissTokens',
+      'inputWriteCacheTokens',
+      'inputTextTokens',
+      'inputImageTokens',
+      'inputAudioTokens',
+      'inputCitationTokens',
+      'outputTextTokens',
+      'outputImageTokens',
+      'outputAudioTokens',
+      'outputReasoningTokens',
+      'acceptedPredictionTokens',
+      'rejectedPredictionTokens',
+      'totalInputTokens',
+      'totalOutputTokens',
+      'totalTokens',
+    ];
+
+    for (const field of numericFields) {
+      const prevValue = previous[field] as number | undefined;
+      const currValue = current[field] as number | undefined;
+
+      if (prevValue !== undefined || currValue !== undefined) {
+        merged[field] = (prevValue || 0) + (currValue || 0);
+      }
+    }
+
+    // Accumulate cost
+    if (previous.cost !== undefined || current.cost !== undefined) {
+      merged.cost = (previous.cost || 0) + (current.cost || 0);
+    }
+
+    return merged;
+  }
+
+  /**
+   * Accumulate LLM usage and cost for a specific model
+   * @param params - Accumulation parameters
+   * @param params.usage - Current usage statistics (optional, will be created if not provided)
+   * @param params.cost - Current cost statistics (optional, will be created if not provided)
+   * @param params.provider - Provider name (e.g., "openai")
+   * @param params.model - Model name (e.g., "gpt-4")
+   * @param params.modelUsage - ModelUsage from model-runtime
+   * @returns Updated usage and cost
+   */
+  static accumulateLLM(params: {
+    cost?: Cost;
+    model: string;
+    modelUsage: ModelUsage;
+    provider: string;
+    usage?: Usage;
+  }): { cost?: Cost; usage: Usage } {
+    const { usage, cost, provider, model, modelUsage } = params;
+
+    // Ensure usage exists
+    const newUsage = usage ? structuredClone(usage) : this.createDefaultUsage();
+
+    // Accumulate token counts to usage.llm
+    newUsage.llm.tokens.input += modelUsage.totalInputTokens ?? 0;
+    newUsage.llm.tokens.output += modelUsage.totalOutputTokens ?? 0;
+    newUsage.llm.tokens.total += modelUsage.totalTokens ?? 0;
+    newUsage.llm.apiCalls += 1;
+
+    // Ensure cost exists if modelUsage has cost
+    let newCost = cost
+      ? structuredClone(cost)
+      : modelUsage.cost
+        ? this.createDefaultCost()
+        : undefined;
+
+    if (modelUsage.cost && newCost) {
+      const modelId = `${provider}/${model}`;
+
+      // Find or create byModel entry
+      let modelEntry = newCost.llm.byModel.find((entry) => entry.id === modelId);
+
+      if (!modelEntry) {
+        modelEntry = {
+          id: modelId,
+          model,
+          provider,
+          totalCost: 0,
+          usage: {},
+        };
+        newCost.llm.byModel.push(modelEntry);
+      }
+
+      // Merge usage breakdown
+      modelEntry.usage = UsageCounter.mergeModelUsage(modelEntry.usage, modelUsage);
+
+      // Accumulate costs
+      modelEntry.totalCost += modelUsage.cost;
+      newCost.llm.total += modelUsage.cost;
+      newCost.total += modelUsage.cost;
+      newCost.calculatedAt = new Date().toISOString();
+    }
+
+    return { cost: newCost, usage: newUsage };
+  }
+
+  /**
+   * Accumulate tool usage and cost
+   * @param params - Accumulation parameters
+   * @param params.usage - Current usage statistics (optional, will be created if not provided)
+   * @param params.cost - Current cost statistics (optional, will be created if not provided)
+   * @param params.toolName - Tool identifier
+   * @param params.executionTime - Execution time in milliseconds
+   * @param params.success - Whether the execution was successful
+   * @param params.toolCost - Optional cost for this tool call
+   * @returns Updated usage and cost
+   */
+  static accumulateTool(params: {
+    cost?: Cost;
+    executionTime: number;
+    success: boolean;
+    toolCost?: number;
+    toolName: string;
+    usage?: Usage;
+  }): { cost?: Cost; usage: Usage } {
+    const { usage, cost, toolName, executionTime, success, toolCost } = params;
+
+    // Ensure usage exists
+    const newUsage = usage ? structuredClone(usage) : this.createDefaultUsage();
+
+    // Find or create byTool entry
+    let toolEntry = newUsage.tools.byTool.find((entry) => entry.name === toolName);
+
+    if (!toolEntry) {
+      toolEntry = {
+        calls: 0,
+        errors: 0,
+        name: toolName,
+        totalTimeMs: 0,
+      };
+      newUsage.tools.byTool.push(toolEntry);
+    }
+
+    // Accumulate tool usage
+    toolEntry.calls += 1;
+    toolEntry.totalTimeMs += executionTime;
+    if (!success) {
+      toolEntry.errors += 1;
+    }
+
+    newUsage.tools.totalCalls += 1;
+    newUsage.tools.totalTimeMs += executionTime;
+
+    // Ensure cost exists if toolCost is provided
+    let newCost = cost ? structuredClone(cost) : toolCost ? this.createDefaultCost() : undefined;
+
+    if (toolCost && newCost) {
+      let toolCostEntry = newCost.tools.byTool.find((entry) => entry.name === toolName);
+
+      if (!toolCostEntry) {
+        toolCostEntry = {
+          calls: 0,
+          currency: 'USD',
+          name: toolName,
+          totalCost: 0,
+        };
+        newCost.tools.byTool.push(toolCostEntry);
+      }
+
+      toolCostEntry.calls += 1;
+      toolCostEntry.totalCost += toolCost;
+      newCost.tools.total += toolCost;
+      newCost.total += toolCost;
+      newCost.calculatedAt = new Date().toISOString();
+    }
+
+    return { cost: newCost, usage: newUsage };
+  }
+}

package/packages/agent-runtime/src/core/__tests__/InterventionChecker.test.ts

@@ -0,0 +1,334 @@
+import type { HumanInterventionConfig } from '@lobechat/types';
+import { describe, expect, it } from 'vitest';
+
+import { InterventionChecker } from '../InterventionChecker';
+
+describe('InterventionChecker', () => {
+  describe('shouldIntervene', () => {
+    it('should return never when config is undefined', () => {
+      const result = InterventionChecker.shouldIntervene({ config: undefined, toolArgs: {} });
+      expect(result).toBe('never');
+    });
+
+    it('should return the policy when config is a simple string', () => {
+      expect(InterventionChecker.shouldIntervene({ config: 'never', toolArgs: {} })).toBe('never');
+      expect(InterventionChecker.shouldIntervene({ config: 'always', toolArgs: {} })).toBe(
+        'always',
+      );
+      expect(InterventionChecker.shouldIntervene({ config: 'first', toolArgs: {} })).toBe('first');
+    });
+
+    it('should handle "first" policy with confirmed history', () => {
+      const toolKey = 'web-browsing/crawlSinglePage';
+      const confirmedHistory = [toolKey];
+
+      const result = InterventionChecker.shouldIntervene({
+        config: 'first',
+        toolArgs: {},
+        confirmedHistory,
+        toolKey,
+      });
+      expect(result).toBe('never');
+    });
+
+    it('should require intervention for "first" policy without confirmation', () => {
+      const toolKey = 'web-browsing/crawlSinglePage';
+      const confirmedHistory: string[] = [];
+
+      const result = InterventionChecker.shouldIntervene({
+        config: 'first',
+        toolArgs: {},
+        confirmedHistory,
+        toolKey,
+      });
+      expect(result).toBe('first');
+    });
+
+    it('should match rules in order and return first match', () => {
+      const config: HumanInterventionConfig = [
+        { match: { command: 'ls:*' }, policy: 'never' },
+        { match: { command: 'git commit:*' }, policy: 'first' },
+        { policy: 'always' }, // Default rule
+      ];
+
+      expect(InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'ls:' } })).toBe(
+        'never',
+      );
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git commit:' } }),
+      ).toBe('first');
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'rm -rf /' } }),
+      ).toBe('always');
+    });
+
+    it('should return always as default when no rule matches', () => {
+      const config: HumanInterventionConfig = [{ match: { command: 'ls:*' }, policy: 'never' }];
+
+      const result = InterventionChecker.shouldIntervene({
+        config,
+        toolArgs: { command: 'rm -rf /' },
+      });
+      expect(result).toBe('always');
+    });
+
+    it('should handle multiple parameter matching', () => {
+      const config: HumanInterventionConfig = [
+        {
+          match: {
+            command: 'git add:*',
+            path: '/Users/project/*',
+          },
+          policy: 'never',
+        },
+        { policy: 'always' },
+      ];
+
+      // Both match
+      expect(
+        InterventionChecker.shouldIntervene({
+          config,
+          toolArgs: {
+            command: 'git add:.',
+            path: '/Users/project/file.ts',
+          },
+        }),
+      ).toBe('never');
+
+      // Only one matches
+      expect(
+        InterventionChecker.shouldIntervene({
+          config,
+          toolArgs: {
+            command: 'git add:.',
+            path: '/tmp/file.ts',
+          },
+        }),
+      ).toBe('always');
+    });
+
+    it('should handle default rule without match', () => {
+      const config: HumanInterventionConfig = [
+        { match: { command: 'ls:*' }, policy: 'never' },
+        { policy: 'first' }, // Default rule
+      ];
+
+      const result = InterventionChecker.shouldIntervene({
+        config,
+        toolArgs: { command: 'anything' },
+      });
+      expect(result).toBe('first');
+    });
+  });
+
+  describe('matchPattern', () => {
+    it('should match exact strings', () => {
+      expect(InterventionChecker['matchPattern']('hello', 'hello')).toBe(true);
+      expect(InterventionChecker['matchPattern']('hello', 'world')).toBe(false);
+    });
+
+    it('should match wildcard patterns', () => {
+      expect(InterventionChecker['matchPattern']('*.ts', 'file.ts')).toBe(true);
+      expect(InterventionChecker['matchPattern']('*.ts', 'file.js')).toBe(false);
+      expect(InterventionChecker['matchPattern']('test*', 'test123')).toBe(true);
+      expect(InterventionChecker['matchPattern']('test*', 'abc123')).toBe(false);
+    });
+
+    it('should match colon-based prefix patterns', () => {
+      expect(InterventionChecker['matchPattern']('git add:*', 'git add:')).toBe(true);
+      expect(InterventionChecker['matchPattern']('git add:*', 'git add:.')).toBe(true);
+      expect(InterventionChecker['matchPattern']('git add:*', 'git add:--all')).toBe(true);
+      expect(InterventionChecker['matchPattern']('git add:*', 'git commit')).toBe(false);
+    });
+
+    it('should match path patterns', () => {
+      expect(
+        InterventionChecker['matchPattern']('/Users/project/*', '/Users/project/file.ts'),
+      ).toBe(true);
+      expect(InterventionChecker['matchPattern']('/Users/project/*', '/tmp/file.ts')).toBe(false);
+    });
+  });
+
+  describe('matchesArgument', () => {
+    it('should match exact type', () => {
+      const matcher = { pattern: 'git add', type: 'exact' as const };
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add:.')).toBe(false);
+    });
+
+    it('should match prefix type', () => {
+      const matcher = { pattern: 'git add', type: 'prefix' as const };
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add:.')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git commit')).toBe(false);
+    });
+
+    it('should match wildcard type', () => {
+      const matcher = { pattern: 'git *', type: 'wildcard' as const };
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git commit')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'npm install')).toBe(false);
+    });
+
+    it('should match regex type', () => {
+      const matcher = { pattern: '^git (add|commit)', type: 'regex' as const };
+      expect(InterventionChecker['matchesArgument'](matcher, 'git add')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git commit')).toBe(true);
+      expect(InterventionChecker['matchesArgument'](matcher, 'git push')).toBe(false);
+    });
+
+    it('should handle simple string matcher', () => {
+      expect(InterventionChecker['matchesArgument']('git add:*', 'git add:.')).toBe(true);
+      expect(InterventionChecker['matchesArgument']('*.ts', 'file.ts')).toBe(true);
+      expect(InterventionChecker['matchesArgument']('exact', 'exact')).toBe(true);
+    });
+  });
+
+  describe('generateToolKey', () => {
+    it('should generate key without args hash', () => {
+      const key = InterventionChecker.generateToolKey('web-browsing', 'crawlSinglePage');
+      expect(key).toBe('web-browsing/crawlSinglePage');
+    });
+
+    it('should generate key with args hash', () => {
+      const key = InterventionChecker.generateToolKey('bash', 'bash', 'a1b2c3');
+      expect(key).toBe('bash/bash#a1b2c3');
+    });
+  });
+
+  describe('hashArguments', () => {
+    it('should generate consistent hash for same arguments', () => {
+      const args1 = { command: 'ls -la', path: '/tmp' };
+      const args2 = { command: 'ls -la', path: '/tmp' };
+
+      const hash1 = InterventionChecker.hashArguments(args1);
+      const hash2 = InterventionChecker.hashArguments(args2);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('should generate different hash for different arguments', () => {
+      const args1 = { command: 'ls -la' };
+      const args2 = { command: 'ls -l' };
+
+      const hash1 = InterventionChecker.hashArguments(args1);
+      const hash2 = InterventionChecker.hashArguments(args2);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('should handle key order independence', () => {
+      const args1 = { a: 1, b: 2 };
+      const args2 = { b: 2, a: 1 };
+
+      const hash1 = InterventionChecker.hashArguments(args1);
+      const hash2 = InterventionChecker.hashArguments(args2);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('should handle empty arguments', () => {
+      const hash = InterventionChecker.hashArguments({});
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+
+    it('should handle complex nested objects', () => {
+      const args = {
+        config: { nested: { value: 'test' } },
+        array: [1, 2, 3],
+      };
+
+      const hash = InterventionChecker.hashArguments(args);
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+  });
+
+  describe('Integration scenarios', () => {
+    it('should handle Bash tool scenario', () => {
+      const config: HumanInterventionConfig = [
+        { match: { command: 'ls:*' }, policy: 'never' },
+        { match: { command: 'git add:*' }, policy: 'first' },
+        { match: { command: 'git commit:*' }, policy: 'first' },
+        { match: { command: 'rm:*' }, policy: 'always' },
+        { policy: 'always' },
+      ];
+
+      // Safe commands - never
+      expect(InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'ls:' } })).toBe(
+        'never',
+      );
+
+      // Git commands - first
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git add:.' } }),
+      ).toBe('first');
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'git commit:-m' } }),
+      ).toBe('first');
+
+      // Dangerous commands - always
+      expect(InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'rm:-rf' } })).toBe(
+        'always',
+      );
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { command: 'npm install' } }),
+      ).toBe('always');
+    });
+
+    it('should handle LocalSystem tool scenario', () => {
+      const config: HumanInterventionConfig = [
+        { match: { path: '/Users/project/*' }, policy: 'never' },
+        { policy: 'first' },
+      ];
+
+      // Project directory - never
+      expect(
+        InterventionChecker.shouldIntervene({
+          config,
+          toolArgs: { path: '/Users/project/file.ts' },
+        }),
+      ).toBe('never');
+
+      // Outside project - first
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { path: '/tmp/file.ts' } }),
+      ).toBe('first');
+    });
+
+    it('should handle Web Browsing tool with simple policy', () => {
+      const config: HumanInterventionConfig = 'always';
+
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: { url: 'https://example.com' } }),
+      ).toBe('always');
+    });
+
+    it('should handle first policy with confirmation history', () => {
+      const config: HumanInterventionConfig = [
+        { match: { command: 'git add:*' }, policy: 'first' },
+        { policy: 'always' },
+      ];
+
+      const toolKey = 'bash/bash#abc123';
+      const args = { command: 'git add:.' };
+
+      // First time - requires intervention
+      expect(
+        InterventionChecker.shouldIntervene({
+          config,
+          toolArgs: args,
+          confirmedHistory: [],
+          toolKey,
+        }),
+      ).toBe('first');
+
+      // After confirmation - never
+      const confirmedHistory = [toolKey];
+      expect(
+        InterventionChecker.shouldIntervene({ config, toolArgs: args, confirmedHistory, toolKey }),
+      ).toBe('never');
+    });
+  });
+});