@wabot-dev/framework 0.9.27 → 2.0.0-beta.0

package/dist/src/index.js

@@ -84,7 +84,7 @@ export { stripAnsweredMedia } from './feature/chat-bot/stripAnsweredMedia.js';
 export { chatController } from './feature/chat-controller/metadata/controller/@chatController.js';
 export { ControllerMetadataStore } from './feature/chat-controller/metadata/ControllerMetadataStore.js';
 export { ChatResolver } from './feature/chat-controller/ChatResolver.js';
-export { runChatControllers } from './feature/chat-controller/runChatControllers.js';
+export { prepareChatContainer, runChatControllers } from './feature/chat-controller/runChatControllers.js';
 export { ExpressProvider } from './feature/express/ExpressProvider.js';
 export { HttpServerProvider } from './feature/http/HttpServerProvider.js';
 export { mindset } from './feature/mindset/metadata/mindsets/@mindset.js';
@@ -120,7 +120,7 @@ export { onPut } from './feature/rest-controller/metadata/@onPut.js';
 export { onDelete } from './feature/rest-controller/metadata/@onDelete.js';
 export { restController } from './feature/rest-controller/metadata/@restController.js';
 export { RestControllerMetadataStore } from './feature/rest-controller/metadata/RestControllerMetadataStore.js';
-export { runRestControllers } from './feature/rest-controller/runRestControllers.js';
+export { registerRestControllers, runRestControllers } from './feature/rest-controller/runRestControllers.js';
 export { EXPRESS_REQ, EXPRESS_RES } from './feature/rest-controller/injection-tokens.js';
 export { RestRequest } from './feature/rest-controller/RestRequest.js';
 export { SocketServerConfig } from './feature/socket/SocketServerConfig.js';
@@ -130,6 +130,20 @@ export { socketController } from './feature/socket-controller/metadata/@socketCo
 export { onSocketEvent } from './feature/socket-controller/metadata/@onSocketEvent.js';
 export { SocketControllerMetadataStore } from './feature/socket-controller/metadata/SocketControllerMetadataStore.js';
 export { runSocketControllers } from './feature/socket-controller/runSocketControllers.js';
+export { uiController } from './feature/ui-controller/metadata/@uiController.js';
+export { view } from './feature/ui-controller/metadata/@view.js';
+export { action } from './feature/ui-controller/metadata/@action.js';
+export { uiMiddleware } from './feature/ui-controller/metadata/@uiMiddleware.js';
+export { UiControllerMetadataStore } from './feature/ui-controller/metadata/UiControllerMetadataStore.js';
+export { UiRendererRegistry } from './feature/ui-controller/renderer/UiRendererRegistry.js';
+export { ISLAND_MARKER, getIslandMeta, isIsland, island, setIslandId } from './feature/ui-controller/island/island.js';
+export { deserializeProps, serializeProps } from './feature/ui-controller/island/serialize.js';
+export { ISLAND_FILE_PATTERN, IslandRegistry, isIslandFile, toIslandId } from './feature/ui-controller/island/IslandRegistry.js';
+export { renderDocument } from './feature/ui-controller/document/renderDocument.js';
+export { REDIRECT_MARKER, isRedirect, redirect } from './feature/ui-controller/document/helpers.js';
+export { escapeAttr, escapeHtml } from './feature/ui-controller/document/escape.js';
+export { actionUrl, callAction } from './feature/ui-controller/actions.js';
+export { registerUiControllers, runUiControllers } from './feature/ui-controller/runUiControllers.js';
 export { PgCronJobRepository } from './addon/async/pg/PgCronJobRepository.js';
 export { PgJobRepository } from './addon/async/pg/PgJobRepository.js';
 export { PgTransactionAdapter } from './addon/async/pg/PgTransactionAdapter.js';
@@ -165,6 +179,7 @@ export { PgChatMemory } from './addon/chat-bot/pg/PgChatMemory.js';
 export { InMemoryChatMemory } from './addon/chat-bot/in-memory/InMemoryChatMemory.js';
 export { InMemoryChatRepository } from './addon/chat-bot/in-memory/InMemoryChatRepository.js';
 export { WabotChatAdapter } from './addon/chat-bot/wabot/WabotChatAdapter.js';
+export { XAIChatAdapter } from './addon/chat-bot/xai/XAIChatAdapter.js';
 export { cmd } from './addon/chat-controller/cmd/@cmd.js';
 export { CmdChannel, readJsonFromFile, writeJsonToFile } from './addon/chat-controller/cmd/CmdChannel.js';
 export { CmdChannelConfig } from './addon/chat-controller/cmd/CmdChannelConfig.js';
@@ -172,6 +187,21 @@ export { CmdChannelServer } from './addon/chat-controller/cmd/CmdChannelServer.j
 export { cmdChannelName } from './addon/chat-controller/cmd/cmdChannelName.js';
 export { cmdChannelSocketPath } from './addon/chat-controller/cmd/cmdChannelSocketPath.js';
 export { runCmdClient } from './addon/chat-controller/cmd/runCmdClient.js';
+export { hubspotChannelName } from './addon/chat-controller/hubspot/hubspotChannelName.js';
+export { HubSpotChannelConfig } from './addon/chat-controller/hubspot/HubSpotChannelConfig.js';
+export { verifyHubSpotSignatureV3 } from './addon/chat-controller/hubspot/verifyHubSpotSignatureV3.js';
+export { downloadHubSpotAttachments } from './addon/chat-controller/hubspot/downloadHubSpotAttachments.js';
+export { HubSpotSender } from './addon/chat-controller/hubspot/HubSpotSender.js';
+export { HubSpotWebhookController } from './addon/chat-controller/hubspot/HubSpotWebhookController.js';
+export { HubSpotReceiver } from './addon/chat-controller/hubspot/HubSpotReceiver.js';
+export { HubSpotChannel } from './addon/chat-controller/hubspot/HubSpotChannel.js';
+export { markdownToChatHtml as markdownToHubSpotHtml, markdownToChatHtml as markdownToTelegramHtml } from './addon/chat-controller/markdown/markdownToChatHtml.js';
+export { hubspot } from './addon/chat-controller/hubspot/@hubspot.js';
+export { slack } from './addon/chat-controller/slack/@slack.js';
+export { SlackChannelConfig } from './addon/chat-controller/slack/SlackChannelConfig.js';
+export { SlackChannel } from './addon/chat-controller/slack/SlackChannel.js';
+export { slackChannelName } from './addon/chat-controller/slack/slackChannelName.js';
+export { markdownToSlackMrkdwn } from './addon/chat-controller/slack/markdownToSlackMrkdwn.js';
 export { socket } from './addon/chat-controller/socket/@socket.js';
 export { SocketChannel, SocketChannelMessageFile, SocketChannelReceivedMessage } from './addon/chat-controller/socket/SocketChannel.js';
 export { SocketChannelConfig } from './addon/chat-controller/socket/SocketChannelConfig.js';
@@ -180,7 +210,6 @@ export { telegram } from './addon/chat-controller/telegram/@telegram.js';
 export { TelegramChannelConfig } from './addon/chat-controller/telegram/TelegramChannelConfig.js';
 export { TelegramChannel } from './addon/chat-controller/telegram/TelegramChannel.js';
 export { telegramChannelName } from './addon/chat-controller/telegram/telegramChannelName.js';
-export { markdownToTelegramHtml } from './addon/chat-controller/telegram/markdownToTelegramHtml.js';
 export { WhatsAppReceiverByCloudApi } from './addon/chat-controller/whatsapp/cloud-api/WhatsAppReceiverByCloudApi.js';
 export { WhatsAppApiSender } from './addon/chat-controller/whatsapp/cloud-api/WhatsAppApiSender.js';
 export { kapso } from './addon/chat-controller/whatsapp/kapso/@kapso.js';

package/dist/src/testing/LlmJudge.js

@@ -0,0 +1,93 @@
+const VERDICT_TOOL = {
+    language: 'english',
+    name: 'submitVerdict',
+    description: 'Submit your evaluation verdict. You MUST always call this tool exactly once; never answer with plain text.',
+    parameters: [
+        {
+            name: 'pass',
+            required: true,
+            schema: { type: 'boolean', description: 'true if the transcript satisfies the criteria' },
+        },
+        {
+            name: 'reasoning',
+            required: true,
+            schema: { type: 'string', description: 'short explanation of the verdict' },
+        },
+    ],
+};
+const JUDGE_SYSTEM_PROMPT = `
+You are a strict QA judge for chatbot conversations.
+You will receive a chat transcript and evaluation criteria.
+Evaluate whether the transcript satisfies ALL the criteria.
+You MUST report your verdict by calling the submitVerdict tool exactly once.
+Never reply with plain text.
+`;
+function renderTranscript(items) {
+    return items
+        .map((item) => {
+        if (item.type === 'humanMessage') {
+            const msg = item.humanMessage;
+            const parts = [
+                msg.text,
+                msg.images?.length ? `[${msg.images.length} image(s)]` : undefined,
+                msg.documents?.length ? `[${msg.documents.length} document(s)]` : undefined,
+                msg.object ? JSON.stringify(msg.object) : undefined,
+            ].filter(Boolean);
+            return `HUMAN: ${parts.join(' ')}`;
+        }
+        if (item.type === 'botMessage') {
+            return `BOT: ${item.botMessage.text ?? JSON.stringify(item.botMessage)}`;
+        }
+        const call = item.functionCall;
+        return `TOOL CALL: ${call.name}(${call.arguments ?? '{}'}) -> ${call.result ?? '(no result)'}`;
+    })
+        .join('\n');
+}
+/**
+ * Grades chatbot behavior with a real LLM. Provider-agnostic: the verdict is
+ * extracted through a forced tool call instead of parsing free-form text.
+ */
+class LlmJudge {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async evaluate(req) {
+        const transcript = typeof req.transcript === 'string' ? req.transcript : renderTranscript(req.transcript);
+        const { nextItems } = await this.options.adapter.nextItems({
+            models: this.options.models,
+            systemPrompt: JUDGE_SYSTEM_PROMPT,
+            tools: [VERDICT_TOOL],
+            prevItems: [
+                {
+                    type: 'humanMessage',
+                    humanMessage: {
+                        text: `## Criteria\n${req.criteria}\n\n## Transcript\n${transcript}\n\nEvaluate now and call submitVerdict.`,
+                    },
+                },
+            ],
+        });
+        const verdictCall = nextItems.find((item) => item.type === 'functionCall' && item.functionCall.name === VERDICT_TOOL.name);
+        if (!verdictCall || verdictCall.type !== 'functionCall') {
+            const texts = nextItems
+                .map((item) => (item.type === 'botMessage' ? item.botMessage.text : null))
+                .filter(Boolean);
+            throw new Error(`LlmJudge: the judge model did not call submitVerdict. Got: ${texts.join(' | ') || JSON.stringify(nextItems)}`);
+        }
+        const args = JSON.parse(verdictCall.functionCall.arguments ?? '{}');
+        if (typeof args.pass !== 'boolean') {
+            throw new Error(`LlmJudge: invalid verdict arguments: ${verdictCall.functionCall.arguments}`);
+        }
+        return { pass: args.pass, reasoning: String(args.reasoning ?? '') };
+    }
+    /** Like evaluate(), but throws (with the judge's reasoning) when it fails. */
+    async assert(req) {
+        const verdict = await this.evaluate(req);
+        if (!verdict.pass) {
+            throw new Error(`LlmJudge: criteria not satisfied: ${req.criteria}\n${verdict.reasoning}`);
+        }
+        return verdict;
+    }
+}
+
+export { LlmJudge, renderTranscript };

package/dist/src/testing/MockChatAdapter.js

@@ -0,0 +1,68 @@
+/**
+ * Deterministic IChatAdapter for tests: script the LLM turns with
+ * reply()/callTool()/enqueue() and assert on the recorded requests.
+ * Each queued response is consumed by one nextItems() call, so a tool
+ * call turn must be followed by another scripted turn (the ChatBot loop
+ * calls the adapter again after executing the tool).
+ */
+class MockChatAdapter {
+    options;
+    requests = [];
+    queue = [];
+    callIdCounter = 0;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /** Queue a turn where the bot answers with a plain text message. */
+    reply(text) {
+        return this.enqueue([{ type: 'botMessage', botMessage: { text } }]);
+    }
+    /** Queue a turn where the bot requests a tool call (executed for real by the ChatBot). */
+    callTool(name, args) {
+        return this.enqueue([
+            {
+                type: 'functionCall',
+                functionCall: {
+                    id: `mock-call-${++this.callIdCounter}`,
+                    name,
+                    arguments: typeof args === 'string' ? args : JSON.stringify(args ?? {}),
+                },
+            },
+        ]);
+    }
+    /** Queue a raw turn: a list of chat items, or a function of the request. */
+    enqueue(response) {
+        this.queue.push(response);
+        return this;
+    }
+    get lastRequest() {
+        return this.requests[this.requests.length - 1];
+    }
+    pendingResponses() {
+        return this.queue.length;
+    }
+    async nextItems(req) {
+        this.requests.push(req);
+        let response = this.queue.shift();
+        if (!response) {
+            if (this.options.fallbackReply === undefined) {
+                throw new Error('MockChatAdapter: no scripted response left for this turn. ' +
+                    'Queue one with reply()/callTool()/enqueue(), or set the fallbackReply option. ' +
+                    'Remember that after a callTool() turn the ChatBot calls the adapter again.');
+            }
+            response = [{ type: 'botMessage', botMessage: { text: this.options.fallbackReply } }];
+        }
+        const nextItems = typeof response === 'function' ? await response(req) : response;
+        return {
+            nextItems,
+            usage: {
+                inputTokens: 1,
+                outputTokens: 1,
+                provider: 'mock',
+                model: req.models[0]?.model ?? 'mock-model',
+            },
+        };
+    }
+}
+
+export { MockChatAdapter };

package/dist/src/testing/TestChatMemory.js

@@ -0,0 +1,73 @@
+import { randomUUID } from 'node:crypto';
+import '../feature/chat-bot/ChatAdapterRegistry.js';
+import '../feature/chat-bot/ChatBot.js';
+import { ChatOperator } from '../feature/chat-bot/ChatOperator.js';
+import '../feature/chat-bot/UnionChatAdapter.js';
+import '../core/injection/index.js';
+import '../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import '../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../core/error/setupErrorHandlers.js';
+
+/**
+ * Pure in-RAM chat memory for tests. Unlike the in-memory addon, it never
+ * touches the filesystem and exposes the full item list for assertions.
+ */
+class TestChatMemory {
+    items = [];
+    async findLastItems(count) {
+        return this.items.slice(-count);
+    }
+    async create(item) {
+        if (!item.wasCreated()) {
+            item['data'].id = randomUUID();
+            item['data'].createdAt = Date.now();
+        }
+        this.items.push(item);
+    }
+    all() {
+        return [...this.items];
+    }
+    allData() {
+        return this.items.map((item) => item.getData());
+    }
+    clear() {
+        this.items = [];
+    }
+}
+/** Pure in-RAM chat repository for tests (no `.wabot/` persistence). */
+class TestChatRepository {
+    chats = [];
+    memories = new Map();
+    async create(chat) {
+        if (chat.wasCreated()) {
+            throw new Error('Chat already created');
+        }
+        chat['data'].id = randomUUID();
+        chat['data'].createdAt = Date.now();
+        chat.validate();
+        this.chats.push(chat);
+        this.memories.set(chat.id, new TestChatMemory());
+    }
+    async update(chat) {
+        if (!chat.wasCreated()) {
+            throw new Error('Chat was not created');
+        }
+        chat.validate();
+    }
+    async findByConnection(query) {
+        return this.chats.find((chat) => chat.hasConnection(query)) ?? null;
+    }
+    async findMemory(chatId) {
+        return this.memories.get(chatId) ?? null;
+    }
+    async findOperator(chatId) {
+        const chat = this.chats.find((item) => item.id === chatId) ?? null;
+        const memory = this.memories.get(chatId);
+        if (!chat || !memory)
+            return null;
+        return new ChatOperator(chat, memory, this);
+    }
+}
+
+export { TestChatMemory, TestChatRepository };

package/dist/src/testing/asyncHarness.js

@@ -0,0 +1,66 @@
+import { Auth } from '../core/auth/Auth.js';
+import { container } from '../core/injection/index.js';
+import { AsyncMetadataStore } from '../feature/async/AsyncMetadataStore.js';
+import '../feature/async/TransactionMetadataStore.js';
+import '../feature/async/Async.js';
+import '../_virtual/index.js';
+import '../core/error/setupErrorHandlers.js';
+import 'node:crypto';
+import '../feature/async/JobRepository.js';
+import '../feature/async/JobRunner.js';
+import '../feature/async/JobScheduler.js';
+import '../feature/async/JobWatchdog.js';
+import '../feature/async/CronScheduler.js';
+import { assertValid } from './validation.js';
+import { Container } from '../core/injection/Container.js';
+
+/**
+ * Executes @command handlers and @cronHandler jobs inline — no PostgreSQL,
+ * no polling workers — with the same validation production applies.
+ */
+class AsyncHarness {
+    container;
+    constructor(options = {}) {
+        const child = container.createChildContainer();
+        child.register(Container, { useValue: child });
+        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;
+    }
+    /**
+     * Validate the command data and run its handler immediately, like the
+     * JobRunner does for a scheduled job. Returns the transformed command.
+     */
+    async execute(commandConstructor, data = {}) {
+        const store = container.resolve(AsyncMetadataStore);
+        const commandName = store.getCommandName(commandConstructor);
+        if (!commandName) {
+            throw new Error(`AsyncHarness: ${commandConstructor.name} is not registered with the @command decorator`);
+        }
+        const handlerConstructor = store.getHandlerForCommandName(commandName);
+        if (!handlerConstructor) {
+            throw new Error(`AsyncHarness: no @commandHandler registered for command '${commandName}'`);
+        }
+        const command = assertValid(commandConstructor, data);
+        const handler = this.container.resolve(handlerConstructor);
+        await handler.handle(command);
+        return command;
+    }
+    /** Run a @cronHandler's handle() once, immediately. */
+    async runCron(cronConstructor) {
+        const store = container.resolve(AsyncMetadataStore);
+        store.requireCronMetadata(cronConstructor);
+        const handler = this.container.resolve(cronConstructor);
+        await handler.handle();
+    }
+}
+function createAsyncHarness(options = {}) {
+    return new AsyncHarness(options);
+}
+
+export { AsyncHarness, createAsyncHarness };

package/dist/src/testing/auth.js

@@ -0,0 +1,114 @@
+import jwt from 'jsonwebtoken';
+import '../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../core/injection/index.js';
+import { CustomError } from '../core/error/CustomError.js';
+import '../core/error/setupErrorHandlers.js';
+import 'debug';
+import '../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../feature/socket/SocketServerConfig.js';
+import '../feature/socket/SocketServerProvider.js';
+import '../addon/auth/api-key/ApiKeyHandshakeGuardMiddleware.js';
+import '../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import '../feature/express/ExpressProvider.js';
+import 'express';
+import 'node:path';
+import 'node:http';
+import '../addon/auth/api-key/ApiKeyGuardMiddleware.js';
+import { ApiKey } from '../addon/auth/api-key/ApiKey.js';
+import { ApiKeyRepository } from '../addon/auth/api-key/ApiKeyRepository.js';
+import '../addon/auth/api-key/PgApiKeyRepository.js';
+import '../addon/auth/jwt/JwtHandshakeGuardMiddleware.js';
+import '../addon/auth/jwt/JwtGuardMiddleware.js';
+import '../addon/auth/jwt/Jwt.js';
+import '../addon/auth/jwt/JwtAccessAndRefreshTokenDto.js';
+import { JwtConfig } from '../addon/auth/jwt/JwtConfig.js';
+import 'node:crypto';
+import '../addon/auth/jwt/JwtSigner.js';
+import '../addon/auth/jwt/JwtTokenDto.js';
+import '../addon/auth/jwt/PgJwtRefreshTokenRepository.js';
+
+/**
+ * JWT setup for tests: a JwtConfig with a test secret (no JWT_SECRET env var
+ * needed) plus a signer, so the real JwtGuardMiddleware validates the tokens.
+ */
+class TestJwt {
+    config;
+    constructor(options = {}) {
+        const config = Object.create(JwtConfig.prototype);
+        config.algorithm = 'HS256';
+        config.secretOrPublicKey = options.secret ?? 'wabot-test-jwt-secret';
+        config.secretOrPrivateKey = options.secret ?? 'wabot-test-jwt-secret';
+        config.accessExpirationSeconds = options.accessExpirationSeconds ?? 10 * 60;
+        config.refreshExpirationSeconds = 365 * 24 * 3600;
+        this.config = config;
+    }
+    /** Sign a valid access token carrying the given authInfo. */
+    sign(authInfo) {
+        return jwt.sign(authInfo, this.config.secretOrPrivateKey, {
+            algorithm: this.config.algorithm,
+            expiresIn: this.config.accessExpirationSeconds,
+        });
+    }
+    /** A token signed with a different secret; useful for 401 tests. */
+    signInvalid(authInfo = {}) {
+        return jwt.sign(authInfo, `${this.config.secretOrPrivateKey}-corrupted`, {
+            algorithm: this.config.algorithm,
+            expiresIn: this.config.accessExpirationSeconds,
+        });
+    }
+}
+function setupTestJwt(options = {}) {
+    return new TestJwt(options);
+}
+/**
+ * In-RAM IApiKeyRepository so the real ApiKeyGuardMiddleware can run in
+ * tests. Register it with: register: [[ApiKeyRepository, testApiKeys]].
+ */
+class TestApiKeyRepository extends ApiKeyRepository {
+    items = [];
+    idCounter = 0;
+    /** Create a key for the given authInfo and return its secret. */
+    async addKey(authInfo, name = 'test-key') {
+        const { secret } = await this.generate({ name, authInfo });
+        return secret;
+    }
+    async find(id) {
+        return this.items.find((item) => item.id === id) ?? null;
+    }
+    async findOrThrow(id) {
+        const item = await this.find(id);
+        if (!item) {
+            throw new CustomError({ message: `Not found ApiKey with id = '${id}'`, httpCode: 404 });
+        }
+        return item;
+    }
+    async findByMetadata(metadata) {
+        return this.items.filter((item) => Object.entries(metadata).every(([key, value]) => item.metadata[key] === value));
+    }
+    async create(item) {
+        if (!item.wasCreated()) {
+            item['data'].id = `test-api-key-${++this.idCounter}`;
+            item['data'].createdAt = Date.now();
+        }
+        this.items.push(item);
+    }
+    async generate(req) {
+        const apiKey = new ApiKey({ name: req.name, metadata: req.metadata, authInfo: req.authInfo });
+        const secret = apiKey.generateSecret();
+        await this.create(apiKey);
+        return { apiKey, secret };
+    }
+    async findBySecret(secret) {
+        return this.items.find((item) => item.isValidSecret(secret)) ?? null;
+    }
+    async findAndValidate(secret) {
+        const apiKey = await this.findBySecret(secret);
+        if (!apiKey) {
+            throw new CustomError({ message: 'Invalid API key', httpCode: 401 });
+        }
+        return apiKey.authInfo;
+    }
+}
+
+export { TestApiKeyRepository, TestJwt, setupTestJwt };

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 };