@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/ai/_services/ai-provider.service-base.spec.ts

@@ -1,158 +0,0 @@
-
-import { DyNTS_AI_CostEvent } from '../_models/interfaces/dynts-ai-cost-event.interface';
-import { DyNTS_AI_CostEventCallback } from '../_models/interfaces/dynts-ai-cost-event-callback.interface';
-import { DyNTS_AI_Provider_ServiceBase } from './ai-provider.service-base';
-import { DyFM_AI_Provider, DyFM_AI_ProviderCapabilities, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
-
-class TestProviderService extends DyNTS_AI_Provider_ServiceBase {
-  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.OpenAI;
-  readonly capabilities: DyFM_AI_ProviderCapabilities = {
-    chat: true,
-    embeddings: true,
-    imageGeneration: false,
-    vision: false,
-    audioGeneration: false,
-    audioAnalysis: false,
-    functionCalling: false,
-    streaming: false,
-    batchOperations: false,
-    supportedModelTypes: [],
-  };
-
-  setup = (config: DyFM_AI_Config): void => {
-    // Mock implementation
-  };
-
-  testConnection = async (issuer: string): Promise<boolean> => {
-    return true;
-  };
-
-  /** Test-only helper: ráad egy callback-et a protected onCostEvent fielden át. */
-  public setOnCostEventForTest(cb: DyNTS_AI_CostEventCallback | undefined): void {
-    this.onCostEvent = cb;
-  }
-
-  /** Test-only helper: meghívja a protected emitCostEvent-et (a sub-class amúgy is hívná). */
-  public emitForTest(event: DyNTS_AI_CostEvent): void {
-    this.emitCostEvent(event);
-  }
-
-  static getInstance(): TestProviderService {
-    return TestProviderService.getSingletonInstance();
-  }
-}
-
-/** Helper: minimal valid DyNTS_AI_CostEvent. */
-function makeCostEvent(overrides: Partial<DyNTS_AI_CostEvent> = {}): DyNTS_AI_CostEvent {
-  return {
-    callType: 'embedding-single',
-    provider: 'openai',
-    model: 'text-embedding-3-small',
-    tokensUsed: { input: 10, total: 10 },
-    durationMs: 42,
-    issuer: 'test-issuer',
-    timestamp: new Date(),
-    ...overrides,
-  };
-}
-
-describe('| DyNTS_AI_Provider_ServiceBase', () => {
-  let service: TestProviderService;
-
-  beforeEach(() => {
-    service = TestProviderService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestProviderService.getInstance();
-    const instance2 = TestProviderService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestProviderService);
-  });
-
-  it('| should have aiProvider property', () => {
-    expect(service.aiProvider).toBe(DyFM_AI_Provider.OpenAI);
-  });
-
-  it('| should have capabilities property', () => {
-    expect(service.capabilities).toBeDefined();
-    expect(service.capabilities.chat).toBe(true);
-    expect(service.capabilities.embeddings).toBe(true);
-    expect(service.capabilities.chat).toBe(true);
-  });
-
-  describe('| setup', () => {
-    it('| should accept config parameter', () => {
-      const config: DyFM_AI_Config = {
-        apiKey: 'test-key',
-      };
-
-      expect(() => {
-        service.setup(config);
-      }).not.toThrow();
-    });
-  });
-
-  describe('| testConnection', () => {
-    it('| should return true when connection is successful', async () => {
-      const result = await service.testConnection('issuer-123');
-
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('| emitCostEvent (FR-002 cost-event hook)', () => {
-
-    afterEach(() => {
-      // Reset callback hogy ne szivárogjon át teszt-cases között (singleton service)
-      service.setOnCostEventForTest(undefined);
-    });
-
-    it('| should be no-op when onCostEvent is undefined', () => {
-      service.setOnCostEventForTest(undefined);
-
-      expect(() => {
-        service.emitForTest(makeCostEvent());
-      }).not.toThrow();
-    });
-
-    it('| should invoke the registered callback with the event payload', () => {
-      const received: DyNTS_AI_CostEvent[] = [];
-      service.setOnCostEventForTest((e: DyNTS_AI_CostEvent) => {
-        received.push(e);
-      });
-
-      const event: DyNTS_AI_CostEvent = makeCostEvent({
-        model: 'gpt-4o-mini',
-        callType: 'llm-completion',
-        tokensUsed: { input: 100, output: 50, total: 150 },
-      });
-      service.emitForTest(event);
-
-      expect(received.length).toBe(1);
-      expect(received[0]).toEqual(event);
-      expect(received[0].tokensUsed.total).toBe(150);
-    });
-
-    it('| should NOT throw when the callback itself throws (safe emit)', () => {
-      service.setOnCostEventForTest(() => {
-        throw new Error('consumer callback failure');
-      });
-
-      expect(() => {
-        service.emitForTest(makeCostEvent());
-      }).not.toThrow();
-    });
-
-    it('| should leave estimatedCostUsd undefined by default (Dynamo has no pricing registry)', () => {
-      const received: DyNTS_AI_CostEvent[] = [];
-      service.setOnCostEventForTest((e: DyNTS_AI_CostEvent) => { received.push(e); });
-
-      service.emitForTest(makeCostEvent());
-
-      expect(received[0].estimatedCostUsd).toBeUndefined();
-    });
-  });
-});
-

package/src/_modules/ai/_services/ai-provider.service-base.ts

@@ -1,67 +0,0 @@
-import { DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_AI_ProviderCapabilities } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_AI_CostEvent } from '../_models/interfaces/dynts-ai-cost-event.interface';
-import { DyNTS_AI_CostEventCallback } from '../_models/interfaces/dynts-ai-cost-event-callback.interface';
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
-
-/**
- * Abstract base class for all AI providers
- * Defines the common interface that all AI providers must implement
- *
- * **Cost-event hook (FR-002)**: a leszármazott concrete service-ek (OAI
- * Embedding / LLM / Chat) a constructor-ban opcionálisan kapnak egy
- * `onCostEvent` callback-et. Minden sikeres AI-call után `emitCostEvent`-tel
- * hívják, ami safe (try/catch) — a callback hibája NEM akasztja meg az
- * AI-call-t. Lásd `DyNTS_AI_CostEvent` interface.
- */
-export abstract class DyNTS_AI_Provider_ServiceBase extends DyNTS_SingletonService {
-  /** The AI provider this service represents */
-  abstract readonly aiProvider: DyFM_AI_Provider;
-
-  /** The capabilities supported by this provider */
-  abstract readonly capabilities: DyFM_AI_ProviderCapabilities;
-
-  /**
-   * Optional per-call cost-event callback (FR-002).
-   * A leszármazott service-ek minden sikeres AI-call után meghívják az
-   * `emitCostEvent` helper-en keresztül. Non-breaking: ha undefined, nincs emit.
-   */
-  protected onCostEvent?: DyNTS_AI_CostEventCallback;
-
-  /**
-   * Initialize the provider with configuration
-   * @param config - Provider-specific configuration
-   */
-  abstract setup(config: DyFM_AI_Config): void;
-
-  /**
-   * Test the connection to the AI provider
-   * @param issuer - The issuer making the request
-   * @returns Promise<boolean> - True if connection is successful
-   */
-  abstract testConnection(issuer: string): Promise<boolean>;
-
-  /**
-   * Safe cost-event emit: ha van regisztrált `onCostEvent` callback, meghívja.
-   * A callback hibája NEM propagálódik — try/catch-csel safen hívjuk és
-   * `DyFM_Log.warn`-nal jelezzük. Ezzel a consumer-oldali integráció
-   * (CCAP `CT_`, telemetry, stb.) hibái nem akasztják meg az AI-call-t.
-   */
-  protected emitCostEvent(event: DyNTS_AI_CostEvent): void {
-    if (!this.onCostEvent) {
-      return;
-    }
-    try {
-      this.onCostEvent(event);
-    } catch (err: unknown) {
-      const msg: string = err instanceof Error ? err.message : String(err);
-      DyFM_Log.warn(
-        `DyNTS AI | onCostEvent callback threw (call-type: ${event.callType},`
-        + ` model: ${event.model}, issuer: ${event.issuer}): ${msg}`,
-      );
-    }
-  }
-}

package/src/_modules/ai/_services/ai-user-key.service-base.ts

@@ -1,59 +0,0 @@
-import { DyFM_AI_Provider, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_AI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai';
-
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
-import { DyNTS_AI_TestGeneration_Result } from '../_models/ai-test-generation-result.interface';
-
-/**
- * Absztrakt bazis osztaly a user AI provider kulcs kezeleshez
- *
- * A titkositas/visszafejtes NEM itt tortenik -- azt az fdp-auth-service Auth_ControlService-e vegzi.
- * Ezek a service-ek a mar visszafejtett config-ot es API kulcsot kapjak,
- * es abbol allitjak ossze a provider-specifikus konfigot.
- */
-export abstract class DyNTS_AI_UserKey_ServiceBase extends DyNTS_SingletonService {
-  /** melyik provider-hez tartozik ez a service */
-  abstract readonly aiProvider: DyFM_AI_Provider;
-
-  /**
-   * Visszafejtett user config + kulcs -> provider-specifikus AI config osszeallitas
-   * @param userProviderConfig - a user provider konfiguracioja
-   * @param decryptedApiKey - a mar visszafejtett API kulcs
-   */
-  abstract resolveConfig(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): DyFM_AI_Config;
-
-  /**
-   * Kapcsolat tesztelese a provider-rel a visszafejtett kulccsal
-   * @param userProviderConfig - a user provider konfiguracioja
-   * @param decryptedApiKey - a mar visszafejtett API kulcs
-   */
-  abstract testConnection(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): Promise<boolean>;
-
-  /**
-   * Elerheto modellek lekerdezese a provider API-rol
-   * @param userProviderConfig - a user provider konfiguracioja
-   * @param decryptedApiKey - a mar visszafejtett API kulcs
-   */
-  abstract listAvailableModels(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): Promise<string[]>;
-
-  /**
-   * Teszt generalas a provider-rel
-   * @param set.userProviderConfig - a user provider konfiguracioja
-   * @param set.decryptedApiKey - a mar visszafejtett API kulcs
-   * @param set.model - a hasznalando modell
-   */
-  abstract testGeneration(set: {
-    userProviderConfig: DyFM_AI_UserProviderConfig;
-    decryptedApiKey: string;
-    model: string;
-  }): Promise<DyNTS_AI_TestGeneration_Result>;
-}

package/src/_modules/ai/_services/lmstudio-embedding.control-service.spec.ts

@@ -1,197 +0,0 @@
-import { CreateEmbeddingResponse } from 'openai/resources';
-import { DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_LMStudio_Embedding_ControlService } from './lmstudio-embedding.control-service';
-import { DyNTS_AI_CostEvent } from '../_models/interfaces/dynts-ai-cost-event.interface';
-
-describe('| DyNTS_LMStudio_Embedding_ControlService', () => {
-
-  const baseUrl: string = 'http://localhost:1234/v1';
-  const issuer: string = 'test-issuer';
-
-  /** Egy OpenAI-kompatibilis embeddings-válasz JSON-string-é csomagolva, fetch-mockhoz. */
-  function okResponse(embeddings: number[][], usage?: { prompt_tokens: number; total_tokens: number }): Response {
-    const body: string = JSON.stringify({
-      object: 'list',
-      data: embeddings.map((embedding, index) => ({ object: 'embedding', embedding: embedding, index: index })),
-      usage: usage,
-    });
-    return {
-      ok: true,
-      status: 200,
-      text: () => Promise.resolve(body),
-    } as Response;
-  }
-
-  /** Egy hibás (non-2xx) válasz fetch-mockhoz. */
-  function errorResponse(status: number, body: string): Response {
-    return {
-      ok: false,
-      status: status,
-      text: () => Promise.resolve(body),
-    } as Response;
-  }
-
-  let fetchSpy: jasmine.Spy;
-
-  beforeEach(() => {
-    fetchSpy = spyOn(globalThis, 'fetch');
-  });
-
-  describe('| constructor', () => {
-    it('| should throw a DyFM_Error if baseUrl is empty', () => {
-      expect(() => new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: '' })).toThrowMatching(
-        (error: unknown) => error instanceof DyFM_Error,
-      );
-    });
-
-    it('| should set provider to LocalAI', () => {
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      expect(service.aiProvider).toBe(DyFM_AI_Provider.LocalAI);
-      expect(service.capabilities.embeddings).toBe(true);
-    });
-  });
-
-  describe('| createEmbeddings', () => {
-    it('| should POST to ${baseUrl}/embeddings and return vectors in order', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.1, 0.2], [0.3, 0.4]])));
-
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      const result: number[][] | CreateEmbeddingResponse = await service.createEmbeddings({
-        texts: ['hello', 'world'],
-        model: 'nomic-embed-text-v1.5',
-        issuer: issuer,
-      });
-
-      expect(result).toEqual([[0.1, 0.2], [0.3, 0.4]]);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-      const url: string = fetchSpy.calls.mostRecent().args[0] as string;
-      expect(url).toBe('http://localhost:1234/v1/embeddings');
-      const init: RequestInit = fetchSpy.calls.mostRecent().args[1] as RequestInit;
-      expect(init.method).toBe('POST');
-      const sentBody: { model: string; input: string[] } = JSON.parse(init.body as string);
-      expect(sentBody.model).toBe('nomic-embed-text-v1.5');
-      expect(sentBody.input).toEqual(['hello', 'world']);
-    });
-
-    it('| should trim trailing slashes from baseUrl', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.5]])));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({
-        baseUrl: 'http://localhost:1234/v1///',
-      });
-      await service.createEmbeddings({ texts: ['x'], model: 'm', issuer: issuer });
-      expect(fetchSpy.calls.mostRecent().args[0]).toBe('http://localhost:1234/v1/embeddings');
-    });
-
-    it('| should add a Bearer header when apiKey is provided', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.5]])));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({
-        baseUrl: baseUrl,
-        apiKey: 'secret-token',
-      });
-      await service.createEmbeddings({ texts: ['x'], model: 'm', issuer: issuer });
-      const init: RequestInit = fetchSpy.calls.mostRecent().args[1] as RequestInit;
-      const headers: { [key: string]: string } = init.headers as { [key: string]: string };
-      expect(headers.Authorization).toBe('Bearer secret-token');
-    });
-
-    it('| should throw a DyFM_Error on a non-ok HTTP response', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(errorResponse(500, 'boom')));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-
-      await expectAsync(
-        service.createEmbeddings({ texts: ['x'], model: 'm', issuer: issuer }),
-      ).toBeRejectedWith(jasmine.any(DyFM_Error));
-    });
-
-    it('| should throw a DyFM_Error if the vector count does not match the text count', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.1]])));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-
-      await expectAsync(
-        service.createEmbeddings({ texts: ['a', 'b'], model: 'm', issuer: issuer }),
-      ).toBeRejectedWith(jasmine.any(DyFM_Error));
-    });
-
-    it('| should emit an embedding-batch cost-event with provider lm-studio', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.1], [0.2]], { prompt_tokens: 7, total_tokens: 7 })));
-      const events: DyNTS_AI_CostEvent[] = [];
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({
-        baseUrl: baseUrl,
-        onCostEvent: (event: DyNTS_AI_CostEvent) => events.push(event),
-      });
-
-      await service.createEmbeddings({ texts: ['a', 'b'], model: 'm', issuer: issuer });
-
-      expect(events.length).toBe(1);
-      expect(events[0].callType).toBe('embedding-batch');
-      expect(events[0].provider).toBe('lm-studio');
-      expect(events[0].model).toBe('m');
-      expect(events[0].tokensUsed.input).toBe(7);
-      expect(events[0].issuer).toBe(issuer);
-    });
-
-    it('| should estimate tokens when the endpoint provides no usage', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.1]])));
-      const events: DyNTS_AI_CostEvent[] = [];
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({
-        baseUrl: baseUrl,
-        onCostEvent: (event: DyNTS_AI_CostEvent) => events.push(event),
-      });
-
-      await service.createEmbeddings({ texts: ['abcdefgh'], model: 'm', issuer: issuer });
-
-      // 8 chars / 4 = 2 estimated tokens.
-      expect(events[0].tokensUsed.input).toBe(2);
-    });
-  });
-
-  describe('| createEmbedding (single)', () => {
-    it('| should emit an embedding-single cost-event and return a single vector', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.9, 0.8, 0.7]], { prompt_tokens: 3, total_tokens: 3 })));
-      const events: DyNTS_AI_CostEvent[] = [];
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({
-        baseUrl: baseUrl,
-        onCostEvent: (event: DyNTS_AI_CostEvent) => events.push(event),
-      });
-
-      const result: number[] | CreateEmbeddingResponse = await service.createEmbedding({
-        text: 'one',
-        model: 'm',
-        issuer: issuer,
-      });
-
-      expect(result).toEqual([0.9, 0.8, 0.7]);
-      expect(events[0].callType).toBe('embedding-single');
-    });
-
-    it('| should throw a DyFM_Error if text is empty', async () => {
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      await expectAsync(
-        service.createEmbedding({ text: '', model: 'm', issuer: issuer }),
-      ).toBeRejectedWith(jasmine.any(DyFM_Error));
-    });
-  });
-
-  describe('| testConnection', () => {
-    it('| should return true when the probe succeeds', async () => {
-      fetchSpy.and.returnValue(Promise.resolve(okResponse([[0.1, 0.2]])));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      expect(await service.testConnection(issuer)).toBe(true);
-    });
-
-    it('| should return false (never throw) when the probe fails', async () => {
-      fetchSpy.and.returnValue(Promise.reject(new Error('connection refused')));
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      expect(await service.testConnection(issuer)).toBe(false);
-    });
-  });
-
-  describe('| getEmbeddingInfo', () => {
-    it('| should report the LocalAI provider and the given model', () => {
-      const service: DyNTS_LMStudio_Embedding_ControlService = new DyNTS_LMStudio_Embedding_ControlService({ baseUrl: baseUrl });
-      expect(service.getEmbeddingInfo('my-model')).toEqual({ provider: DyFM_AI_Provider.LocalAI, model: 'my-model' });
-    });
-  });
-});