libmodulor 0.3.0 → 0.5.0

package/dist/esm/std/impl/MistralAILLMManager.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MistralAILLMManager_1;
+import { inject, injectable } from 'inversify';
+let MistralAILLMManager = class MistralAILLMManager {
+    static { MistralAILLMManager_1 = this; }
+    httpAPICaller;
+    settingsManager;
+    static BASE_URL = 'https://api.mistral.ai/v1';
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            mai_api_key: this.settingsManager.get()('mai_api_key'),
+        };
+    }
+    async send(req) {
+        return await this.httpAPICaller.exec({
+            authorizationHeader: {
+                value: this.s().mai_api_key,
+                prefix: 'Bearer',
+            },
+            errBuilder: async (error) => {
+                if ('message' in error) {
+                    return error.message;
+                }
+                return error.detail.map((d) => d.msg).join('\n');
+            },
+            method: 'POST',
+            req: {
+                envelope: 'json',
+                builder: async () => req,
+            },
+            urlBuilder: async () => `${MistralAILLMManager_1.BASE_URL}/chat/completions`,
+        });
+    }
+};
+MistralAILLMManager = MistralAILLMManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], MistralAILLMManager);
+export { MistralAILLMManager };

package/dist/esm/std/impl/NodeCryptoManager.js

@@ -7,10 +7,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import crypto from 'node:crypto';
 import { promisify } from 'node:util';
 import { injectable } from 'inversify';
+// https://nodejs.org/api/crypto.html#cryptopbkdf2password-salt-iterations-keylen-digest-callback
 const pbkdf2 = promisify(crypto.pbkdf2);
+// https://nodejs.org/api/crypto.html#cryptoscryptpassword-salt-keylen-options-callback
 const scrypt = promisify(crypto.scrypt);
 let NodeCryptoManager = class NodeCryptoManager {
     async clear() {
+        // Nothing to do
     }
     hash(algorithm, base, binaryToTextEncoding) {
         return crypto
@@ -35,9 +38,11 @@ let NodeCryptoManager = class NodeCryptoManager {
         return Uint8Array.from(result);
     }
     async randomString(length) {
+        // Not perfect in terms of randomness (because of Math.random() but pretty fine for now)
         let res = '';
         while (res.length < length) {
             const next = Math.random().toString(36).slice(2, 3);
+            // For now, we want only chars at the beginning, so it can be used as an identifier (i.e. in a database)
             if (res.length === 0 &&
                 Number.isInteger(Number.parseInt(next, 10))) {
                 continue;
@@ -50,7 +55,7 @@ let NodeCryptoManager = class NodeCryptoManager {
         return crypto.randomUUID();
     }
     async scrypt(password, salt, keyLength) {
-        const buffer = (await scrypt(password, salt, keyLength));
+        const buffer = (await scrypt(password, salt, keyLength)); // Forced to cast because it seems to be not typed correctly
         return buffer.toString('hex');
     }
 };

package/dist/esm/std/impl/NodeDeterministicCryptoManager.d.ts

@@ -1,6 +1,20 @@
 import type { UIntQuantity, UUID } from '../../dt/index.js';
 import type { CryptoManagerRandomString } from '../CryptoManager.js';
 import { NodeCryptoManager } from './NodeCryptoManager.js';
+/**
+ * A deterministic {@link CryptoManager} based on {@link NodeCryptoManager}
+ *
+ * The main purpose is to have an implementation that generates always the
+ * same data deterministically to make snapshot assertions in tests easier.
+ *
+ * WARNING : it keeps internal "seeds" to generate always the same data.
+ *
+ * In our case, it's an auto-incremented integer.
+ *
+ * So if the same implementation is used in multiple places
+ * (e.g. in concurrent tests within the same test suite),
+ * be ready for "race conditions" and inconsistencies.
+ */
 export declare class NodeDeterministicCryptoManager extends NodeCryptoManager {
     private randomStringIdx;
     private uuidIdx;

package/dist/esm/std/impl/NodeDeterministicCryptoManager.js

@@ -7,6 +7,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { createHash } from 'node:crypto';
 import { injectable } from 'inversify';
 import { NodeCryptoManager } from './NodeCryptoManager.js';
+/**
+ * A deterministic {@link CryptoManager} based on {@link NodeCryptoManager}
+ *
+ * The main purpose is to have an implementation that generates always the
+ * same data deterministically to make snapshot assertions in tests easier.
+ *
+ * WARNING : it keeps internal "seeds" to generate always the same data.
+ *
+ * In our case, it's an auto-incremented integer.
+ *
+ * So if the same implementation is used in multiple places
+ * (e.g. in concurrent tests within the same test suite),
+ * be ready for "race conditions" and inconsistencies.
+ */
 let NodeDeterministicCryptoManager = class NodeDeterministicCryptoManager extends NodeCryptoManager {
     randomStringIdx = 0;
     uuidIdx = 0;
@@ -33,14 +47,14 @@ let NodeDeterministicCryptoManager = class NodeDeterministicCryptoManager extend
         const hashBytes = hash.digest().subarray(0, 16);
         const bytes = Array.from(hashBytes);
         if (bytes[6] !== undefined) {
-            bytes[6] = (bytes[6] & 0x0f) | 0x40;
+            bytes[6] = (bytes[6] & 0x0f) | 0x40; // Set the version to 4 (UUID v4)
         }
         if (bytes[8] !== undefined) {
-            bytes[8] = (bytes[8] & 0x3f) | 0x80;
+            bytes[8] = (bytes[8] & 0x3f) | 0x80; // Set the variant to the correct RFC 4122 variant
         }
         const raw = bytes
             .map((byte) => {
-            return (byte + 0x1_00).toString(16).substring(1);
+            return (byte + 0x1_00).toString(16).substring(1); // Convert byte to hex
         })
             .join('');
         const uuid = [

package/dist/esm/std/impl/NodeFSManager.js

@@ -13,6 +13,9 @@ let NodeFSManager = class NodeFSManager {
         return true;
     }
     async cat(path, opts) {
+        // Be careful : omitting to pass an encoding makes it return a Buffer and not a string
+        // This can be problematic in some callers, manipulating the file as a string (e.g. startsWith, includes, etc.)
+        // So make sure to fallback on a default encoding
         return readFile(path, opts?.encoding ?? 'utf8');
     }
     async chmod(path, mode) {
@@ -25,6 +28,8 @@ let NodeFSManager = class NodeFSManager {
         await appendFile(src, content);
     }
     async exists(path) {
+        // Before, we could use fs.exists(path) but it's been deprecated : @deprecated since v1.0.0 Use `fs.stat()` or `fs.access()` instead
+        // Both functions are very unpractical to use because we need to wrap everything in a try/catch. It's too verbose !
         try {
             await stat(path);
             return true;
@@ -45,6 +50,11 @@ let NodeFSManager = class NodeFSManager {
         const parsedPath = parse(path);
         const stats = await stat(path);
         const { birthtime, size } = stats;
+        // For now there is nothing in the standard library to detect it.
+        // There are 3rd party packages like mime, mime-type, etc. but we prefer
+        // limiting the external dependencies.
+        // One can also call `file -b --mime-type /some/path` via exec/spawn if their
+        // system has this utility.
         const mimeType = null;
         const type = this.determineType(stats);
         return {

package/dist/esm/std/impl/NodeHTTPAPICallExecutorAgentBuilder.js

@@ -21,6 +21,8 @@ let NodeHTTPAPICallExecutorAgentBuilder = class NodeHTTPAPICallExecutorAgentBuil
     exec({ url, }) {
         if (url.protocol.startsWith('https')) {
             return new https.Agent({
+                // We allow self-signed certificates in non-prod environments
+                // This is useful when testing the CLI calling a the server from a docker container for example
                 rejectUnauthorized: this.environmentManager.isProd(),
             });
         }

package/dist/esm/std/impl/NodePromptManager.js

@@ -9,10 +9,13 @@ import { createInterface } from 'node:readline/promises';
 import { injectable } from 'inversify';
 let NodePromptManager = class NodePromptManager {
     async prompt(invite, opts) {
+        // TODO : Add keypress handling to hide when sensitive data is typed
         const readLine = createInterface({
             input: stdin,
             output: stdout,
         });
+        // To avoid "Warning: Detected unsettled top-level await at file:///[...]/dist/esm/xxx.js"
+        // when pressing Ctrl+C while being prompted
         readLine.on('SIGINT', () => {
             readLine.close();
             process.exit(0);

package/dist/esm/std/impl/OllamaLLMManager.d.ts

@@ -0,0 +1,20 @@
+import type { URL } from '../../dt/index.js';
+import type { HTTPAPICaller } from '../HTTPAPICaller.js';
+import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+/**
+ * Unlike the "commercial" APIs, Ollama does not secure the API with an API key
+ * @see https://github.com/ollama/ollama/issues/849
+ */
+export interface OllamaLLMManagerSettings extends Settings {
+    oll_base_url: URL;
+}
+type S = OllamaLLMManagerSettings;
+export declare class OllamaLLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): OllamaLLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};

package/dist/esm/std/impl/OllamaLLMManager.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { IllegalArgumentError } from '../../error/index.js';
+let OllamaLLMManager = class OllamaLLMManager {
+    httpAPICaller;
+    settingsManager;
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            oll_base_url: this.settingsManager.get()('oll_base_url'),
+        };
+    }
+    async send(req) {
+        const firstMessage = req.messages[0];
+        if (!firstMessage) {
+            throw new IllegalArgumentError('Please provide at least one message');
+        }
+        return await this.httpAPICaller.exec({
+            errBuilder: async (error) => error.error,
+            method: 'POST',
+            outputBuilder: async (res) => ({
+                choices: [{ message: { content: res.response } }],
+            }),
+            req: {
+                envelope: 'json',
+                builder: async () => ({
+                    model: req.model,
+                    prompt: firstMessage.content,
+                    stream: false,
+                }),
+            },
+            urlBuilder: async () => `${this.s().oll_base_url}/api/generate`,
+        });
+    }
+};
+OllamaLLMManager = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], OllamaLLMManager);
+export { OllamaLLMManager };

package/dist/esm/std/impl/OpenAILLMManager.d.ts

@@ -0,0 +1,17 @@
+import type { ApiKey } from '../../dt/index.js';
+import type { HTTPAPICaller } from '../HTTPAPICaller.js';
+import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+export interface OpenAILLMManagerSettings extends Settings {
+    oai_api_key: ApiKey;
+}
+type S = OpenAILLMManagerSettings;
+export declare class OpenAILLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    private static BASE_URL;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): OpenAILLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};

package/dist/esm/std/impl/OpenAILLMManager.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var OpenAILLMManager_1;
+import { inject, injectable } from 'inversify';
+let OpenAILLMManager = class OpenAILLMManager {
+    static { OpenAILLMManager_1 = this; }
+    httpAPICaller;
+    settingsManager;
+    static BASE_URL = 'https://api.openai.com/v1';
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            oai_api_key: this.settingsManager.get()('oai_api_key'),
+        };
+    }
+    async send(req) {
+        return await this.httpAPICaller.exec({
+            authorizationHeader: {
+                value: this.s().oai_api_key,
+                prefix: 'Bearer',
+            },
+            errBuilder: async (error) => error.error.message,
+            method: 'POST',
+            req: {
+                envelope: 'json',
+                builder: async () => req,
+            },
+            urlBuilder: async () => `${OpenAILLMManager_1.BASE_URL}/chat/completions`,
+        });
+    }
+};
+OpenAILLMManager = OpenAILLMManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], OpenAILLMManager);
+export { OpenAILLMManager };

package/dist/esm/std/impl/SimpleHTTPAPICaller.js

@@ -64,6 +64,7 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         if (status === 202 || status === 204) {
             return {};
         }
+        // Using .startsWith instead of === because the value can look like this 'application/json; charset=utf-8'
         const responseContentType = headers.get('Content-Type');
         const isJSON = responseContentType?.startsWith('application/json');
         const isFormURLEncoded = responseContentType?.startsWith('application/x-www-form-urlencoded');
@@ -87,6 +88,10 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
     async computeHeaders({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', req, }) {
         const headers = {};
         if (req?.envelope !== 'form-data') {
+            // The boundary needs to be set when sending data this way, so the server can understand how to read it (Source : https://stackoverflow.com/a/20321259/1259118)
+            // In RN, the content-type we set is automatically overriden by the internal fetch client (i.e. 'content-type': 'multipart/form-data; boundary=7ZsqoHiTstShSc4-Yi4U7ier3GPc_4QL5iN2eT9rnSNd0g1UoFPgt3I6.fsWlV8YpJhFkG')
+            // In CLI, if it is set, it's not overriden. So it creates problems. With 'form-data', we send 'content-type': 'multipart/form-data'` but the server expects something like 'content-type': 'multipart/form-data;boundary=--------------------------743913816161509008636675'
+            // So we don't set it at all and we're good to go.
             headers['Content-Type'] = contentType;
         }
         if (authorizationHeader) {
@@ -110,6 +115,8 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         return headers;
     }
     async processResBad({ errBuilder, opts, }, isJSON, isXML, response) {
+        // NOTE : This method must handle all possible cases and never throw
+        // Indeed, it's supposed to handle the errors so it shouldn't throw one
         let error;
         try {
             if (isJSON) {
@@ -134,6 +141,7 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             return null;
         }
         if (typeof error === 'string') {
+            // For example, it can be from `asText`, containing funny formatting (developers and errors you know...)
             return error.trim();
         }
         if (!error) {
@@ -144,10 +152,14 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             if (typeof message === 'string') {
                 return message;
             }
+            // Case where `errBuilder` is of type (error: string) => string
+            // If an object is passed to it, it would return an object instead, interpreted incorrectly as [object Object] by error handlers
             return JSON.stringify(message);
         }
         catch (err) {
             this.logger.error(err);
+            // Case where `errBuilder` is of type (error: Object) => string
+            // If an object of another shape is passed to it, it would trigger some TypeError or cannot call .message of undefined
             return JSON.stringify(error);
         }
     }
@@ -163,7 +175,9 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             });
             if (isFormURLEncoded) {
                 payload = {};
+                // TODO : Find a better way to do this (without adding any external dependency because the code must be portable)
                 new URL(`http://localhost?${asText}`).searchParams.forEach((v, k) => {
+                    // @ts-ignore
                     payload[k] = v;
                 });
             }

package/dist/esm/std/impl/SimpleMapI18nManager.js

@@ -17,7 +17,7 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
     static { SimpleMapI18nManager_1 = this; }
     i18n;
     logger;
-    static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g;
+    static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g; // Note the 'g' so it can be used with `matchAll`
     entries;
     constructor(i18n, logger) {
         this.i18n = i18n;
@@ -48,12 +48,14 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
         if (opts?.fallback) {
             return opts.fallback;
         }
-        return key;
+        return key; // Mimic the behavior of some common libraries like i18next
     }
     tOrNull(key, _opts) {
         return this.entries.get(key) || null;
     }
     replacePlaceholders(v, opts) {
+        // DO NOT USE THIS IN PRODUCTION
+        // The purpose of it is to have a simple and dependency-less implementation, to play with
         let res = v;
         const placeholders = res.matchAll(SimpleMapI18nManager_1.PLACEHOLDERS_REGEX);
         for (const [placeholder, key] of placeholders) {

package/dist/esm/std/impl/StdDateClockManager.js

@@ -10,6 +10,9 @@ let StdDateClockManager = class StdDateClockManager {
         return new Date();
     }
     nowToKey() {
+        // The rationale behind this being hardcoded is to avoid adding a library (luxon, date-fns) just for that.
+        // For instance, luxon adds a huge amount of code to a basic web target when bundled, for nothing.
+        // See https://github.com/moment/luxon/issues/854#issuecomment-1729384672
         return this.now()
             .toISOString()
             .replaceAll(/-|T|:/g, '')

package/dist/esm/std/impl/UCDataStoreExternalResourceManager.js

@@ -11,6 +11,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
+// TODO : Wait for the DB to be ready or add a retry mechanism
+// Because when we start from a fresh install, this is executed before the docker container is ready
+// A temporary workaround is to stop and restart everything. At the 2nd startup, the db is ready, and it works
 let UCDataStoreExternalResourceManager = class UCDataStoreExternalResourceManager {
     ucDataStore;
     constructor(ucDataStore) {

package/dist/esm/std/impl/WebCryptoManager.js

@@ -10,6 +10,7 @@ const DIGEST_MAPPING = new Map([
 ]);
 let WebCryptoManager = class WebCryptoManager {
     async clear() {
+        // Nothing to do
     }
     hash(_algorithm, _base) {
         throw new Error('Method not implemented.');
@@ -25,9 +26,13 @@ let WebCryptoManager = class WebCryptoManager {
         if (!hash) {
             throw new Error(`Digest ${digest} is not valid for WebCryptoManager`);
         }
+        // "Secure context: This feature is available only in secure contexts (HTTPS), in some or all supporting browsers."
+        // Warning: This API provides a number of low-level cryptographic primitives. It's very easy to misuse them, and the pitfalls involved can be very subtle.
+        // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
         const textEncoder = new TextEncoder();
         const passwordKey = await crypto.subtle.importKey('raw', textEncoder.encode(password), 'PBKDF2', false, ['deriveBits']);
         const result = await crypto.subtle.deriveBits({
+            // https://developer.mozilla.org/en-US/docs/Web/API/Pbkdf2Params
             hash,
             iterations: iterationsCount,
             name: 'PBKDF2',
@@ -36,9 +41,11 @@ let WebCryptoManager = class WebCryptoManager {
         return new Uint8Array(result);
     }
     async randomString(length) {
+        // Not perfect in terms of randomness (because of Math.random() but pretty fine for now)
         let res = '';
         while (res.length < length) {
             const next = Math.random().toString(36).slice(2, 3);
+            // For now, we want only chars at the beginning, so it can be used as an identifier (i.e. in a database)
             if (res.length === 0 &&
                 Number.isInteger(Number.parseInt(next, 10))) {
                 continue;
@@ -48,6 +55,8 @@ let WebCryptoManager = class WebCryptoManager {
         return res;
     }
     randomUUID() {
+        // "Secure context: This feature is available only in secure contexts (HTTPS), in some or all supporting browsers."
+        // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID
         return crypto.randomUUID();
     }
     async scrypt() {

package/dist/esm/std/index.d.ts

@@ -13,6 +13,7 @@ export * from './HTTPAPICallExecutor.js';
 export * from './I18nManager.js';
 export * from './JobManager.js';
 export * from './JWTManager.js';
+export * from './LLMManager.js';
 export * from './Logger.js';
 export * from './PromptManager.js';
 export * from './SettingsManager.js';

package/dist/esm/std/index.js

@@ -13,6 +13,7 @@ export * from './HTTPAPICallExecutor.js';
 export * from './I18nManager.js';
 export * from './JobManager.js';
 export * from './JWTManager.js';
+export * from './LLMManager.js';
 export * from './Logger.js';
 export * from './PromptManager.js';
 export * from './SettingsManager.js';

package/dist/esm/target/lib/cli/renderer.js

@@ -1,5 +1,6 @@
 import { CustomError } from '../../../error/index.js';
 export function print(line) {
+    // biome-ignore lint/suspicious/noConsole: we want it
     console.info(line);
 }
 export function printError(err) {
@@ -7,11 +8,13 @@ export function printError(err) {
     if (err instanceof Error) {
         message = err.message;
         if (!(err instanceof CustomError)) {
+            // biome-ignore lint/suspicious/noConsole: we want it
             console.error(err);
         }
     }
     else if (typeof err === 'string') {
         message = err;
     }
+    // biome-ignore lint/suspicious/noConsole: we want it
     console.error(message);
 }

package/dist/esm/target/lib/client/consts.d.ts

@@ -1,2 +1,5 @@
 import type { ServerClientManagerSettings } from './ServerClientManager.js';
+/**
+ * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
+ */
 export declare const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS: ServerClientManagerSettings;

package/dist/esm/target/lib/client/consts.js

@@ -1,3 +1,6 @@
+/**
+ * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
+ */
 export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
     server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
     server_public_api_key_header_name: 'X-API-Key',

package/dist/esm/target/lib/mcp-server/MCPServerBooter.js

@@ -32,6 +32,7 @@ let MCPServerBooter = class MCPServerBooter {
                 srcImporter,
             });
             for await (const uc of ucs) {
+                // Declared only for compatibility with ServerManager's contract but not used
                 const contract = ucHTTPContract(uc);
                 await this.ucManager.initServer(uc);
                 await this.serverManager.mount(uc.appManifest, uc.def, contract);

package/dist/esm/target/lib/react/UCContainer.js

@@ -15,6 +15,7 @@ export function UCContainer({ children, uc, }) {
         })();
     }, [uc, ucExecChecker]);
     if (isAllowed === undefined) {
+        // TODO : Add some loader while we check if can do
         return React.createElement(React.Fragment, null);
     }
     if (isAllowed === false) {

package/dist/esm/target/lib/react/UCPanel.js

@@ -33,6 +33,9 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
     };
     const onSubmit = async () => {
         setExecState('submitting');
+        // Is some targets, the confirmClient blocks the main thread (e.g. window.confirm()).
+        // This leads to the state set above not being updated.
+        // This is a "hacky" workaroud to let React re-render the control with 'submitting' state before
         await sleep(100);
         await onStartSubmitting?.();
         const confirmed = await ucManager.confirmClient(uc);
@@ -62,6 +65,7 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
     };
     const disabled = ucIsDisabled(execState);
     const loading = ucIsLoading(execState);
+    // TODO : Keep these as a state to avoid recomputation
     const ctx = {
         clearAfterExec,
         disabled,

package/dist/esm/target/lib/react/entrypoint.d.ts

@@ -1,6 +1,8 @@
 import type { URLPath } from '../../../dt/index.js';
 import type { UC, UCInput, UCOPIBase } from '../../../uc/index.js';
+export type UCEntrypointOnPress = () => Promise<void>;
 export interface UCEntrypointCtx<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    onPress?: UCEntrypointOnPress;
     path?: URLPath | undefined;
     uc: UC<I, OPI0, OPI1>;
 }

package/dist/esm/target/lib/react/useUC.d.ts

@@ -2,6 +2,14 @@ import { type ArgsRecord, UC, type UCDef, type UCInput, type UCOPIBase } from '.
 type CloneFunc<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (i: Partial<I>) => UC<I, OPI0, OPI1>;
 type DivertFunc<II extends UCInput | undefined = undefined, OOPI0 extends UCOPIBase | undefined = undefined, OOPI1 extends UCOPIBase | undefined = undefined> = (siblingUCD: UCDef) => UC<II, OOPI0, OOPI1>;
 type RefillFunc<I extends UCInput | undefined = undefined> = (i: Partial<I>) => void;
+/**
+ * This hook provides utilities to init a use case and perform actions on it in a React way
+ * @param appManifest
+ * @param def
+ * @param auth
+ * @param opts
+ * @returns
+ */
 export declare function useUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: ArgsRecord<I, OPI0, OPI1>['appManifest'], def: ArgsRecord<I, OPI0, OPI1>['def'], auth: ArgsRecord<I, OPI0, OPI1>['auth'], opts?: {
     fillWith: Partial<I>;
 }): [