@wabot-dev/framework 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/src/ai/claude/ClaudeChatBotAdapter.js

@@ -0,0 +1,115 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../injection/index.js';
+import { Anthropic } from '../../node_modules/@anthropic-ai/sdk/client.js';
+import '../../node_modules/@anthropic-ai/sdk/core/api-promise.js';
+import '../../node_modules/@anthropic-ai/sdk/core/pagination.js';
+import 'uuid';
+import '../../chatbot/metadata/ChatBotMetadataStore.js';
+import '../../chatbot/ChatBot.js';
+import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
+import { Logger } from '../../logger/Logger.js';
+
+let ClaudeChatBotAdapter = class ClaudeChatBotAdapter extends ChatBotAdapter {
+    anthropic;
+    model;
+    logger = new Logger('wabot:claude-chat-bot-adapter');
+    constructor(mindset) {
+        super(mindset);
+        const apiKey = process.env.CLAUDE_API_KEY;
+        if (!apiKey) {
+            throw new Error(`CLAUDE_API_KEY env variable is required`);
+        }
+        const model = process.env.CLAUDE_CHAT_MODEL;
+        if (!model) {
+            throw new Error(`CLAUDE_CHAT_MODEL env variable is required`);
+        }
+        this.anthropic = new Anthropic({ apiKey });
+        this.model = model;
+    }
+    async generateNextChatItem(chatItems) {
+        const systemPrompt = await this.systemPrompt();
+        const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
+            return {
+                name: fn.name,
+                description: fn.description,
+                input_schema: {
+                    ...fn.parameters,
+                    type: 'object'
+                }
+            };
+        });
+        const messages = this.mapChatItems(chatItems);
+        const request = {
+            model: this.model,
+            max_tokens: 4096,
+            system: systemPrompt,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+        };
+        this.logger.debug(`Call Claude API with Request: ${JSON.stringify(request)}`);
+        const response = await this.anthropic.messages.create(request);
+        let newChatItem;
+        const content = response.content[0];
+        if (content.type === 'text') {
+            newChatItem = await this.buildBotMessageItem(content.text);
+        }
+        else if (content.type === 'tool_use') {
+            newChatItem = await this.buildFunctionCallItem(content.id, content.name, JSON.stringify(content.input));
+        }
+        else {
+            throw new Error('Not supported Claude Response');
+        }
+        return newChatItem;
+    }
+    mapChatItems(chatItems) {
+        const messages = [];
+        for (const item of chatItems) {
+            const itemData = item.getData();
+            if (itemData.type === 'CONNECTION_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('User message content is empty');
+                }
+                messages.push({ role: 'user', content: itemData.content.text });
+            }
+            else if (itemData.type === 'BOT_MESSAGE') {
+                if (!itemData.content.text) {
+                    throw new Error('Assistant message content is empty');
+                }
+                messages.push({ role: 'assistant', content: itemData.content.text });
+            }
+            else if (itemData.type === 'FUNCTION_CALL') {
+                messages.push({
+                    role: 'assistant',
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: itemData.content.id,
+                            name: itemData.content.name,
+                            input: JSON.parse(itemData.content.arguments || '{}')
+                        }
+                    ]
+                });
+                messages.push({
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: itemData.content.id,
+                            content: itemData.content.result || 'No result'
+                        }
+                    ]
+                });
+            }
+        }
+        return messages;
+    }
+};
+ClaudeChatBotAdapter = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [MindsetOperator])
+], ClaudeChatBotAdapter);
+
+export { ClaudeChatBotAdapter };

package/dist/src/core/Entity.js

@@ -46,7 +46,7 @@ class Entity extends Storable {
 /**
  * @deprecated Should use Entity
  */
-class PersistentData extends Entity {
+class Persistent extends Entity {
 }
 
-export { Entity, PersistentData };
+export { Entity, Persistent };

package/dist/src/index.d.ts

@@ -64,7 +64,7 @@ interface IPersistentData extends IEntityData {
 /**
  * @deprecated Should use Entity
  */
-declare class PersistentData<D extends IPersistentData> extends Entity<D> {
+declare class Persistent<D extends IPersistentData> extends Entity<D> {
 }
 
 type IChatType = 'PRIVATE' | 'GROUP';
@@ -400,6 +400,15 @@ declare class OpenaiChatBotAdapter extends ChatBotAdapter {
     private mapChatItems;
 }
 
+declare class ClaudeChatBotAdapter extends ChatBotAdapter {
+    private anthropic;
+    private model;
+    private logger;
+    constructor(mindset: MindsetOperator);
+    generateNextChatItem(chatItems: ChatItem[]): Promise<ChatItem>;
+    private mapChatItems;
+}
+
 declare function cmd(): (target: object, propertyKey: string | symbol) => void;
 
 declare class ChatResolver {
@@ -1179,4 +1188,4 @@ declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IM
 
 declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, PersistentData, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };

package/dist/src/index.js

@@ -1,5 +1,6 @@
 export { DeepSeekChatBotAdapter } from './ai/deepseek/DeepSeekChatBotAdapter.js';
 export { OpenaiChatBotAdapter } from './ai/openia/OpenaiChatBotAdapter.js';
+export { ClaudeChatBotAdapter } from './ai/claude/ClaudeChatBotAdapter.js';
 export { cmd } from './channels/cmd/@cmd.js';
 export { CmdChannel } from './channels/cmd/CmdChannel.js';
 export { ExpressProvider } from './channels/express/ExpressProvider.js';
@@ -39,7 +40,7 @@ export { ChatItem } from './core/chat/ChatItem.js';
 export { User } from './core/user/User.js';
 export { UserRepository } from './core/user/IUserRepository.js';
 export { MessageContext } from './core/IMessageContext.js';
-export { Entity, PersistentData } from './core/Entity.js';
+export { Entity, Persistent } from './core/Entity.js';
 export { WabotEnv } from './env/WabotEnv.js';
 export { CustomError } from './error/CustomError.js';
 export { container, inject, injectable, singleton } from './injection/index.js';

package/dist/src/node_modules/@anthropic-ai/sdk/_vendor/partial-json-parser/parser.js

@@ -0,0 +1,221 @@
+const tokenize = (input) => {
+    let current = 0;
+    let tokens = [];
+    while (current < input.length) {
+        let char = input[current];
+        if (char === '\\') {
+            current++;
+            continue;
+        }
+        if (char === '{') {
+            tokens.push({
+                type: 'brace',
+                value: '{',
+            });
+            current++;
+            continue;
+        }
+        if (char === '}') {
+            tokens.push({
+                type: 'brace',
+                value: '}',
+            });
+            current++;
+            continue;
+        }
+        if (char === '[') {
+            tokens.push({
+                type: 'paren',
+                value: '[',
+            });
+            current++;
+            continue;
+        }
+        if (char === ']') {
+            tokens.push({
+                type: 'paren',
+                value: ']',
+            });
+            current++;
+            continue;
+        }
+        if (char === ':') {
+            tokens.push({
+                type: 'separator',
+                value: ':',
+            });
+            current++;
+            continue;
+        }
+        if (char === ',') {
+            tokens.push({
+                type: 'delimiter',
+                value: ',',
+            });
+            current++;
+            continue;
+        }
+        if (char === '"') {
+            let value = '';
+            let danglingQuote = false;
+            char = input[++current];
+            while (char !== '"') {
+                if (current === input.length) {
+                    danglingQuote = true;
+                    break;
+                }
+                if (char === '\\') {
+                    current++;
+                    if (current === input.length) {
+                        danglingQuote = true;
+                        break;
+                    }
+                    value += char + input[current];
+                    char = input[++current];
+                }
+                else {
+                    value += char;
+                    char = input[++current];
+                }
+            }
+            char = input[++current];
+            if (!danglingQuote) {
+                tokens.push({
+                    type: 'string',
+                    value,
+                });
+            }
+            continue;
+        }
+        let WHITESPACE = /\s/;
+        if (char && WHITESPACE.test(char)) {
+            current++;
+            continue;
+        }
+        let NUMBERS = /[0-9]/;
+        if ((char && NUMBERS.test(char)) || char === '-' || char === '.') {
+            let value = '';
+            if (char === '-') {
+                value += char;
+                char = input[++current];
+            }
+            while ((char && NUMBERS.test(char)) || char === '.') {
+                value += char;
+                char = input[++current];
+            }
+            tokens.push({
+                type: 'number',
+                value,
+            });
+            continue;
+        }
+        let LETTERS = /[a-z]/i;
+        if (char && LETTERS.test(char)) {
+            let value = '';
+            while (char && LETTERS.test(char)) {
+                if (current === input.length) {
+                    break;
+                }
+                value += char;
+                char = input[++current];
+            }
+            if (value == 'true' || value == 'false' || value === 'null') {
+                tokens.push({
+                    type: 'name',
+                    value,
+                });
+            }
+            else {
+                // unknown token, e.g. `nul` which isn't quite `null`
+                current++;
+                continue;
+            }
+            continue;
+        }
+        current++;
+    }
+    return tokens;
+}, strip = (tokens) => {
+    if (tokens.length === 0) {
+        return tokens;
+    }
+    let lastToken = tokens[tokens.length - 1];
+    switch (lastToken.type) {
+        case 'separator':
+            tokens = tokens.slice(0, tokens.length - 1);
+            return strip(tokens);
+        case 'number':
+            let lastCharacterOfLastToken = lastToken.value[lastToken.value.length - 1];
+            if (lastCharacterOfLastToken === '.' || lastCharacterOfLastToken === '-') {
+                tokens = tokens.slice(0, tokens.length - 1);
+                return strip(tokens);
+            }
+        case 'string':
+            let tokenBeforeTheLastToken = tokens[tokens.length - 2];
+            if (tokenBeforeTheLastToken?.type === 'delimiter') {
+                tokens = tokens.slice(0, tokens.length - 1);
+                return strip(tokens);
+            }
+            else if (tokenBeforeTheLastToken?.type === 'brace' && tokenBeforeTheLastToken.value === '{') {
+                tokens = tokens.slice(0, tokens.length - 1);
+                return strip(tokens);
+            }
+            break;
+        case 'delimiter':
+            tokens = tokens.slice(0, tokens.length - 1);
+            return strip(tokens);
+    }
+    return tokens;
+}, unstrip = (tokens) => {
+    let tail = [];
+    tokens.map((token) => {
+        if (token.type === 'brace') {
+            if (token.value === '{') {
+                tail.push('}');
+            }
+            else {
+                tail.splice(tail.lastIndexOf('}'), 1);
+            }
+        }
+        if (token.type === 'paren') {
+            if (token.value === '[') {
+                tail.push(']');
+            }
+            else {
+                tail.splice(tail.lastIndexOf(']'), 1);
+            }
+        }
+    });
+    if (tail.length > 0) {
+        tail.reverse().map((item) => {
+            if (item === '}') {
+                tokens.push({
+                    type: 'brace',
+                    value: '}',
+                });
+            }
+            else if (item === ']') {
+                tokens.push({
+                    type: 'paren',
+                    value: ']',
+                });
+            }
+        });
+    }
+    return tokens;
+}, generate = (tokens) => {
+    let output = '';
+    tokens.map((token) => {
+        switch (token.type) {
+            case 'string':
+                output += '"' + token.value + '"';
+                break;
+            default:
+                output += token.value;
+                break;
+        }
+    });
+    return output;
+}, partialParse = (input) => JSON.parse(generate(unstrip(strip(tokenize(input)))));
+
+export { partialParse };