@mate-academy/llm-gateway 1.0.3 → 1.1.0

package/README.md

@@ -173,6 +173,383 @@ Supports both completion and assistance APIs. For more information, see [OpenAI
 
 Supports completion API through Google's Generative AI models. For more information, see [Google Generative AI documentation](https://ai.google.dev/docs).
 
+## Developer Guide: Adding a New Provider
+
+To add support for a new LLM provider, follow these steps:
+
+### 1. Create Provider Directory Structure
+
+Create a new directory in `src/providers` with your provider name, following the established pattern:
+
+```
+src/providers/YourProvider/
+├── index.ts                    # Entry point for provider exports
+├── YourProvider.constants.ts   # Provider-specific constants
+├── YourProvider.entity.ts      # Provider-specific entity
+├── YourProvider.typedefs.ts    # TypeScript definitions
+├── YourProviderService.factory.ts # Factory for your provider's services
+└── services/                   # Provider service implementations
+    ├── index.ts
+    ├── YourProviderCompletionService.ts
+    └── YourProviderAssistanceService.ts
+```
+
+### 2. Add Provider to LLM Providers Enum
+
+Update the LLM providers enum in `src/LLMService.typedefs.ts`:
+
+```typescript
+export enum LLMProviders {
+  OpenAI = 'openai',
+  GoogleGenerativeAI = 'google',
+  YourProvider = 'your-provider-id',
+}
+```
+
+### 3. Define Provider-Specific Types
+
+Create type definitions in `src/providers/YourProvider/YourProvider.typedefs.ts`:
+
+```typescript
+// Define model names as an enum for type safety
+export enum YourProviderModelNames {
+  MODEL_ONE = 'model-one',
+  MODEL_TWO = 'model-extended',
+}
+
+// Define message roles if applicable
+export enum YourProviderRoles {
+  User = 'user',
+  Assistant = 'assistant',
+  System = 'system',
+}
+
+// Add any other provider-specific enums or interfaces
+```
+
+Then ensure your provider is properly integrated in the main type system by updating the necessary type mappings in `src/LLMService.typedefs.ts`:
+
+```typescript
+// Add import for your provider's types
+import { type YourProviderModelNames } from './providers/YourProvider/YourProvider.typedefs';
+
+// Update the LLMProviders enum
+export enum LLMProviders {
+  OpenAI = 'OpenAI',
+  GoogleGenerativeAI = 'GoogleGenerativeAI',
+  YourProvider = 'YourProvider',
+}
+
+// Update LLMInstances type mapping
+export type LLMInstances = {
+  // ...existing code...
+  [LLMProviders.YourProvider]: YourProviderClient; // Your provider's client type
+};
+
+// Update LLMInstanceOptions type mapping
+export type LLMInstanceOptions = {
+  // ...existing code...
+  [LLMProviders.YourProvider]: {
+    apiKey: string;
+    // Add other provider-specific options
+  };
+};
+
+// Update LLMModelName type mapping
+export type LLMModelName = {
+  // ...existing code...
+  [LLMProviders.YourProvider]: YourProviderModelNames;
+};
+```
+
+### 4. Implement Provider Constants
+
+Define constants in `src/providers/YourProvider/YourProvider.constants.ts`:
+
+```typescript
+import {
+  type LLMProviderAvailableModels,
+  type LLMProviderModelsByPurpose,
+  type LLMProviders,
+  LLMPurposes,
+  type LLMServiceBuilder,
+} from '../../LLMService.typedefs';
+import { YourProviderModelNames } from './YourProvider.typedefs';
+import {
+  YourProviderAssistanceService,
+  YourProviderCompletionService,
+} from './services';
+import { pick } from '../../functional.utils';
+
+// Define available models with their capabilities and configurations
+const YOUR_PROVIDER_AVAILABLE_MODELS: LLMProviderAvailableModels<
+  LLMProviders.YourProvider
+> = {
+  [YourProviderModelNames.MODEL_ONE]: {
+    name: YourProviderModelNames.MODEL_ONE,
+    limits: {
+      maxInputTokens: 8_000,
+      maxOutputTokens: 2_000,
+    },
+    config: {
+      temperature: 0.2,
+    },
+  },
+  [YourProviderModelNames.MODEL_TWO]: {
+    name: YourProviderModelNames.MODEL_TWO,
+    limits: {
+      maxInputTokens: 16_000,
+      maxOutputTokens: 4_000,
+    },
+    config: {
+      temperature: 0.2,
+    },
+  },
+};
+
+// Specify which models are available for each purpose
+export const YOUR_PROVIDER_MODELS: LLMProviderModelsByPurpose<
+  LLMPurposes,
+  LLMProviders.YourProvider
+> = {
+  [LLMPurposes.Completion]: pick(
+    YOUR_PROVIDER_AVAILABLE_MODELS,
+    [
+      YourProviderModelNames.MODEL_ONE,
+      YourProviderModelNames.MODEL_TWO,
+    ],
+  ),
+  [LLMPurposes.Assistance]: pick(
+    YOUR_PROVIDER_AVAILABLE_MODELS,
+    [
+      YourProviderModelNames.MODEL_TWO, // Only MODEL_TWO supports assistance
+    ],
+  ),
+};
+
+// Define service builders for each LLM purpose
+export const YOUR_PROVIDER_SERVICE_BUILDERS: {
+  [purpose in LLMPurposes]: (
+    LLMServiceBuilder<LLMProviders.YourProvider, purpose> | null
+  )
+} = {
+  [LLMPurposes.Completion]: (logger, options) => (
+    new YourProviderCompletionService(logger, options)
+  ),
+  [LLMPurposes.Assistance]: (logger, options) => (
+    new YourProviderAssistanceService(logger, options)
+  ),
+};
+```
+
+### 5. Implement Provider Entity (if needed)
+
+Create the entity class in `src/providers/YourProvider/YourProvider.entity.ts`:
+
+```typescript
+export class YourProviderEntity {
+  // Implement provider-specific methods
+}
+```
+
+### 6. Implement Service Classes
+
+Create service implementations in the `services` directory:
+
+**CompletionService (src/providers/YourProvider/services/YourProviderCompletionService.ts)**:
+
+```typescript
+import { Logger } from '../../../LLMService.typedefs';
+import { LLMCompletionService } from '../../../services/LLMCompletionService.abstract';
+import { CompletionParams, CompletionResult, LLMProviders } from '../../../LLMService.typedefs';
+import { YourProviderEntity } from '../YourProvider.entity';
+
+export class YourProviderCompletionService extends LLMCompletionService<LLMProviders.YourProvider> {
+  constructor(
+    logger: Logger,
+    private readonly providerEntity: YourProviderEntity,
+  ) {
+    super(logger);
+  }
+
+  async complete(params: CompletionParams): Promise<CompletionResult> {
+    this.logger.info('Starting completion with YourProvider', { params });
+
+    try {
+      // Implement provider-specific completion logic
+
+      return {
+        text: 'Completed text',
+        // Include other required fields
+      };
+    } catch (error) {
+      this.logger.error('Error in YourProvider completion', { error });
+      throw error;
+    }
+  }
+}
+```
+
+**AssistanceService (if applicable)**:
+
+```typescript
+import { Logger } from '../../../LLMService.typedefs';
+import { LLMAssistanceService } from '../../../services/LLMAssistanceService.abstract';
+import {
+  AssistantParams,
+  ThreadParams,
+  MessageParams,
+  LLMProviders
+} from '../../../LLMService.typedefs';
+import { YourProviderEntity } from '../YourProvider.entity';
+
+export class YourProviderAssistanceService extends LLMAssistanceService<LLMProviders.YourProvider> {
+  constructor(
+    logger: Logger,
+    private readonly providerEntity: YourProviderEntity,
+  ) {
+    super(logger);
+  }
+
+  // Implement required assistance methods
+}
+```
+
+### 7. Create Service Factory
+
+First, define service builders in `src/providers/YourProvider/YourProvider.constants.ts`:
+
+```typescript
+import {
+  LLMPurposes,
+  type LLMServiceBuilder,
+} from '../../LLMService.typedefs';
+import {
+  YourProviderAssistanceService,
+  YourProviderCompletionService,
+} from './services';
+
+export const YOUR_PROVIDER_SERVICE_BUILDERS: {
+  [purpose in LLMPurposes]: (
+    LLMServiceBuilder<LLMProviders.YourProvider, purpose> | null
+  )
+} = {
+  [LLMPurposes.Completion]: (logger, options) => (
+    new YourProviderCompletionService(logger, options)
+  ),
+  [LLMPurposes.Assistance]: (logger, options) => (
+    new YourProviderAssistanceService(logger, options)
+  ),
+};
+```
+
+Then, implement the service factory in `src/providers/YourProvider/YourProviderService.factory.ts`:
+
+```typescript
+import { type Logger } from '@mate-academy/core';
+import {
+  type LLMInstanceOptions,
+  LLMProviders,
+  type LLMPurposes,
+  type LLMServiceByPurpose,
+} from '../../LLMService.typedefs';
+import { LLMServicePurposeFactory } from '../../services';
+import { YOUR_PROVIDER_SERVICE_BUILDERS } from './YourProvider.constants';
+
+export class YourProviderServiceFactory extends LLMServicePurposeFactory<
+  LLMProviders.YourProvider
+> {
+  createService<
+    Purpose extends LLMPurposes
+  >(
+    purpose: Purpose,
+    logger: Logger,
+    options: LLMInstanceOptions[LLMProviders.YourProvider],
+  ): LLMServiceByPurpose<LLMProviders.YourProvider>[Purpose] {
+    const serviceBuilder = YOUR_PROVIDER_SERVICE_BUILDERS[purpose];
+
+    if (!serviceBuilder) {
+      throw new Error(`Purpose [${purpose}] is not supported for [${LLMProviders.YourProvider}] service`);
+    }
+
+    return serviceBuilder(logger, options);
+  }
+}
+```
+
+### 8. Update Entry Point Files
+
+Update the provider's `index.ts`:
+
+```typescript
+export * from './YourProvider.constants';
+export * from './YourProvider.entity';
+export * from './YourProvider.typedefs';
+export * from './YourProviderService.factory';
+export * from './services';
+```
+
+Update the main providers `index.ts` at `src/providers/index.ts`:
+
+```typescript
+// ... other providers
+export * from './YourProvider';
+```
+
+### 9. Update LLM Service Factory
+
+Modify `src/LLMService.factory.ts` to include your new provider:
+
+```typescript
+import {
+  LLMProviders,
+  Logger,
+  YourProviderOptions,
+} from './LLMService.typedefs';
+import { YourProviderServiceFactory } from './providers/YourProvider';
+import { YourProviderOptions } from './providers/YourProvider/YourProvider.typedefs';
+
+export class LLMServiceFactory {
+  static resolveProviderOptions<T extends LLMProviders>(
+    provider: T,
+    optionsMap: {
+      // ... other providers
+      [LLMProviders.YourProvider]?: YourProviderOptions;
+    },
+  ) {
+    return optionsMap[provider];
+  }
+
+  static getCompletionService<T extends LLMProviders>(
+    provider: T,
+    logger: Logger,
+    options: any,
+  ) {
+    switch (provider) {
+      // ... other providers
+      case LLMProviders.YourProvider:
+        return YourProviderServiceFactory.createCompletionService(logger, options);
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+
+  static getAssistanceService<T extends LLMProviders>(
+    provider: T,
+    logger: Logger,
+    options: any,
+  ) {
+    switch (provider) {
+      // ... other providers
+      case LLMProviders.YourProvider:
+        return YourProviderServiceFactory.createAssistanceService(logger, options);
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+}
+```
+
 ## License
 
 [MIT](LICENSE)

package/dist/LLMService.constants.js

@@ -1,16 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLM_SERVICE_MODELS = exports.LLM_SERVICE_FACTORIES = void 0;
-const LLMService_typedefs_1 = require("./LLMService.typedefs");
-const providers_1 = require("./providers");
-const GoogleGenerativeAI_constants_1 = require("./providers/GoogleGenerativeAI/GoogleGenerativeAI.constants");
-const OpenAI_constants_1 = require("./providers/OpenAI/OpenAI.constants");
-exports.LLM_SERVICE_FACTORIES = {
-    [LLMService_typedefs_1.LLMProviders.OpenAI]: new providers_1.OpenAIServiceFactory(),
-    [LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI]: new providers_1.GoogleGenerativeAIServiceFactory(),
-};
-exports.LLM_SERVICE_MODELS = {
-    [LLMService_typedefs_1.LLMProviders.OpenAI]: OpenAI_constants_1.OPEN_AI_MODELS,
-    [LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI]: GoogleGenerativeAI_constants_1.GOOGLE_AI_MODELS,
-};
-//# sourceMappingURL=LLMService.constants.js.map
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LLM_SERVICE_MODELS=exports.LLM_SERVICE_FACTORIES=void 0;const LLMService_typedefs_1=require("./LLMService.typedefs"),providers_1=require("./providers"),GoogleGenerativeAI_constants_1=require("./providers/GoogleGenerativeAI/GoogleGenerativeAI.constants"),OpenAI_constants_1=require("./providers/OpenAI/OpenAI.constants");exports.LLM_SERVICE_FACTORIES={[LLMService_typedefs_1.LLMProviders.OpenAI]:new providers_1.OpenAIServiceFactory,[LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI]:new providers_1.GoogleGenerativeAIServiceFactory},exports.LLM_SERVICE_MODELS={[LLMService_typedefs_1.LLMProviders.OpenAI]:OpenAI_constants_1.OPEN_AI_MODELS,[LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI]:GoogleGenerativeAI_constants_1.GOOGLE_AI_MODELS};

package/dist/LLMService.entity.js

@@ -1,38 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMServiceEntity = void 0;
-const LLMService_typedefs_1 = require("./LLMService.typedefs");
-class LLMServiceEntity {
-    static countTokensFallback(messages) {
-        const message = messages.join('');
-        const basicTokens = message.split(/[\s,.;!?(){}[\]<>%&]+/).filter(Boolean);
-        const subwordTokens = basicTokens.flatMap((token) => (token.split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-zA-Z])(?=\d)|(?<=[\d])(?=[a-zA-Z])/)));
-        return Promise.resolve(subwordTokens.length);
-    }
-    static async combineMessagesWithLimit({ modelContext = [], history = [], message, model, countTokensFn = this.countTokensFallback, }) {
-        const combinedMessages = [...modelContext];
-        if (history[0]) {
-            const firstHistoryMessage = history[0];
-            combinedMessages.push(firstHistoryMessage);
-        }
-        const messagesToConsider = [
-            { role: LLMService_typedefs_1.LLMRoles.User, content: message },
-            ...history.slice(1).reverse(),
-        ];
-        const messages = combinedMessages.map((combinedMessage) => combinedMessage.content);
-        let tokenCount = await countTokensFn(messages, model);
-        for (const msg of messagesToConsider) {
-            const tempTokenCount = tokenCount + (await countTokensFn([msg.content], model));
-            if (tempTokenCount <= model.limits.maxInputTokens) {
-                combinedMessages.push(msg);
-                tokenCount = tempTokenCount;
-            }
-            else {
-                break;
-            }
-        }
-        return combinedMessages;
-    }
-}
-exports.LLMServiceEntity = LLMServiceEntity;
-//# sourceMappingURL=LLMService.entity.js.map
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LLMServiceEntity=void 0;const LLMService_typedefs_1=require("./LLMService.typedefs");class LLMServiceEntity{static countTokensFallback(e){const t=e.join("").split(/[\s,.;!?(){}[\]<>%&]+/).filter(Boolean).flatMap((e=>e.split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-zA-Z])(?=\d)|(?<=[\d])(?=[a-zA-Z])/)));return Promise.resolve(t.length)}static async combineMessagesWithLimit({modelContext:e=[],history:t=[],message:s,model:o,countTokensFn:i=this.countTokensFallback}){const n=[...e];if(t[0]){const e=t[0];n.push(e)}const c=[{role:LLMService_typedefs_1.LLMRoles.User,content:s},...t.slice(1).reverse()],r=n.map((e=>e.content));let a=await i(r,o);for(const e of c){const t=a+await i([e.content],o);if(!(t<=o.limits.maxInputTokens))break;n.push(e),a=t}return n}}exports.LLMServiceEntity=LLMServiceEntity;

package/dist/LLMService.factory.js

@@ -1,71 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMServiceFactory = void 0;
-const LLMService_typedefs_1 = require("./LLMService.typedefs");
-const LLMService_constants_1 = require("./LLMService.constants");
-class LLMServiceFactory {
-    /**
-     * Gets a service for the specified LLM purpose and provider
-     *
-     * @private
-     * @static
-     * @template Purpose - The purpose of the LLM service (Completion or Assistance)
-     * @template Provider - The LLM provider (OpenAI, GoogleGenerativeAI)
-     * @param {Purpose} purpose - The purpose of the service
-     * @param {Provider} provider - The LLM provider
-     * @param {Logger} logger - Logger instance
-     * @param {LLMInstanceOptions[Provider]} options - Provider-specific options
-     * @returns {LLMServiceByPurpose<Provider>[Purpose]} The LLM service instance
-     * @throws {Error} If the provider is not supported
-     */
-    static getService(purpose, provider, logger, options) {
-        switch (provider) {
-            case LLMService_typedefs_1.LLMProviders.OpenAI:
-            case LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI:
-                return LLMService_constants_1.LLM_SERVICE_FACTORIES[provider]
-                    .createService(purpose, logger, options);
-            default:
-                throw new Error(`Provider [${provider}] is not supported`);
-        }
-    }
-    /**
-     * Gets a completion service for the specified LLM provider
-     *
-     * @static
-     * @template Provider - The LLM provider type
-     * @param {Provider} provider - The LLM provider (OpenAI, GoogleGenerativeAI)
-     * @param {Logger} logger - Logger instance
-     * @param {LLMInstanceOptions[Provider]} options - Provider-specific options
-     * @returns {LLMServiceByPurpose<Provider>[LLMPurposes.Completion]} A completion service instance
-     */
-    static getCompletionService(provider, logger, options) {
-        return this.getService(LLMService_typedefs_1.LLMPurposes.Completion, provider, logger, options);
-    }
-    /**
-     * Gets an assistance service for the specified LLM provider
-     *
-     * @static
-     * @template Provider - The LLM provider type
-     * @param {Provider} provider - The LLM provider (OpenAI, GoogleGenerativeAI)
-     * @param {Logger} logger - Logger instance
-     * @param {LLMInstanceOptions[Provider]} options - Provider-specific options
-     * @returns {LLMServiceByPurpose<Provider>[LLMPurposes.Assistance]} An assistance service instance
-     */
-    static getAssistanceService(provider, logger, options) {
-        return this.getService(LLMService_typedefs_1.LLMPurposes.Assistance, provider, logger, options);
-    }
-    /**
-     * Resolves the options for the specified provider from an options map
-     *
-     * @static
-     * @template Provider - The LLM provider type
-     * @param {Provider} provider - The LLM provider to get options for
-     * @param {Record<Provider, LLMInstanceOptions[Provider]>} options - Map of provider options
-     * @returns {LLMInstanceOptions[Provider]} The options for the specified provider
-     */
-    static resolveProviderOptions(provider, options) {
-        return options[provider];
-    }
-}
-exports.LLMServiceFactory = LLMServiceFactory;
-//# sourceMappingURL=LLMService.factory.js.map
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.LLMServiceFactory=void 0;const LLMService_typedefs_1=require("./LLMService.typedefs"),LLMService_constants_1=require("./LLMService.constants");class LLMServiceFactory{static getService(e,r,t,s){switch(r){case LLMService_typedefs_1.LLMProviders.OpenAI:case LLMService_typedefs_1.LLMProviders.GoogleGenerativeAI:return LLMService_constants_1.LLM_SERVICE_FACTORIES[r].createService(e,t,s);default:throw new Error(`Provider [${r}] is not supported`)}}static getCompletionService(e,r,t){return this.getService(LLMService_typedefs_1.LLMPurposes.Completion,e,r,t)}static getAssistanceService(e,r,t){return this.getService(LLMService_typedefs_1.LLMPurposes.Assistance,e,r,t)}static resolveProviderOptions(e,r){return r[e]}}exports.LLMServiceFactory=LLMServiceFactory;

package/dist/LLMService.typedefs.js

@@ -1,36 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLMUploadFileMimeTypes = exports.LLMRoles = exports.LLMPurposes = exports.LLMProviders = void 0;
-/**
- * Enum of supported LLM providers.
- */
-var LLMProviders;
-(function (LLMProviders) {
-    LLMProviders["OpenAI"] = "OpenAI";
-    LLMProviders["GoogleGenerativeAI"] = "GoogleGenerativeAI";
-})(LLMProviders || (exports.LLMProviders = LLMProviders = {}));
-/**
- * Supported service purposes/types that the LLM gateway provides.
- */
-var LLMPurposes;
-(function (LLMPurposes) {
-    LLMPurposes["Completion"] = "completion";
-    LLMPurposes["Assistance"] = "assistance";
-})(LLMPurposes || (exports.LLMPurposes = LLMPurposes = {}));
-/**
- * Roles that can be assigned to messages in an LLM conversation.
- */
-var LLMRoles;
-(function (LLMRoles) {
-    LLMRoles["User"] = "user";
-    LLMRoles["Assistant"] = "assistant";
-})(LLMRoles || (exports.LLMRoles = LLMRoles = {}));
-/**
- * Supported MIME types for files that can be uploaded to LLM services.
- */
-var LLMUploadFileMimeTypes;
-(function (LLMUploadFileMimeTypes) {
-    LLMUploadFileMimeTypes["PNG"] = "image/png";
-    LLMUploadFileMimeTypes["PLAIN_TEXT"] = "text/plain";
-})(LLMUploadFileMimeTypes || (exports.LLMUploadFileMimeTypes = LLMUploadFileMimeTypes = {}));
-//# sourceMappingURL=LLMService.typedefs.js.map
+"use strict";var LLMProviders,LLMPurposes,LLMRoles,LLMUploadFileMimeTypes;Object.defineProperty(exports,"__esModule",{value:!0}),exports.LLMUploadFileMimeTypes=exports.LLMRoles=exports.LLMPurposes=exports.LLMProviders=void 0,function(e){e.OpenAI="OpenAI",e.GoogleGenerativeAI="GoogleGenerativeAI"}(LLMProviders||(exports.LLMProviders=LLMProviders={})),function(e){e.Completion="completion",e.Assistance="assistance"}(LLMPurposes||(exports.LLMPurposes=LLMPurposes={})),function(e){e.User="user",e.Assistant="assistant"}(LLMRoles||(exports.LLMRoles=LLMRoles={})),function(e){e.PNG="image/png",e.PLAIN_TEXT="text/plain"}(LLMUploadFileMimeTypes||(exports.LLMUploadFileMimeTypes=LLMUploadFileMimeTypes={}));

package/dist/functional.utils.js

@@ -1,9 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pick = void 0;
-const pick = (obj, keys) => (keys.reduce((acc, key) => {
-    Object.assign(acc, { [key]: obj[key] });
-    return acc;
-}, {}));
-exports.pick = pick;
-//# sourceMappingURL=functional.utils.js.map
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.pick=void 0;const pick=(e,c)=>c.reduce(((c,s)=>(Object.assign(c,{[s]:e[s]}),c)),{});exports.pick=pick;

package/dist/index.js

@@ -1,23 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./LLMService.constants"), exports);
-__exportStar(require("./LLMService.entity"), exports);
-__exportStar(require("./LLMService.factory"), exports);
-__exportStar(require("./LLMService.typedefs"), exports);
-__exportStar(require("./providers"), exports);
-__exportStar(require("./services"), exports);
-//# sourceMappingURL=index.js.map
+"use strict";var __createBinding=this&&this.__createBinding||(Object.create?function(e,r,t,i){void 0===i&&(i=t);var o=Object.getOwnPropertyDescriptor(r,t);o&&!("get"in o?!r.__esModule:o.writable||o.configurable)||(o={enumerable:!0,get:function(){return r[t]}}),Object.defineProperty(e,i,o)}:function(e,r,t,i){void 0===i&&(i=t),e[i]=r[t]}),__exportStar=this&&this.__exportStar||function(e,r){for(var t in e)"default"===t||Object.prototype.hasOwnProperty.call(r,t)||__createBinding(r,e,t)};Object.defineProperty(exports,"__esModule",{value:!0}),__exportStar(require("./LLMService.constants"),exports),__exportStar(require("./LLMService.entity"),exports),__exportStar(require("./LLMService.factory"),exports),__exportStar(require("./LLMService.typedefs"),exports),__exportStar(require("./providers"),exports),__exportStar(require("./services"),exports);