@lobehub/lobehub 2.0.0-next.84 → 2.0.0-next.86

package/src/store/chat/agents/__tests__/createAgentExecutors/fixtures/mockOperations.ts

@@ -0,0 +1,96 @@
+import { nanoid } from '@lobechat/utils';
+
+import type { Operation, OperationType } from '@/store/chat/slices/operation/types';
+
+/**
+ * Create a mock Operation object for testing
+ */
+export const createMockOperation = (
+  type: OperationType,
+  context: Record<string, any> = {},
+  overrides: Partial<Operation> = {},
+): Operation => {
+  return {
+    abortController: new AbortController(),
+    childOperationIds: [],
+    context,
+    id: `op_${nanoid()}`,
+    metadata: {
+      startTime: Date.now(),
+    },
+    status: 'running',
+    type,
+    ...overrides,
+  };
+};
+
+/**
+ * Create a cancelled operation
+ */
+export const createCancelledOperation = (
+  type: OperationType,
+  context: Record<string, any> = {},
+): Operation => {
+  const operation = createMockOperation(type, context, { status: 'cancelled' });
+  operation.abortController.abort();
+  operation.metadata.cancelReason = 'Test cancellation';
+  return operation;
+};
+
+/**
+ * Create a completed operation
+ */
+export const createCompletedOperation = (
+  type: OperationType,
+  context: Record<string, any> = {},
+): Operation => {
+  return createMockOperation(type, context, {
+    metadata: {
+      duration: 1000,
+      endTime: Date.now(),
+      startTime: Date.now() - 1000,
+    },
+    status: 'completed',
+  });
+};
+
+/**
+ * Create a failed operation
+ */
+export const createFailedOperation = (
+  type: OperationType,
+  context: Record<string, any> = {},
+  // eslint-disable-next-line unicorn/no-object-as-default-parameter
+  error: { message: string; type: string } = { message: 'Test error', type: 'TestError' },
+): Operation => {
+  return createMockOperation(type, context, {
+    metadata: {
+      duration: 1000,
+      endTime: Date.now(),
+      error,
+      startTime: Date.now() - 1000,
+    },
+    status: 'failed',
+  });
+};
+
+/**
+ * Create an operation tree (parent with children)
+ */
+export const createOperationTree = (
+  parentType: OperationType,
+  childTypes: OperationType[],
+  context: Record<string, any> = {},
+) => {
+  const parent = createMockOperation(parentType, context);
+
+  const children = childTypes.map((childType) =>
+    createMockOperation(childType, context, {
+      parentOperationId: parent.id,
+    }),
+  );
+
+  parent.childOperationIds = children.map((c) => c.id);
+
+  return { children, parent };
+};

package/src/store/chat/agents/__tests__/createAgentExecutors/fixtures/mockStore.ts

@@ -0,0 +1,138 @@
+import { nanoid } from '@lobechat/utils';
+import { vi } from 'vitest';
+
+import type { ChatStore } from '@/store/chat/store';
+
+/**
+ * Create a mock ChatStore for testing executors
+ * All methods are mocked with vi.fn() and can be customized
+ */
+export const createMockStore = (overrides: Partial<ChatStore> = {}): ChatStore => {
+  const operations: Record<string, any> = {};
+  const messageOperationMap: Record<string, string> = {};
+  const operationsByMessage: Record<string, string[]> = {};
+  const dbMessagesMap: Record<string, any[]> = {};
+
+  const store = {
+    // Other store properties (add as needed)
+    activeId: 'test-session',
+
+    activeTopicId: 'test-topic',
+
+    associateMessageWithOperation: vi.fn().mockImplementation((messageId, operationId) => {
+      messageOperationMap[messageId] = operationId;
+
+      if (!operationsByMessage[messageId]) {
+        operationsByMessage[messageId] = [];
+      }
+      if (!operationsByMessage[messageId].includes(operationId)) {
+        operationsByMessage[messageId].push(operationId);
+      }
+    }),
+
+    cancelOperation: vi.fn().mockImplementation((operationId) => {
+      if (operations[operationId]) {
+        operations[operationId].abortController.abort();
+        operations[operationId].status = 'cancelled';
+      }
+    }),
+
+    completeOperation: vi.fn().mockImplementation((operationId) => {
+      if (operations[operationId]) {
+        operations[operationId].status = 'completed';
+        operations[operationId].metadata.endTime = Date.now();
+      }
+    }),
+
+    // Message state
+    dbMessagesMap,
+
+    failOperation: vi.fn().mockImplementation((operationId, error) => {
+      if (operations[operationId]) {
+        operations[operationId].status = 'failed';
+        operations[operationId].metadata.error = error;
+        operations[operationId].metadata.endTime = Date.now();
+      }
+    }),
+
+    // AI chat methods
+    internal_fetchAIChatMessage: vi.fn().mockResolvedValue(undefined),
+
+    internal_invokeDifferentTypePlugin: vi.fn().mockResolvedValue({ error: null }),
+
+    messageOperationMap,
+
+    onOperationCancel: vi.fn(),
+
+    // Operation state
+    operations,
+
+    operationsByContext: {},
+
+    operationsByMessage,
+
+    operationsByType: {} as any,
+
+    optimisticAddToolToAssistantMessage: vi.fn().mockResolvedValue(undefined),
+
+    // Message management methods
+    optimisticCreateMessage: vi.fn().mockImplementation(async (params) => {
+      const id = nanoid();
+      const message = { id, ...params, createdAt: Date.now(), updatedAt: Date.now() };
+      return message;
+    }),
+
+    optimisticUpdateMessageContent: vi.fn().mockResolvedValue(undefined),
+
+    optimisticUpdateMessagePlugin: vi.fn().mockResolvedValue(undefined),
+
+    optimisticUpdateMessagePluginError: vi.fn().mockResolvedValue(undefined),
+
+    optimisticUpdatePluginArguments: vi.fn().mockResolvedValue(undefined),
+
+    optimisticUpdatePluginState: vi.fn().mockResolvedValue(undefined),
+
+    // Operation management methods
+    startOperation: vi.fn().mockImplementation((config) => {
+      const operationId = `op_${nanoid()}`;
+      const abortController = new AbortController();
+
+      const operation = {
+        abortController,
+        childOperationIds: [],
+        context: config.context || {},
+        id: operationId,
+        metadata: config.metadata || { startTime: Date.now() },
+        parentOperationId: config.parentOperationId,
+        status: 'running',
+        type: config.type,
+      };
+
+      operations[operationId] = operation;
+
+      // Auto-associate message with operation if messageId exists
+      if (config.context?.messageId) {
+        messageOperationMap[config.context.messageId] = operationId;
+
+        if (!operationsByMessage[config.context.messageId]) {
+          operationsByMessage[config.context.messageId] = [];
+        }
+        operationsByMessage[config.context.messageId].push(operationId);
+      }
+
+      return { abortController, operationId };
+    }),
+    updateOperationMetadata: vi.fn().mockImplementation((operationId, metadata) => {
+      if (operations[operationId]) {
+        operations[operationId].metadata = {
+          ...operations[operationId].metadata,
+          ...metadata,
+        };
+      }
+    }),
+
+    ...overrides,
+  } as unknown as ChatStore;
+
+  return store;
+};

package/src/store/chat/agents/__tests__/createAgentExecutors/helpers/assertions.ts

@@ -0,0 +1,185 @@
+import { expect } from 'vitest';
+
+import type { OperationType } from '@/store/chat/slices/operation/types';
+import type { ChatStore } from '@/store/chat/store';
+
+/**
+ * Assert that an operation was created with specific type
+ */
+export const expectOperationCreated = (mockStore: ChatStore, type: OperationType) => {
+  expect(mockStore.startOperation).toHaveBeenCalledWith(
+    expect.objectContaining({
+      type,
+    }),
+  );
+};
+
+/**
+ * Assert that a message was created with specific role
+ */
+export const expectMessageCreated = (mockStore: ChatStore, role: 'assistant' | 'tool' | 'user') => {
+  expect(mockStore.optimisticCreateMessage).toHaveBeenCalledWith(
+    expect.objectContaining({
+      role,
+    }),
+  );
+};
+
+/**
+ * Assert that a cancel handler was registered
+ */
+export const expectCancelHandlerRegistered = (mockStore: ChatStore, operationId?: string) => {
+  if (operationId) {
+    expect(mockStore.onOperationCancel).toHaveBeenCalledWith(operationId, expect.any(Function));
+  } else {
+    expect(mockStore.onOperationCancel).toHaveBeenCalled();
+  }
+};
+
+/**
+ * Assert that an operation was completed
+ */
+export const expectOperationCompleted = (mockStore: ChatStore, operationId: string) => {
+  expect(mockStore.completeOperation).toHaveBeenCalledWith(operationId);
+};
+
+/**
+ * Assert that an operation was failed
+ */
+export const expectOperationFailed = (
+  mockStore: ChatStore,
+  operationId: string,
+  errorType?: string,
+) => {
+  if (errorType) {
+    expect(mockStore.failOperation).toHaveBeenCalledWith(
+      operationId,
+      expect.objectContaining({
+        type: errorType,
+      }),
+    );
+  } else {
+    expect(mockStore.failOperation).toHaveBeenCalledWith(operationId, expect.any(Object));
+  }
+};
+
+/**
+ * Assert that message content was updated
+ */
+export const expectMessageContentUpdated = (
+  mockStore: ChatStore,
+  messageId: string,
+  content?: string,
+) => {
+  if (content) {
+    expect(mockStore.optimisticUpdateMessageContent).toHaveBeenCalledWith(
+      messageId,
+      content,
+      expect.anything(),
+      expect.anything(),
+    );
+  } else {
+    expect(mockStore.optimisticUpdateMessageContent).toHaveBeenCalledWith(
+      messageId,
+      expect.any(String),
+      expect.anything(),
+      expect.anything(),
+    );
+  }
+};
+
+/**
+ * Assert that message plugin was updated
+ */
+export const expectMessagePluginUpdated = (
+  mockStore: ChatStore,
+  messageId: string,
+  interventionStatus?: string,
+) => {
+  if (interventionStatus) {
+    expect(mockStore.optimisticUpdateMessagePlugin).toHaveBeenCalledWith(
+      messageId,
+      expect.objectContaining({
+        intervention: expect.objectContaining({
+          status: interventionStatus,
+        }),
+      }),
+      expect.anything(),
+    );
+  } else {
+    expect(mockStore.optimisticUpdateMessagePlugin).toHaveBeenCalled();
+  }
+};
+
+/**
+ * Assert that internal_fetchAIChatMessage was called with correct params
+ */
+export const expectFetchAIChatMessageCalled = (mockStore: ChatStore, messageId?: string) => {
+  if (messageId) {
+    expect(mockStore.internal_fetchAIChatMessage).toHaveBeenCalledWith(
+      messageId,
+      expect.anything(),
+    );
+  } else {
+    expect(mockStore.internal_fetchAIChatMessage).toHaveBeenCalled();
+  }
+};
+
+/**
+ * Assert that internal_invokeDifferentTypePlugin was called
+ */
+export const expectInvokePluginCalled = (mockStore: ChatStore, messageId?: string) => {
+  if (messageId) {
+    expect(mockStore.internal_invokeDifferentTypePlugin).toHaveBeenCalledWith(
+      messageId,
+      expect.anything(),
+    );
+  } else {
+    expect(mockStore.internal_invokeDifferentTypePlugin).toHaveBeenCalled();
+  }
+};
+
+/**
+ * Assert that operation metadata was updated
+ */
+export const expectOperationMetadataUpdated = (
+  mockStore: ChatStore,
+  operationId: string,
+  metadata?: Record<string, any>,
+) => {
+  if (metadata) {
+    expect(mockStore.updateOperationMetadata).toHaveBeenCalledWith(
+      operationId,
+      expect.objectContaining(metadata),
+    );
+  } else {
+    expect(mockStore.updateOperationMetadata).toHaveBeenCalledWith(operationId, expect.any(Object));
+  }
+};
+
+/**
+ * Assert executor result structure
+ */
+export const expectValidExecutorResult = (result: any) => {
+  expect(result).toHaveProperty('events');
+  expect(result).toHaveProperty('newState');
+  expect(Array.isArray(result.events)).toBe(true);
+  expect(result.newState).toBeDefined();
+};
+
+/**
+ * Assert executor returned specific event type
+ */
+export const expectEventType = (result: any, eventType: string) => {
+  expect(result.events.some((e: any) => e.type === eventType)).toBe(true);
+};
+
+/**
+ * Assert executor returned next context
+ */
+export const expectNextContext = (result: any, phase?: string) => {
+  expect(result.nextContext).toBeDefined();
+  if (phase) {
+    expect(result.nextContext.phase).toBe(phase);
+  }
+};

package/src/store/chat/agents/__tests__/createAgentExecutors/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from './assertions';
+export * from './operationTestUtils';
+export * from './testExecutor';

package/src/store/chat/agents/__tests__/createAgentExecutors/helpers/operationTestUtils.ts

@@ -0,0 +1,94 @@
+import type { Operation } from '@/store/chat/slices/operation/types';
+
+/**
+ * Simulate operation cancellation
+ */
+export const simulateOperationCancellation = (
+  operation: Operation,
+  reason: string = 'Test cancellation',
+) => {
+  operation.abortController.abort();
+  operation.status = 'cancelled';
+  if (operation.metadata) {
+    operation.metadata.cancelReason = reason;
+  }
+};
+
+/**
+ * Simulate cascading cancellation through operation tree
+ */
+export const simulateCascadingCancellation = (
+  parentOperation: Operation,
+  childOperations: Operation[],
+  reason: string = 'Parent operation cancelled',
+) => {
+  simulateOperationCancellation(parentOperation, reason);
+  childOperations.forEach((child) => simulateOperationCancellation(child, reason));
+};
+
+/**
+ * Wait for operation status change
+ */
+export const waitForOperationStatus = async (
+  getOperation: () => Operation | undefined,
+  targetStatus: Operation['status'],
+  timeout: number = 1000,
+): Promise<boolean> => {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const operation = getOperation();
+    if (operation?.status === targetStatus) {
+      return true;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 10);
+    });
+  }
+  return false;
+};
+
+/**
+ * Verify operation tree structure
+ */
+export const verifyOperationTree = (parent: Operation, expectedChildIds: string[]): boolean => {
+  if (!parent.childOperationIds) return false;
+  if (parent.childOperationIds.length !== expectedChildIds.length) return false;
+  return expectedChildIds.every((id) => parent.childOperationIds!.includes(id));
+};
+
+/**
+ * Get all operations in a tree (parent + all descendants)
+ */
+export const getAllOperationsInTree = (
+  operations: Record<string, Operation>,
+  rootOperationId: string,
+): Operation[] => {
+  const result: Operation[] = [];
+  const visited = new Set<string>();
+
+  const traverse = (operationId: string) => {
+    if (visited.has(operationId)) return;
+    visited.add(operationId);
+
+    const operation = operations[operationId];
+    if (!operation) return;
+
+    result.push(operation);
+
+    if (operation.childOperationIds) {
+      operation.childOperationIds.forEach(traverse);
+    }
+  };
+
+  traverse(rootOperationId);
+  return result;
+};
+
+/**
+ * Create AbortSignal that aborts after delay
+ */
+export const createDelayedAbortSignal = (delayMs: number): AbortSignal => {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), delayMs);
+  return controller.signal;
+};

package/src/store/chat/agents/__tests__/createAgentExecutors/helpers/testExecutor.ts

@@ -0,0 +1,139 @@
+import type {
+  AgentInstruction,
+  AgentState,
+} from '@lobechat/agent-runtime';
+
+import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
+import type { OperationType } from '@/store/chat/slices/operation/types';
+import type { ChatStore } from '@/store/chat/store';
+
+/**
+ * Execute an executor with mock context
+ *
+ * @example
+ * const result = await executeWithMockContext({
+ *   executor: 'call_llm',
+ *   instruction: createCallLLMInstruction(),
+ *   state: createInitialState(),
+ *   mockStore,
+ *   context: { operationId: 'op_123', messageKey: 'session_topic', parentId: 'msg_456' }
+ * });
+ */
+export const executeWithMockContext = async ({
+  executor,
+  instruction,
+  state,
+  mockStore,
+  context,
+  skipCreateFirstMessage = false,
+}: {
+  context: {
+    messageKey: string;
+    operationId: string;
+    parentId: string;
+    sessionId?: string;
+    topicId?: string | null;
+  };
+  executor: AgentInstruction['type'];
+  instruction: AgentInstruction;
+  mockStore: ChatStore;
+  skipCreateFirstMessage?: boolean;
+  state: AgentState;
+}) => {
+  // Ensure operation exists in store
+  if (!mockStore.operations[context.operationId]) {
+    mockStore.operations[context.operationId] = {
+      abortController: new AbortController(),
+      childOperationIds: [],
+      context: {
+        messageId: context.parentId,
+        sessionId: context.sessionId || 'test-session',
+        topicId: context.topicId !== undefined ? context.topicId : 'test-topic',
+      },
+      id: context.operationId,
+      metadata: { startTime: Date.now() },
+      status: 'running',
+      type: 'execAgentRuntime' as OperationType,
+    };
+  }
+
+  // Create executors with mock context
+  const executors = createAgentExecutors({
+    get: () => mockStore,
+    messageKey: context.messageKey,
+    operationId: context.operationId,
+    parentId: context.parentId,
+    skipCreateFirstMessage,
+  });
+
+  const executorFn = executors[executor];
+  if (!executorFn) {
+    throw new Error(`Executor ${executor} not found`);
+  }
+
+  // Execute
+  const result = await executorFn(instruction, state);
+
+  return result;
+};
+
+/**
+ * Create initial agent runtime state for testing
+ */
+export const createInitialState = (overrides: Partial<AgentState> = {}): AgentState => {
+  const defaultState: any = {
+    lastModified: new Date().toISOString(),
+    messages: [],
+    sessionId: 'test-session',
+    status: 'running',
+    stepCount: 1,
+    usage: {
+      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,
+      },
+    },
+  };
+
+  return {
+    ...defaultState,
+    ...overrides,
+  } as AgentState;
+};
+
+/**
+ * Create a test context object for executor
+ */
+export const createTestContext = (
+  overrides: {
+    messageKey?: string;
+    operationId?: string;
+    parentId?: string;
+    sessionId?: string;
+    topicId?: string | null;
+  } = {},
+) => {
+  return {
+    messageKey:
+      overrides.messageKey ||
+      `${overrides.sessionId || 'test-session'}_${overrides.topicId !== undefined ? overrides.topicId : 'test-topic'}`,
+    operationId: overrides.operationId || 'op_test',
+    parentId: overrides.parentId || 'msg_parent',
+  };
+};