@wabot-dev/framework 0.9.27 → 0.9.80

package/dist/src/testing/chatBotHarness.js

@@ -0,0 +1,88 @@
+import { Auth } from '../core/auth/Auth.js';
+import { container } from '../core/injection/index.js';
+import { ChatAdapter } from '../feature/chat-bot/ChatAdapter.js';
+import '../feature/chat-bot/ChatAdapterRegistry.js';
+import { ChatBot } from '../feature/chat-bot/ChatBot.js';
+import { ChatMemory } from '../feature/chat-bot/ChatMemory.js';
+import '../feature/chat-bot/ChatOperator.js';
+import '../feature/chat-bot/UnionChatAdapter.js';
+import '../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import '../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../core/error/setupErrorHandlers.js';
+import '../feature/mindset/metadata/MindsetMetadataStore.js';
+import { Mindset } from '../feature/mindset/IMindset.js';
+import { MindsetOperator } from '../feature/mindset/MindsetOperator.js';
+import { humanMessage } from './fixtures.js';
+import { MockChatAdapter } from './MockChatAdapter.js';
+import { TestChatMemory } from './TestChatMemory.js';
+import { Container } from '../core/injection/Container.js';
+
+/**
+ * Runs a real ChatBot (real MindsetOperator, system prompt, tool loop and
+ * argument validation) against an in-RAM memory and a pluggable adapter.
+ */
+class ChatBotHarness {
+    adapter;
+    memory = new TestChatMemory();
+    container;
+    chatBot;
+    operator;
+    constructor(options) {
+        this.adapter = options.adapter ?? new MockChatAdapter();
+        const child = container.createChildContainer();
+        child.register(Container, { useValue: child });
+        child.register(Mindset, { useClass: options.mindset });
+        child.registerInstance(ChatMemory, this.memory);
+        child.registerInstance(ChatAdapter, this.adapter);
+        for (const [token, instance] of options.register ?? []) {
+            child.registerInstance(token, instance);
+        }
+        if (options.authInfo) {
+            const auth = child.resolve(Auth);
+            auth.assign(options.authInfo);
+        }
+        this.container = child;
+        this.chatBot = child.resolve(ChatBot);
+        this.operator = child.resolve(MindsetOperator);
+    }
+    /** Send a human message and collect everything the bot did in response. */
+    async send(message) {
+        const itemsBefore = this.memory.all().length;
+        const replies = [];
+        await this.chatBot.sendMessage(humanMessage(message), async (reply) => {
+            replies.push(reply);
+        });
+        const items = this.memory.allData().slice(itemsBefore);
+        const toolCalls = items
+            .filter((item) => item.type === 'functionCall')
+            .map((item) => item.functionCall);
+        return { replies, toolCalls, items };
+    }
+    /**
+     * Execute a single mindset tool directly (real argument validation and
+     * module resolution), without scripting a whole conversation.
+     * Returns the string result exactly as the LLM would receive it.
+     */
+    async callTool(name, args = {}) {
+        const argsJson = typeof args === 'string' ? args : JSON.stringify(args);
+        return await this.operator.callFunction(name, argsJson);
+    }
+    /** Full chat history (data form) accumulated across turns. */
+    history() {
+        return this.memory.allData();
+    }
+    /** The real system prompt the mindset produces. */
+    async systemPrompt() {
+        return await this.operator.systemPrompt();
+    }
+    /** The real tool definitions derived from the mindset modules. */
+    tools() {
+        return this.operator.tools();
+    }
+}
+function createChatBotHarness(options) {
+    return new ChatBotHarness(options);
+}
+
+export { ChatBotHarness, createChatBotHarness };

package/dist/src/testing/chatControllerHarness.js

@@ -0,0 +1,94 @@
+import { InMemoryLocker } from '../addon/lock/InMemoryLocker.js';
+import { container } from '../core/injection/index.js';
+import { Locker } from '../core/lock/Locker.js';
+import { ChatAdapter } from '../feature/chat-bot/ChatAdapter.js';
+import '../feature/chat-bot/ChatAdapterRegistry.js';
+import '../feature/chat-bot/ChatBot.js';
+import '../feature/chat-bot/ChatOperator.js';
+import { ChatRepository } from '../feature/chat-bot/ChatRepository.js';
+import '../feature/chat-bot/UnionChatAdapter.js';
+import '../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import '../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../core/error/setupErrorHandlers.js';
+import '../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import { ChatResolver } from '../feature/chat-controller/ChatResolver.js';
+import { prepareChatContainer } from '../feature/chat-controller/runChatControllers.js';
+import { humanMessage } from './fixtures.js';
+import { MockChatAdapter } from './MockChatAdapter.js';
+import { TestChatRepository } from './TestChatMemory.js';
+import { Container } from '../core/injection/Container.js';
+
+/**
+ * Drives a @chatController end-to-end without a real channel: resolves the
+ * Chat, prepares the per-message container (same code path as production,
+ * including @chatBot injection) and invokes the controller method.
+ */
+class ChatControllerHarness {
+    adapter;
+    chatRepository = new TestChatRepository();
+    chatConnection;
+    channelContainer;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.adapter = options.adapter ?? new MockChatAdapter();
+        this.chatConnection = options.chatConnection ?? {
+            chatType: 'PRIVATE',
+            channelName: 'TestChannel',
+            id: 'test-chat',
+        };
+        const child = container.createChildContainer();
+        child.register(Container, { useValue: child });
+        child.register(Locker, { useToken: InMemoryLocker });
+        child.registerInstance(ChatRepository, this.chatRepository);
+        child.registerInstance(ChatAdapter, this.adapter);
+        for (const [token, instance] of options.register ?? []) {
+            child.registerInstance(token, instance);
+        }
+        this.channelContainer = child;
+    }
+    /** Deliver a message to a controller method, as if it came from a channel. */
+    async invoke(methodName, message) {
+        const controllerCtor = this.options.controller;
+        if (typeof controllerCtor.prototype[methodName] !== 'function') {
+            throw new Error(`ChatControllerHarness: ${controllerCtor.name} has no method '${methodName}'`);
+        }
+        const chatResolver = this.channelContainer.resolve(ChatResolver);
+        const chat = await chatResolver.resolve(this.chatConnection);
+        const memory = await this.chatRepository.findMemory(chat.id);
+        const itemsBefore = memory ? memory.all().length : 0;
+        const replies = [];
+        const receivedMessage = {
+            message: humanMessage(message),
+            reply: async (reply) => {
+                replies.push(reply);
+            },
+        };
+        const chatContainer = await prepareChatContainer(this.channelContainer, {
+            chat,
+            authInfo: this.options.authInfo,
+            ...receivedMessage,
+        });
+        const controller = chatContainer.resolve(controllerCtor);
+        await controller[methodName](receivedMessage);
+        const items = (await this.history()).slice(itemsBefore);
+        const toolCalls = items
+            .filter((item) => item.type === 'functionCall')
+            .map((item) => item.functionCall);
+        return { replies, toolCalls, items };
+    }
+    /** Full chat history (data form) of the harness conversation. */
+    async history() {
+        const chat = await this.chatRepository.findByConnection(this.chatConnection);
+        if (!chat)
+            return [];
+        const memory = await this.chatRepository.findMemory(chat.id);
+        return memory ? memory.allData() : [];
+    }
+}
+function createChatControllerHarness(options) {
+    return new ChatControllerHarness(options);
+}
+
+export { ChatControllerHarness, createChatControllerHarness };