@lobehub/chat 1.141.8 → 1.141.10

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

@@ -369,7 +369,7 @@ describe('AgentRuntime', () => {
           type: 'tool_pending',
         });
 
-        expect(result.newState.status).toBe('waiting_for_human_input');
+        expect(result.newState.status).toBe('waiting_for_human');
         expect(result.newState.pendingToolsCalling).toBeDefined();
       });
 
@@ -396,7 +396,7 @@ describe('AgentRuntime', () => {
           sessionId: 'test-session',
         });
 
-        expect(result.newState.status).toBe('waiting_for_human_input');
+        expect(result.newState.status).toBe('waiting_for_human');
         expect(result.newState.pendingHumanPrompt).toEqual({
           prompt: 'Please provide input',
           metadata: { key: 'value' },
@@ -434,7 +434,7 @@ describe('AgentRuntime', () => {
           sessionId: 'test-session',
         });
 
-        expect(result.newState.status).toBe('waiting_for_human_input');
+        expect(result.newState.status).toBe('waiting_for_human');
       });
     });
 
@@ -733,7 +733,7 @@ describe('AgentRuntime', () => {
         },
         tools: {
           totalCalls: 0,
-          byTool: {},
+          byTool: [],
           totalTimeMs: 0,
         },
         humanInteraction: {
@@ -746,12 +746,12 @@ describe('AgentRuntime', () => {
 
       expect(state.cost).toMatchObject({
         llm: {
-          byModel: {},
+          byModel: [],
           total: 0,
           currency: 'USD',
         },
         tools: {
-          byTool: {},
+          byTool: [],
           total: 0,
           currency: 'USD',
         },
@@ -890,8 +890,8 @@ describe('AgentRuntime', () => {
 
         calculateCost(context: CostCalculationContext): Cost {
           return {
-            llm: { byModel: {}, total: 15.0, currency: 'USD' },
-            tools: { byTool: {}, total: 0, currency: 'USD' },
+            llm: { byModel: [], total: 15.0, currency: 'USD' },
+            tools: { byTool: [], total: 0, currency: 'USD' },
             total: 15.0,
             currency: 'USD',
             calculatedAt: new Date().toISOString(),
@@ -1018,7 +1018,7 @@ describe('AgentRuntime', () => {
       result = await runtime.step(result.newState, result.nextContext);
 
       // Now should request human approval
-      expect(result.newState.status).toBe('waiting_for_human_input');
+      expect(result.newState.status).toBe('waiting_for_human');
       expect(result.newState.pendingToolsCalling).toHaveLength(1);
 
       // Step 2: Approve and execute tool call
@@ -1210,7 +1210,7 @@ describe('AgentRuntime', () => {
       expect(agent.tools.safe_tool).toHaveBeenCalled();
 
       // Should be in waiting state (blocked by approval request)
-      expect(result.newState.status).toBe('waiting_for_human_input');
+      expect(result.newState.status).toBe('waiting_for_human');
 
       // Should have pending tool calls
       expect(result.newState.pendingToolsCalling).toHaveLength(1);
@@ -1333,8 +1333,8 @@ describe('AgentRuntime', () => {
           return {
             calculatedAt: new Date().toISOString(),
             currency: 'USD',
-            llm: { byModel: {}, currency: 'USD', total: 15.0 },
-            tools: { byTool: {}, currency: 'USD', total: 0 },
+            llm: { byModel: [], currency: 'USD', total: 15.0 },
+            tools: { byTool: [], currency: 'USD', total: 0 },
             total: 15.0,
           };
         }
@@ -1396,8 +1396,8 @@ describe('AgentRuntime', () => {
           return {
             calculatedAt: new Date().toISOString(),
             currency: 'USD',
-            llm: { byModel: {}, currency: 'USD', total: 0 },
-            tools: { byTool: {}, currency: 'USD', total: 20.0 },
+            llm: { byModel: [], currency: 'USD', total: 0 },
+            tools: { byTool: [], currency: 'USD', total: 20.0 },
             total: 20.0,
           };
         }
@@ -1438,8 +1438,8 @@ describe('AgentRuntime', () => {
           const baseCost = context.previousCost || {
             calculatedAt: new Date().toISOString(),
             currency: 'USD',
-            llm: { byModel: {}, currency: 'USD', total: 0 },
-            tools: { byTool: {}, currency: 'USD', total: 0 },
+            llm: { byModel: [], currency: 'USD', total: 0 },
+            tools: { byTool: [], currency: 'USD', total: 0 },
             total: 0,
           };
 
@@ -1447,7 +1447,7 @@ describe('AgentRuntime', () => {
             ...baseCost,
             calculatedAt: new Date().toISOString(),
             tools: {
-              byTool: {},
+              byTool: [],
               currency: 'USD',
               total: baseCost.tools.total + 5.0,
             },
@@ -1514,15 +1514,17 @@ describe('AgentRuntime', () => {
             newUsage.tools.totalCalls += 1;
             newUsage.tools.totalTimeMs += 100;
 
-            if (newUsage.tools.byTool[toolName]) {
-              newUsage.tools.byTool[toolName].calls += 1;
-              newUsage.tools.byTool[toolName].totalTimeMs += 100;
+            const existingTool = newUsage.tools.byTool.find((t) => t.name === toolName);
+            if (existingTool) {
+              existingTool.calls += 1;
+              existingTool.totalTimeMs += 100;
             } else {
-              newUsage.tools.byTool[toolName] = {
+              newUsage.tools.byTool.push({
                 calls: 1,
                 errors: 0,
+                name: toolName,
                 totalTimeMs: 100,
-              };
+              });
             }
 
             return newUsage;
@@ -1567,10 +1569,14 @@ describe('AgentRuntime', () => {
 
       // Should have per-tool statistics
       expect(result.newState.usage.tools.totalCalls).toBe(2);
-      expect(result.newState.usage.tools.byTool.analytics_tool).toBeDefined();
-      expect(result.newState.usage.tools.byTool.analytics_tool.calls).toBe(1);
-      expect(result.newState.usage.tools.byTool.logging_tool).toBeDefined();
-      expect(result.newState.usage.tools.byTool.logging_tool.calls).toBe(1);
+      const analyticsTool = result.newState.usage.tools.byTool.find(
+        (t) => t.name === 'analytics_tool',
+      );
+      const loggingTool = result.newState.usage.tools.byTool.find((t) => t.name === 'logging_tool');
+      expect(analyticsTool).toBeDefined();
+      expect(analyticsTool!.calls).toBe(1);
+      expect(loggingTool).toBeDefined();
+      expect(loggingTool!.calls).toBe(1);
     });
   });
 });

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

@@ -1 +1,3 @@
+export * from './InterventionChecker';
 export * from './runtime';
+export * from './UsageCounter';

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

@@ -120,10 +120,7 @@ export class AgentRuntime {
         }
 
         // Stop execution if blocked
-        if (
-          currentState.status === 'waiting_for_human_input' ||
-          currentState.status === 'interrupted'
-        ) {
+        if (currentState.status === 'waiting_for_human' || currentState.status === 'interrupted') {
           break;
         }
       }
@@ -273,7 +270,7 @@ export class AgentRuntime {
         tokens: { input: 0, output: 0, total: 0 },
       },
       tools: {
-        byTool: {},
+        byTool: [],
         totalCalls: 0,
         totalTimeMs: 0,
       },
@@ -290,12 +287,12 @@ export class AgentRuntime {
       calculatedAt: now,
       currency: 'USD',
       llm: {
-        byModel: {},
+        byModel: [],
         currency: 'USD',
         total: 0,
       },
       tools: {
-        byTool: {},
+        byTool: [],
         currency: 'USD',
         total: 0,
       },
@@ -308,7 +305,9 @@ export class AgentRuntime {
    * @param partialState - Partial state to override defaults
    * @returns Complete AgentState with defaults filled in
    */
-  static createInitialState(partialState: Partial<AgentState> & { sessionId: string }): AgentState {
+  static createInitialState(
+    partialState?: Partial<AgentState> & { sessionId: string },
+  ): AgentState {
     const now = new Date().toISOString();
 
     return {
@@ -319,9 +318,10 @@ export class AgentRuntime {
       messages: [],
       status: 'idle',
       stepCount: 0,
+      toolManifestMap: {},
       usage: AgentRuntime.createDefaultUsage(),
       // User provided values override defaults
-      ...partialState,
+      ...(partialState || { sessionId: '' }),
     };
   }
 
@@ -489,7 +489,7 @@ export class AgentRuntime {
       const newState = structuredClone(state);
 
       newState.lastModified = new Date().toISOString();
-      newState.status = 'waiting_for_human_input';
+      newState.status = 'waiting_for_human';
       newState.pendingToolsCalling = pendingToolsCalling;
 
       const events: AgentEvent[] = [
@@ -515,7 +515,7 @@ export class AgentRuntime {
       const newState = structuredClone(state);
 
       newState.lastModified = new Date().toISOString();
-      newState.status = 'waiting_for_human_input';
+      newState.status = 'waiting_for_human';
       newState.pendingHumanPrompt = { metadata, prompt };
 
       const events: AgentEvent[] = [
@@ -541,7 +541,7 @@ export class AgentRuntime {
       const newState = structuredClone(state);
 
       newState.lastModified = new Date().toISOString();
-      newState.status = 'waiting_for_human_input';
+      newState.status = 'waiting_for_human';
       newState.pendingHumanSelect = { metadata, multi, options, prompt };
 
       const events: AgentEvent[] = [
@@ -641,13 +641,15 @@ export class AgentRuntime {
         newState.usage.tools.totalCalls += result.newState.usage.tools.totalCalls;
         newState.usage.tools.totalTimeMs += result.newState.usage.tools.totalTimeMs;
 
-        // Merge per-tool statistics
-        Object.entries(result.newState.usage.tools.byTool).forEach(([tool, stats]) => {
-          if (newState.usage.tools.byTool[tool]) {
-            newState.usage.tools.byTool[tool].calls += stats.calls;
-            newState.usage.tools.byTool[tool].totalTimeMs += stats.totalTimeMs;
+        // Merge per-tool statistics (now using array)
+        result.newState.usage.tools.byTool.forEach((toolStats) => {
+          const existingTool = newState.usage.tools.byTool.find((t) => t.name === toolStats.name);
+          if (existingTool) {
+            existingTool.calls += toolStats.calls;
+            existingTool.totalTimeMs += toolStats.totalTimeMs;
+            existingTool.errors += toolStats.errors || 0;
           } else {
-            newState.usage.tools.byTool[tool] = { ...stats };
+            newState.usage.tools.byTool.push({ ...toolStats });
           }
         });
       }
@@ -656,6 +658,17 @@ export class AgentRuntime {
       if (result.newState.cost && newState.cost) {
         newState.cost.tools.total += result.newState.cost.tools.total;
         newState.cost.total += result.newState.cost.tools.total;
+
+        // Merge per-tool cost statistics (now using array)
+        result.newState.cost.tools.byTool.forEach((toolCost) => {
+          const existingToolCost = newState.cost.tools.byTool.find((t) => t.name === toolCost.name);
+          if (existingToolCost) {
+            existingToolCost.calls += toolCost.calls;
+            existingToolCost.totalCost += toolCost.totalCost;
+          } else {
+            newState.cost.tools.byTool.push({ ...toolCost });
+          }
+        });
       }
     }
 

package/packages/agent-runtime/src/types/instruction.ts

@@ -29,7 +29,7 @@ export interface AgentRuntimeContext {
     stepCount: number;
   };
   /** Usage statistics from the current step (if applicable) */
-  stepUsage?: ModelUsage;
+  stepUsage?: ModelUsage | unknown;
 }
 
 /**

package/packages/agent-runtime/src/types/state.ts

@@ -8,13 +8,13 @@ import type { Cost, CostLimit, Usage } from './usage';
 export interface AgentState {
   sessionId: string;
   // --- State Machine ---
-  status: 'idle' | 'running' | 'waiting_for_human_input' | 'done' | 'error' | 'interrupted';
+  status: 'idle' | 'running' | 'waiting_for_human' | 'done' | 'error' | 'interrupted';
 
   // --- Core Context ---
   messages: any[];
   tools?: any[];
   systemRole?: string;
-
+  toolManifestMap: Record<string, any>;
   // --- Execution Tracking ---
   /**
    * Number of execution steps in this session.
@@ -46,7 +46,7 @@ export interface AgentState {
 
   // --- HIL ---
   /**
-   * When status is 'waiting_for_human_input', this stores pending requests
+   * When status is 'waiting_for_human', this stores pending requests
    * for human-in-the-loop operations.
    */
   pendingToolsCalling?: ToolsCalling[];

package/packages/agent-runtime/src/types/usage.ts

@@ -1,3 +1,5 @@
+import { ModelUsage } from '@lobechat/types';
+
 /**
  * Token usage tracking for different types of operations
  */
@@ -39,14 +41,16 @@ export interface Usage {
   /** Tool usage statistics */
   tools: {
     /** Usage breakdown by tool name */
-    byTool: Record<
-      string,
-      {
-        calls: number;
-        errors: number;
-        totalTimeMs: number;
-      }
-    >;
+    byTool: Array<{
+      /** Number of calls */
+      calls: number;
+      /** Number of errors */
+      errors: number;
+      /** Tool name/identifier */
+      name: string;
+      /** Total execution time in milliseconds */
+      totalTimeMs: number;
+    }>;
     /** Number of tool calls executed */
     totalCalls: number;
     /** Total tool execution time */
@@ -66,15 +70,18 @@ export interface Cost {
   /** LLM API costs */
   llm: {
     /** Cost per model used */
-    byModel: Record<
-      string,
-      {
-        currency: string;
-        inputTokens: number;
-        outputTokens: number;
-        totalCost: number;
-      }
-    >;
+    byModel: Array<{
+      /** Model identifier in format "provider/model" */
+      id: string;
+      /** Model name */
+      model: string;
+      /** Provider name */
+      provider: string;
+      /** Total cost for this model */
+      totalCost: number;
+      /** Detailed usage breakdown */
+      usage: ModelUsage;
+    }>;
     currency: string;
     /** Total LLM cost */
     total: number;
@@ -82,14 +89,16 @@ export interface Cost {
   /** Tool execution costs */
   tools: {
     /** Cost per tool (if tool has associated costs) */
-    byTool: Record<
-      string,
-      {
-        calls: number;
-        currency: string;
-        totalCost: number;
-      }
-    >;
+    byTool: Array<{
+      /** Number of calls */
+      calls: number;
+      /** Currency */
+      currency: string;
+      /** Tool name/identifier */
+      name: string;
+      /** Total cost for this tool */
+      totalCost: number;
+    }>;
     currency: string;
     /** Total tool cost */
     total: number;

package/packages/context-engine/src/index.ts

@@ -32,6 +32,7 @@ export {
 export type {
   FunctionCallChecker,
   GenerateToolsParams,
+  LobeToolManifest,
   PluginEnableChecker,
   ToolNameGenerator,
   ToolsEngineOptions,

package/packages/context-engine/src/tools/ToolNameResolver.ts

@@ -1,7 +1,7 @@
 import { ChatToolPayload, MessageToolCall } from '@lobechat/types';
 import { Md5 } from 'ts-md5';
 
-import { LobeChatPluginApi, LobeChatPluginManifest } from './types';
+import { LobeChatPluginApi, LobeToolManifest } from './types';
 
 // Tool naming constants
 const PLUGIN_SCHEMA_SEPARATOR = '____';
@@ -57,7 +57,7 @@ export class ToolNameResolver {
    */
   resolve(
     toolCalls: MessageToolCall[],
-    manifests: Record<string, LobeChatPluginManifest>,
+    manifests: Record<string, LobeToolManifest>,
   ): ChatToolPayload[] {
     return toolCalls
       .map((toolCall): ChatToolPayload | null => {

package/packages/context-engine/src/tools/ToolsEngine.ts

@@ -3,7 +3,7 @@ import debug from 'debug';
 import {
   FunctionCallChecker,
   GenerateToolsParams,
-  LobeChatPluginManifest,
+  LobeToolManifest,
   PluginEnableChecker,
   ToolsEngineOptions,
   ToolsGenerationContext,
@@ -18,7 +18,7 @@ const log = debug('context-engine:tools-engine');
  * Tools Engine - Unified processing of tools array construction and transformation
  */
 export class ToolsEngine {
-  private manifestSchemas: Map<string, LobeChatPluginManifest>;
+  private manifestSchemas: Map<string, LobeToolManifest>;
   private enableChecker?: PluginEnableChecker;
   private functionCallChecker?: FunctionCallChecker;
   private defaultToolIds: string[];
@@ -162,13 +162,13 @@ export class ToolsEngine {
     context?: ToolsGenerationContext,
     supportsFunctionCall?: boolean,
   ): {
-    enabledManifests: LobeChatPluginManifest[];
+    enabledManifests: LobeToolManifest[];
     filteredPlugins: Array<{
       id: string;
       reason: 'not_found' | 'disabled' | 'incompatible';
     }>;
   } {
-    const enabledManifests: LobeChatPluginManifest[] = [];
+    const enabledManifests: LobeToolManifest[] = [];
     const filteredPlugins: Array<{
       id: string;
       reason: 'not_found' | 'disabled' | 'incompatible';
@@ -240,7 +240,7 @@ export class ToolsEngine {
   /**
    * Convert manifests to UniformTool array
    */
-  private convertManifestsToTools(manifests: LobeChatPluginManifest[]): UniformTool[] {
+  private convertManifestsToTools(manifests: LobeToolManifest[]): UniformTool[] {
     log('Converting %d manifests to tools', manifests.length);
 
     // Use simplified conversion logic to avoid external package dependencies
@@ -290,14 +290,14 @@ export class ToolsEngine {
   /**
    * 获取插件的 manifest
    */
-  getPluginManifest(pluginId: string): LobeChatPluginManifest | undefined {
+  getPluginManifest(pluginId: string): LobeToolManifest | undefined {
     return this.manifestSchemas.get(pluginId);
   }
 
   /**
    * 更新插件 manifest schemas（用于动态添加插件）
    */
-  updateManifestSchemas(manifestSchemas: LobeChatPluginManifest[]): void {
+  updateManifestSchemas(manifestSchemas: LobeToolManifest[]): void {
     this.manifestSchemas.clear();
     for (const schema of manifestSchemas) {
       this.manifestSchemas.set(schema.identifier, schema);
@@ -307,7 +307,7 @@ export class ToolsEngine {
   /**
    * 添加单个插件 manifest
    */
-  addPluginManifest(manifest: LobeChatPluginManifest): void {
+  addPluginManifest(manifest: LobeToolManifest): void {
     this.manifestSchemas.set(manifest.identifier, manifest);
   }
 
@@ -317,4 +317,33 @@ export class ToolsEngine {
   removePluginManifest(pluginId: string): boolean {
     return this.manifestSchemas.delete(pluginId);
   }
+
+  /**
+   * 获取所有 enabled plugin 的 Manifest Map
+   */
+  getEnabledPluginManifests(toolIds: string[] = []): Map<string, LobeToolManifest> {
+    // Merge user-provided tool IDs with default tool IDs
+    const allToolIds = [...toolIds, ...this.defaultToolIds];
+
+    log('Getting enabled plugin manifests for pluginIds=%o', allToolIds);
+
+    const manifestMap = new Map<string, LobeToolManifest>();
+
+    for (const pluginId of allToolIds) {
+      const manifest = this.manifestSchemas.get(pluginId);
+      if (manifest) {
+        manifestMap.set(pluginId, manifest);
+      }
+    }
+
+    log('Returning %d enabled plugin manifests', manifestMap.size);
+    return manifestMap;
+  }
+
+  /**
+   * 获取所有插件的 Manifest Map
+   */
+  getAllPluginManifests(): Map<string, LobeToolManifest> {
+    return new Map(this.manifestSchemas);
+  }
 }