libmodulor 0.4.0 → 0.6.0

package/dist/esm/std/LLMManager.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,12 @@
 export interface PromptManagerPromptOpts<T extends string> {
+    /**
+     * Predicate to validate the input
+     *
+     * It keeps asking while the value is not valid, unless the user presses `Ctrl+C`.
+     *
+     * @param value
+     * @returns
+     */
     validate?: (value: T) => Promise<boolean>;
 }
 export interface PromptManager {

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

@@ -1,10 +1,29 @@
+/**
+ * Placeholder for string settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholder = "!<>!";
+/**
+ * Placeholder for array settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholderForArray: string[];
+/**
+ * Placeholder for object settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export declare const SettingsManagerMandatoryPlaceholderForObject: {
     '0': string;
 };
+/**
+ * A group of settings
+ *
+ * Prefix them with the thing that is configurable to avoid conflicts when defining settings together for a product and/or a target.
+ */
 export interface Settings {
 }
+/**
+ * Interface to implement by the classes that needs settings
+ *
+ * As `S`, pass the subset of settings that the class needs (e.g. `Pick<SomeSettings, 'setting_1'>`).
+ */
 export interface Configurable<S> {
     s(): S;
 }

package/dist/esm/std/SettingsManager.js

@@ -1,7 +1,16 @@
+/**
+ * Placeholder for string settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholder = '!<>!';
+/**
+ * Placeholder for array settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholderForArray = [
     SettingsManagerMandatoryPlaceholder,
 ];
+/**
+ * Placeholder for object settings that must be defined explicitly at runtime (e.g. secrets).
+ */
 export const SettingsManagerMandatoryPlaceholderForObject = {
     '0': SettingsManagerMandatoryPlaceholder,
 };

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

@@ -0,0 +1,19 @@
+import type { FilePath } from '../dt/index.js';
+import type { Worker } from './Worker.js';
+export type ShellCommandExecutorCommandArg = string;
+export type ShellCommandExecutorCommandBin = 'docker' | 'file' | 'git' | 'open' | 'ssh-keygen' | 'ssh-keyscan' | 'unzip' | 'yarn' | 'zip' | (string & {});
+export type ShellCommandExecutorEnv = Record<string, string>;
+export type ShellCommandExecutorInstruction = string;
+export type ShellCommandExecutorScript = string;
+export type ShellCommandExecutorShebang = '#!/bin/bash';
+export interface ShellCommandExecutorInput {
+    bin: ShellCommandExecutorCommandBin;
+    opts?: {
+        args?: ShellCommandExecutorCommandArg[];
+        cwd?: FilePath;
+        env?: ShellCommandExecutorEnv;
+    };
+}
+export type ShellCommandExecutorOutput = string;
+export interface ShellCommandExecutor extends Worker<ShellCommandExecutorInput, Promise<ShellCommandExecutorOutput>> {
+}

package/dist/esm/std/ShellCommandExecutor.js

@@ -0,0 +1 @@
+export {};

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

@@ -15,6 +15,7 @@ import { inject, injectable } from 'inversify';
 let ConsoleLogger = class ConsoleLogger {
     static { ConsoleLogger_1 = this; }
     settingsManager;
+    // Ordered by level
     static LEVELS = [
         'trace',
         'debug',
@@ -34,30 +35,35 @@ let ConsoleLogger = class ConsoleLogger {
         if (!this.shouldLog('debug')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.debug(`${this.t()} [debug] ${message}`, ...meta);
     }
     error(err) {
         if (!this.shouldLog('error')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.error(err);
     }
     info(message, ...meta) {
         if (!this.shouldLog('info')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.info(`${this.t()} [info] ${message}`, ...meta);
     }
     trace(message, ...meta) {
         if (!this.shouldLog('trace')) {
             return;
         }
-        console.debug(`${this.t()} [trace] ${message}`, ...meta);
+        // biome-ignore lint/suspicious/noConsole: we want it
+        console.trace(`${this.t()} [trace] ${message}`, ...meta);
     }
     warn(message, ...meta) {
         if (!this.shouldLog('warn')) {
             return;
         }
+        // biome-ignore lint/suspicious/noConsole: we want it
         console.warn(`${this.t()} [warn] ${message}`, ...meta);
     }
     shouldLog(level) {

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

@@ -20,6 +20,7 @@ let FakeEmailManager = class FakeEmailManager {
         this.entries.push({ def, replyTo, to });
     }
     async verify() {
+        // Nothing to do
     }
 };
 FakeEmailManager = __decorate([

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

@@ -20,6 +20,7 @@ let FakeJobManager = class FakeJobManager {
         this.entries.push({ input, jobName, queueName });
     }
     async init() {
+        // Nothing to do
     }
 };
 FakeJobManager = __decorate([

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

@@ -1,4 +1,13 @@
 import type { HTTPAPICallExecutor, HTTPAPICallExecutorFunc } from '../HTTPAPICallExecutor.js';
+/**
+ * Nowadays, most platforms include it as a global :
+ *
+ *   - Node : https://nodejs.org/api/globals.html#fetch
+ *   - RN   : https://reactnative.dev/docs/network#using-fetch
+ *   - Web  : https://developer.mozilla.org/fr/docs/Web/API/Fetch_API
+ *
+ * So we should be safe using it almost everywhere.
+ */
 export declare class FetchHTTPAPICallExecutor implements HTTPAPICallExecutor {
     fn<Res>(): HTTPAPICallExecutorFunc<Res>;
 }

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

@@ -5,8 +5,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { injectable } from 'inversify';
+/**
+ * Nowadays, most platforms include it as a global :
+ *
+ *   - Node : https://nodejs.org/api/globals.html#fetch
+ *   - RN   : https://reactnative.dev/docs/network#using-fetch
+ *   - Web  : https://developer.mozilla.org/fr/docs/Web/API/Fetch_API
+ *
+ * So we should be safe using it almost everywhere.
+ */
 let FetchHTTPAPICallExecutor = class FetchHTTPAPICallExecutor {
     fn() {
+        // The generalization in HTTPAPICallExecutor is not exactly the same as the actual implementation
+        // @ts-ignore
         return fetch;
     }
 };

package/dist/esm/std/impl/MistralAILLMManager.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 MistralAILLMManagerSettings extends Settings {
+    mai_api_key: ApiKey;
+}
+type S = MistralAILLMManagerSettings;
+export declare class MistralAILLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    private static BASE_URL;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): MistralAILLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};

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/NodeSpawnShellCommandExecutor.d.ts

@@ -0,0 +1,4 @@
+import type { ShellCommandExecutor, ShellCommandExecutorInput, ShellCommandExecutorOutput } from '../ShellCommandExecutor.js';
+export declare class NodeSpawnShellCommandExecutor implements ShellCommandExecutor {
+    exec({ bin, opts, }: ShellCommandExecutorInput): Promise<ShellCommandExecutorOutput>;
+}

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

@@ -0,0 +1,41 @@
+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;
+};
+import { spawn } from 'node:child_process';
+import { injectable } from 'inversify';
+let NodeSpawnShellCommandExecutor = class NodeSpawnShellCommandExecutor {
+    async exec({ bin, opts, }) {
+        return new Promise((resolve, reject) => {
+            let stderr = '';
+            let stdout = '';
+            const proc = spawn(bin, opts?.args || [], {
+                cwd: opts?.cwd,
+                env: opts?.env,
+            });
+            proc.stderr.on('data', (chunk) => {
+                stderr += chunk;
+            });
+            proc.stdout.on('data', (chunk) => {
+                stdout += chunk;
+            });
+            proc.stdout.on('error', (err) => {
+                reject(err);
+            });
+            proc.on('close', (code, signal) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(`Command failed with exit code (${code}), signal (${signal}), stderr (${stderr}) stdout (${stdout})`));
+                }
+            });
+        });
+    }
+};
+NodeSpawnShellCommandExecutor = __decorate([
+    injectable()
+], NodeSpawnShellCommandExecutor);
+export { NodeSpawnShellCommandExecutor };

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