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

package/dist/src/node_modules/@anthropic-ai/sdk/resources/messages/messages.js

@@ -0,0 +1,71 @@
+import { APIResource } from '../../core/resource.js';
+import { MessageStream } from '../../lib/MessageStream.js';
+import { Batches } from './batches.js';
+import { MODEL_NONSTREAMING_TOKENS } from '../../internal/constants.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Messages extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.batches = new Batches(this._client);
+    }
+    create(body, options) {
+        if (body.model in DEPRECATED_MODELS) {
+            console.warn(`The model '${body.model}' is deprecated and will reach end-of-life on ${DEPRECATED_MODELS[body.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);
+        }
+        let timeout = this._client._options.timeout;
+        if (!body.stream && timeout == null) {
+            const maxNonstreamingTokens = MODEL_NONSTREAMING_TOKENS[body.model] ?? undefined;
+            timeout = this._client.calculateNonstreamingTimeout(body.max_tokens, maxNonstreamingTokens);
+        }
+        return this._client.post('/v1/messages', {
+            body,
+            timeout: timeout ?? 600000,
+            ...options,
+            stream: body.stream ?? false,
+        });
+    }
+    /**
+     * Create a Message stream
+     */
+    stream(body, options) {
+        return MessageStream.createMessage(this, body, options);
+    }
+    /**
+     * Count the number of tokens in a Message.
+     *
+     * The Token Count API can be used to count the number of tokens in a Message,
+     * including tools, images, and documents, without creating it.
+     *
+     * Learn more about token counting in our
+     * [user guide](/en/docs/build-with-claude/token-counting)
+     *
+     * @example
+     * ```ts
+     * const messageTokensCount =
+     *   await client.messages.countTokens({
+     *     messages: [{ content: 'string', role: 'user' }],
+     *     model: 'claude-3-7-sonnet-latest',
+     *   });
+     * ```
+     */
+    countTokens(body, options) {
+        return this._client.post('/v1/messages/count_tokens', { body, ...options });
+    }
+}
+const DEPRECATED_MODELS = {
+    'claude-1.3': 'November 6th, 2024',
+    'claude-1.3-100k': 'November 6th, 2024',
+    'claude-instant-1.1': 'November 6th, 2024',
+    'claude-instant-1.1-100k': 'November 6th, 2024',
+    'claude-instant-1.2': 'November 6th, 2024',
+    'claude-3-sonnet-20240229': 'July 21st, 2025',
+    'claude-3-opus-20240229': 'January 5th, 2026',
+    'claude-2.1': 'July 21st, 2025',
+    'claude-2.0': 'July 21st, 2025',
+    'claude-3-5-sonnet-20241022': 'October 22, 2025',
+    'claude-3-5-sonnet-20240620': 'October 22, 2025',
+};
+Messages.Batches = Batches;
+
+export { Messages };

package/dist/src/node_modules/@anthropic-ai/sdk/resources/models.js

@@ -0,0 +1,43 @@
+import { APIResource } from '../core/resource.js';
+import { Page } from '../core/pagination.js';
+import { buildHeaders } from '../internal/headers.js';
+import { path } from '../internal/utils/path.js';
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Models extends APIResource {
+    /**
+     * Get a specific model.
+     *
+     * The Models API response can be used to determine information about a specific
+     * model or resolve a model alias to a model ID.
+     */
+    retrieve(modelID, params = {}, options) {
+        const { betas } = params ?? {};
+        return this._client.get(path `/v1/models/${modelID}`, {
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+    /**
+     * List available models.
+     *
+     * The Models API response can be used to determine which models are available for
+     * use in the API. More recently released models are listed first.
+     */
+    list(params = {}, options) {
+        const { betas, ...query } = params ?? {};
+        return this._client.getAPIList('/v1/models', (Page), {
+            query,
+            ...options,
+            headers: buildHeaders([
+                { ...(betas?.toString() != null ? { 'anthropic-beta': betas?.toString() } : undefined) },
+                options?.headers,
+            ]),
+        });
+    }
+}
+
+export { Models };

package/dist/src/node_modules/@anthropic-ai/sdk/version.js

@@ -0,0 +1,3 @@
+const VERSION = '0.60.0'; // x-release-please-version
+
+export { VERSION };

package/dist/src/pre-made/repository/chat/ram/RamChatRepository.js

@@ -16,7 +16,7 @@ let RamChatRepository = class RamChatRepository {
         this.items.push(chat);
         const memory = {
             memory: new RamChatMemory(),
-            chatId: chat.getId(),
+            chatId: chat.id,
         };
         this.memories.push(memory);
     }

package/dist/src/repository/pg/PgCrudRepository.js

@@ -57,10 +57,10 @@ class PgCrudRepository extends PgRepositoryBase {
          SET ${this.updates}
       WHERE id = $${this.columnsList.length + 1}
     `;
-        await this.exec(sql, [...this.values(item), item.getId()]);
+        await this.exec(sql, [...this.values(item), item.id]);
     }
     async discard(item) {
-        const _item = await this.find(item.getId());
+        const _item = await this.find(item.id);
         if (!_item) {
             throw new Error('Not found');
         }

package/dist/src/repository/pg/PgRepositoryBase.js

@@ -32,8 +32,8 @@ class PgRepositoryBase {
     }
     values(item) {
         return [
-            item.getId(),
-            item.getCreatedAt(),
+            item.id,
+            item.createdAt,
             JSON.stringify(item['data']),
             ...this.columnsList.slice(3).map((x) => this.addColumns[x].value(item)),
         ];

package/dist/src/rest-controller/metadata/@middleware.js

@@ -0,0 +1,16 @@
+import { container } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function middleware(middlewareConstructor) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveMiddlewareMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            middlewareConstructor: middlewareConstructor,
+        });
+    };
+}
+
+export { middleware };

package/dist/src/rest-controller/metadata/RestControllerMetadataStore.js

@@ -3,6 +3,7 @@ import { singleton } from 'tsyringe';
 
 let RestControllerMetadataStore = class RestControllerMetadataStore {
     endPoints = new Map();
+    middlewares = new Map();
     restControllers = new Map();
     saveControllerMetadata(controllerMetadata) {
         this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
@@ -14,6 +15,17 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
     }
+    saveMiddlewareMetadata(middlewareMetadata) {
+        let controllerMiddlewares = this.middlewares.get(middlewareMetadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(middlewareMetadata);
+    }
     getControllerEndPointsInfo(controllerConstructor) {
         const controller = this.restControllers.get(controllerConstructor);
         if (!controller) {
@@ -26,6 +38,7 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         return [...endPoints.values()].map((endPoint) => ({
             ...endPoint,
+            middlewares: this.middlewares.get(endPoint.controllerConstructor)?.get(endPoint.functionName) ?? [],
             controller: this.restControllers.get(endPoint.controllerConstructor),
         }));
     }

package/dist/src/rest-controller/runRestControllers.js

@@ -10,19 +10,20 @@ import '../channels/socket/SocketChannelConfig.js';
 import '../channels/socket/SocketServerProvider.js';
 import '../channels/telegram/TelegramChannel.js';
 import '../channels/whatsapp/WhatsAppChannel.js';
+import '../channels/whatsapp/EnvWhatsAppRepository.js';
+import '../channels/whatsapp/PgWhatsAppRepository.js';
 import '../core/chat/repository/IChatRepository.js';
 import '../core/user/IUserRepository.js';
 import '../channels/whatsapp/WhatsAppReceiverByDevConnection.js';
 import '../channels/whatsapp/WhatsAppReceiverByWebHook.js';
-import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
 import '../channels/whatsapp/WhatsAppSenderByCloudApi.js';
-import '../channels/whatsapp/PgWhatsAppRepository.js';
-import '../channels/whatsapp/EnvWhatsAppRepository.js';
+import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
 import { Logger } from '../logger/Logger.js';
 import '../validation/metadata/ValidationMetadataStore.js';
 import { validate } from '../validation/validate.js';
 import path from 'path';
 import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
+import { CustomError } from '../error/CustomError.js';
 
 function buildRequest(req) {
     return Object.assign({}, req.body, req.query, req.params);
@@ -40,42 +41,49 @@ function runRestControllers(controllers, container) {
             logger.info(`config ${endPoint.method.toUpperCase()} ${route}`);
             expressApp[method](route, async (req, res) => {
                 const requestContainer = container.createChildContainer();
-                const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
-                const endPointArgs = [];
-                let defaultArgFound = false;
-                for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
-                    const paramType = endPoint.paramsTypes[paramIndex];
-                    if (defaultArgFound) {
-                        throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                try {
+                    const middlewares = endPoint.middlewares.map((x) => requestContainer.resolve(x.middlewareConstructor));
+                    for (const middleware of middlewares) {
+                        await middleware.handle(req, res, requestContainer);
                     }
-                    defaultArgFound = true;
-                    if (typeof paramType === 'function') {
-                        const { value, error } = validate(buildRequest(req), paramType);
-                        if (error) {
-                            res.status(400).json({ error });
-                            return;
+                    const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
+                    const endPointArgs = [];
+                    let defaultArgFound = false;
+                    for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
+                        const paramType = endPoint.paramsTypes[paramIndex];
+                        if (defaultArgFound) {
+                            throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                        }
+                        defaultArgFound = true;
+                        if (typeof paramType === 'function') {
+                            const { value, error } = validate(buildRequest(req), paramType);
+                            if (error) {
+                                throw new CustomError({ httpCode: 400, message: error.description, info: error });
+                            }
+                            endPointArgs.push(value);
                         }
-                        endPointArgs.push(value);
                     }
-                }
-                try {
                     const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
                     res.status(200).json(response);
                 }
                 catch (err) {
                     if (err instanceof Error) {
                         const keys = Object.keys(err).filter((key) => !['message', 'stack'].includes(key));
-                        const info = keys.reduce((acc, key) => {
+                        const { httpCode, ...info } = keys.reduce((acc, key) => {
                             acc[key] = err[key];
                             return acc;
                         }, {});
-                        res.status(500).json({ error: { message: err.message, stack: err.stack, ...info } });
+                        res
+                            .status(httpCode ?? 500)
+                            .json({ error: { message: err.message, stack: err.stack, ...info } });
                     }
                     else {
                         res.status(500).json({ error: { message: 'Unknown error' } });
                     }
                 }
-                requestContainer.dispose();
+                finally {
+                    requestContainer.dispose();
+                }
             });
         });
     });

package/dist/src/server/prepareChatContainer.js

@@ -19,9 +19,9 @@ async function prepareChatContainer(container, context, mindsetCtor) {
         useValue: new MessageContext(context.message, context.chat, context.user),
     });
     const chatRepository = container.resolve(ChatRepository);
-    const chatMemory = await chatRepository.findMemory(context.chat.getId());
+    const chatMemory = await chatRepository.findMemory(context.chat.id);
     if (!chatMemory) {
-        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.getId());
+        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.id);
     }
     chatContainer.register(ChatMemory, { useValue: chatMemory });
     const chatBotMetadataStore = container.resolve(ChatBotMetadataStore);

package/dist/src/validation/metadata/@isModel.js

@@ -0,0 +1,18 @@
+import { container } from '../../injection/index.js';
+import { validateModel } from '../validators/validateModel.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+function isModel(model) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateModel,
+            validatorOptions: store.getModelValidatorsInfo(model),
+        });
+    };
+}
+
+export { isModel };

package/dist/src/validation/validators/validateModel.js

@@ -2,11 +2,7 @@ function validateModel(value, info) {
     const result = {};
     if (typeof value !== 'object') {
         result.error = {
-            model: [
-                {
-                    description: `the value should be an object`,
-                },
-            ],
+            description: 'the value should be an object',
             properties: [],
         };
         return result;
@@ -26,7 +22,7 @@ function validateModel(value, info) {
             if (propertyValidatorResult.error) {
                 let resultError = result.error;
                 if (!resultError) {
-                    resultError = { model: [], properties: [] };
+                    resultError = { description: `Error on properties`, properties: [] };
                     result.error = resultError;
                 }
                 let propertyErrors = resultError.properties.find((x) => x.name === propertyName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.11",
+  "version": "0.1.0-beta.13",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -35,6 +35,7 @@
     "typescript": "5.8.3"
   },
   "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.60.0",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.1",
     "@types/pg": "^8.11.14",