@futdevpro/nts-dynamo 1.15.56 → 1.15.58

package/src/_modules/ai/_modules/open-ai/_services/oai-user-key.control-service.ts

@@ -1,157 +1,157 @@
-import { OpenAI } from 'openai';
-
-import { DyFM_AI_Provider, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_AI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai';
-import { DyFM_OAI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai/open-ai';
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_AI_UserKey_ServiceBase } from '../../../_services/ai-user-key.service-base';
-import { DyNTS_AI_TestGeneration_Result } from '../../../_models/ai-test-generation-result.interface';
-
-/**
- * OpenAI-specifikus user API key kezelo service
- *
- * A visszafejtett API kulcsbol OpenAI-specifikus konfigot allit ossze,
- * es teszteli a kapcsolatot az OpenAI API-val.
- */
-export class DyNTS_OAI_UserKey_ControlService extends DyNTS_AI_UserKey_ServiceBase {
-
-  static getInstance(): DyNTS_OAI_UserKey_ControlService {
-    return DyNTS_OAI_UserKey_ControlService.getSingletonInstance();
-  }
-
-  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.OpenAI;
-
-  /**
-   * OpenAI config osszeallitasa a visszafejtett kulcsbol
-   */
-  resolveConfig(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): DyFM_AI_Config {
-    const oaiConfig: DyFM_OAI_UserProviderConfig =
-      userProviderConfig as DyFM_OAI_UserProviderConfig;
-
-    return {
-      apiKey: decryptedApiKey,
-      organization: oaiConfig.organization,
-      project: oaiConfig.project,
-    };
-  }
-
-  /**
-   * OpenAI kapcsolat tesztelese a models.list() hivassal
-   */
-  async testConnection(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): Promise<boolean> {
-    try {
-      const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
-      const openai: OpenAI = new OpenAI({
-        apiKey: config.apiKey,
-        organization: config.organization,
-        project: config.project,
-      });
-
-      await openai.models.list();
-
-      return true;
-    } catch (error) {
-      DyFM_Log.error(
-        'DyNTS_OAI_UserKey_ControlService',
-        'testConnection',
-        'OpenAI connection test failed',
-        { error: error }
-      );
-
-      return false;
-    }
-  }
-
-  /**
-   * Elerheto OpenAI modellek lekerdezese
-   * Szuri a chat/LLM modelleket (nem embedding, nem whisper stb.)
-   */
-  async listAvailableModels(
-    userProviderConfig: DyFM_AI_UserProviderConfig,
-    decryptedApiKey: string
-  ): Promise<string[]> {
-    const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
-    const openai: OpenAI = new OpenAI({
-      apiKey: config.apiKey,
-      organization: config.organization,
-      project: config.project,
-    });
-
-    const models = await openai.models.list();
-
-    return models.data
-      .map((m) => m.id)
-      .filter((id: string) => this.isLLMModel(id))
-      .sort();
-  }
-
-  /**
-   * Teszt generalas az OpenAI API-val
-   */
-  async testGeneration(set: {
-    userProviderConfig: DyFM_AI_UserProviderConfig;
-    decryptedApiKey: string;
-    model: string;
-  }): Promise<DyNTS_AI_TestGeneration_Result> {
-    const startTime: number = Date.now();
-
-    try {
-      const config: DyFM_AI_Config = this.resolveConfig(
-        set.userProviderConfig,
-        set.decryptedApiKey
-      );
-      const openai: OpenAI = new OpenAI({
-        apiKey: config.apiKey,
-        organization: config.organization,
-        project: config.project,
-      });
-
-      const response = await openai.chat.completions.create({
-        model: set.model,
-        messages: [{ role: 'user', content: 'Hello, this is a test. Reply with "OK".' }],
-        max_tokens: 10,
-      });
-
-      return {
-        success: true,
-        response: response.choices[0]?.message?.content,
-        model: set.model,
-        latencyMs: Date.now() - startTime,
-      };
-    } catch (error) {
-      DyFM_Log.error(
-        'DyNTS_OAI_UserKey_ControlService',
-        'testGeneration',
-        'OpenAI test generation failed',
-        { error: error }
-      );
-
-      return {
-        success: false,
-        model: set.model,
-        latencyMs: Date.now() - startTime,
-      };
-    }
-  }
-
-  /**
-   * LLM/Chat modell szures -- kiszuri az embedding, whisper, tts stb. modelleket
-   */
-  private isLLMModel(modelId: string): boolean {
-    const excludePatterns: string[] = [
-      'embedding', 'whisper', 'tts', 'dall-e',
-      'moderation', 'davinci', 'babbage', 'ada',
-    ];
-
-    return !excludePatterns.some(
-      (pattern: string) => modelId.includes(pattern)
-    );
-  }
-}
+import { OpenAI } from 'openai';
+
+import { DyFM_AI_Provider, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_AI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_OAI_UserProviderConfig } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_AI_UserKey_ServiceBase } from '../../../_services/ai-user-key.service-base';
+import { DyNTS_AI_TestGeneration_Result } from '../../../_models/ai-test-generation-result.interface';
+
+/**
+ * OpenAI-specifikus user API key kezelo service
+ *
+ * A visszafejtett API kulcsbol OpenAI-specifikus konfigot allit ossze,
+ * es teszteli a kapcsolatot az OpenAI API-val.
+ */
+export class DyNTS_OAI_UserKey_ControlService extends DyNTS_AI_UserKey_ServiceBase {
+
+  static getInstance(): DyNTS_OAI_UserKey_ControlService {
+    return DyNTS_OAI_UserKey_ControlService.getSingletonInstance();
+  }
+
+  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.OpenAI;
+
+  /**
+   * OpenAI config osszeallitasa a visszafejtett kulcsbol
+   */
+  resolveConfig(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): DyFM_AI_Config {
+    const oaiConfig: DyFM_OAI_UserProviderConfig =
+      userProviderConfig as DyFM_OAI_UserProviderConfig;
+
+    return {
+      apiKey: decryptedApiKey,
+      organization: oaiConfig.organization,
+      project: oaiConfig.project,
+    };
+  }
+
+  /**
+   * OpenAI kapcsolat tesztelese a models.list() hivassal
+   */
+  async testConnection(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): Promise<boolean> {
+    try {
+      const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
+      const openai: OpenAI = new OpenAI({
+        apiKey: config.apiKey,
+        organization: config.organization,
+        project: config.project,
+      });
+
+      await openai.models.list();
+
+      return true;
+    } catch (error) {
+      DyFM_Log.error(
+        'DyNTS_OAI_UserKey_ControlService',
+        'testConnection',
+        'OpenAI connection test failed',
+        { error: error }
+      );
+
+      return false;
+    }
+  }
+
+  /**
+   * Elerheto OpenAI modellek lekerdezese
+   * Szuri a chat/LLM modelleket (nem embedding, nem whisper stb.)
+   */
+  async listAvailableModels(
+    userProviderConfig: DyFM_AI_UserProviderConfig,
+    decryptedApiKey: string
+  ): Promise<string[]> {
+    const config: DyFM_AI_Config = this.resolveConfig(userProviderConfig, decryptedApiKey);
+    const openai: OpenAI = new OpenAI({
+      apiKey: config.apiKey,
+      organization: config.organization,
+      project: config.project,
+    });
+
+    const models = await openai.models.list();
+
+    return models.data
+      .map((m) => m.id)
+      .filter((id: string) => this.isLLMModel(id))
+      .sort();
+  }
+
+  /**
+   * Teszt generalas az OpenAI API-val
+   */
+  async testGeneration(set: {
+    userProviderConfig: DyFM_AI_UserProviderConfig;
+    decryptedApiKey: string;
+    model: string;
+  }): Promise<DyNTS_AI_TestGeneration_Result> {
+    const startTime: number = Date.now();
+
+    try {
+      const config: DyFM_AI_Config = this.resolveConfig(
+        set.userProviderConfig,
+        set.decryptedApiKey
+      );
+      const openai: OpenAI = new OpenAI({
+        apiKey: config.apiKey,
+        organization: config.organization,
+        project: config.project,
+      });
+
+      const response = await openai.chat.completions.create({
+        model: set.model,
+        messages: [{ role: 'user', content: 'Hello, this is a test. Reply with "OK".' }],
+        max_tokens: 10,
+      });
+
+      return {
+        success: true,
+        response: response.choices[0]?.message?.content,
+        model: set.model,
+        latencyMs: Date.now() - startTime,
+      };
+    } catch (error) {
+      DyFM_Log.error(
+        'DyNTS_OAI_UserKey_ControlService',
+        'testGeneration',
+        'OpenAI test generation failed',
+        { error: error }
+      );
+
+      return {
+        success: false,
+        model: set.model,
+        latencyMs: Date.now() - startTime,
+      };
+    }
+  }
+
+  /**
+   * LLM/Chat modell szures -- kiszuri az embedding, whisper, tts stb. modelleket
+   */
+  private isLLMModel(modelId: string): boolean {
+    const excludePatterns: string[] = [
+      'embedding', 'whisper', 'tts', 'dall-e',
+      'moderation', 'davinci', 'babbage', 'ada',
+    ];
+
+    return !excludePatterns.some(
+      (pattern: string) => modelId.includes(pattern)
+    );
+  }
+}

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

@@ -0,0 +1,115 @@
+import { CreateEmbeddingResponse } from 'openai/resources';
+import { DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
+
+import {
+  DyNTS_AI_Embedding_MockService,
+  DyNTS_AI_MOCK_EMBEDDING_DIMS,
+} from './ai-embedding-mock.service';
+import { DyNTS_AI_CostEvent } from '../_models/interfaces/dynts-ai-cost-event.interface';
+
+describe('| DyNTS_AI_Embedding_MockService', () => {
+
+  const issuer: string = 'test-issuer';
+
+  describe('| determinism', () => {
+    it('| should return the same vector for the same (model, text)', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      const first: number[][] = (await service.createEmbeddings({ texts: ['hello'], model: 'm', issuer: issuer })) as number[][];
+      const second: number[][] = (await service.createEmbeddings({ texts: ['hello'], model: 'm', issuer: issuer })) as number[][];
+      expect(first[0]).toEqual(second[0]);
+    });
+
+    it('| should return different vectors for different texts', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      const result: number[][] = (await service.createEmbeddings({ texts: ['hello', 'world'], model: 'm', issuer: issuer })) as number[][];
+      expect(result[0]).not.toEqual(result[1]);
+    });
+
+    it('| should return different vectors for different models (re-embed scenario)', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      const a: number[][] = (await service.createEmbeddings({ texts: ['hello'], model: 'model-a', issuer: issuer })) as number[][];
+      const b: number[][] = (await service.createEmbeddings({ texts: ['hello'], model: 'model-b', issuer: issuer })) as number[][];
+      expect(a[0]).not.toEqual(b[0]);
+    });
+  });
+
+  describe('| dimensions', () => {
+    it('| should default to DyNTS_AI_MOCK_EMBEDDING_DIMS', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      const result: number[][] = (await service.createEmbeddings({ texts: ['x'], model: 'm', issuer: issuer })) as number[][];
+      expect(result[0].length).toBe(DyNTS_AI_MOCK_EMBEDDING_DIMS);
+    });
+
+    it('| should honour a configured dims', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService({ dims: 16 });
+      const result: number[][] = (await service.createEmbeddings({ texts: ['x'], model: 'm', issuer: issuer })) as number[][];
+      expect(result[0].length).toBe(16);
+    });
+
+    it('| should produce an l2-normalized vector (unit length)', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService({ dims: 32 });
+      const result: number[][] = (await service.createEmbeddings({ texts: ['vector'], model: 'm', issuer: issuer })) as number[][];
+      const norm: number = Math.sqrt(result[0].reduce((sum: number, v: number) => sum + v * v, 0));
+      expect(norm).toBeCloseTo(1, 6);
+    });
+  });
+
+  describe('| createEmbedding (single)', () => {
+    it('| should match the batch vector for the same text', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      const single: number[] = (await service.createEmbedding({ text: 'hi', model: 'm', issuer: issuer })) as number[];
+      const batch: number[][] = (await service.createEmbeddings({ texts: ['hi'], model: 'm', issuer: issuer })) as number[][];
+      expect(single).toEqual(batch[0]);
+    });
+
+    it('| should return a full OpenAI-shaped response when fullResponse is true', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService({ dims: 8 });
+      const response: CreateEmbeddingResponse = (await service.createEmbedding({
+        text: 'hi',
+        model: 'm',
+        fullResponse: true,
+        issuer: issuer,
+      })) as CreateEmbeddingResponse;
+      expect(response.object).toBe('list');
+      expect(response.data[0].embedding.length).toBe(8);
+      expect(response.usage.total_tokens).toBeGreaterThan(0);
+    });
+  });
+
+  describe('| cost-event', () => {
+    it('| should emit an embedding-batch cost-event with provider mock', async () => {
+      const events: DyNTS_AI_CostEvent[] = [];
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService({
+        onCostEvent: (event: DyNTS_AI_CostEvent) => events.push(event),
+      });
+      await service.createEmbeddings({ texts: ['abcd', 'efgh'], model: 'm', issuer: issuer });
+      expect(events.length).toBe(1);
+      expect(events[0].callType).toBe('embedding-batch');
+      expect(events[0].provider).toBe('mock');
+      expect(events[0].estimatedCostUsd).toBe(0);
+      expect(events[0].tokensUsed.input).toBeGreaterThan(0);
+    });
+
+    it('| should emit an embedding-single cost-event', async () => {
+      const events: DyNTS_AI_CostEvent[] = [];
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService({
+        onCostEvent: (event: DyNTS_AI_CostEvent) => events.push(event),
+      });
+      await service.createEmbedding({ text: 'hi', model: 'm', issuer: issuer });
+      expect(events[0].callType).toBe('embedding-single');
+    });
+  });
+
+  describe('| provider info + availability', () => {
+    it('| should report the LocalAI provider', () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      expect(service.aiProvider).toBe(DyFM_AI_Provider.LocalAI);
+      expect(service.getEmbeddingInfo('m')).toEqual({ provider: DyFM_AI_Provider.LocalAI, model: 'm' });
+    });
+
+    it('| should always be available', async () => {
+      const service: DyNTS_AI_Embedding_MockService = new DyNTS_AI_Embedding_MockService();
+      expect(await service.testConnection(issuer)).toBe(true);
+    });
+  });
+});

package/src/_modules/ai/_services/ai-embedding-mock.service.ts

@@ -0,0 +1,219 @@
+import * as crypto from 'crypto';
+
+import { CreateEmbeddingResponse } from 'openai/resources';
+import { DyFM_AI_Provider, DyFM_AI_ProviderCapabilities, DyFM_AI_Config } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_DAI_EmbeddingInfo } from '@futdevpro/fsm-dynamo/ai/document-ai';
+
+import { DyNTS_AI_Embedding_ServiceBase } from './ai-embedding.service-base';
+import { DyNTS_AI_CostEventCallback } from '../_models/interfaces/dynts-ai-cost-event-callback.interface';
+
+/** A mock-embedding default dimenziója (kicsi, hogy a teszt-pool gyors legyen, de elég a koszinuszhoz). */
+export const DyNTS_AI_MOCK_EMBEDDING_DIMS: number = 64;
+
+/**
+ * A mock embedding-service config-set-je. A `dims` a generált vektor dimenziója (default
+ * `DyNTS_AI_MOCK_EMBEDDING_DIMS`), az `onCostEvent` a per-call cost-event sink (FR-002 / BFR-AM-007).
+ */
+export interface DyNTS_AI_Embedding_MockSettings {
+  /** A generált vektor dimenziója (default `DyNTS_AI_MOCK_EMBEDDING_DIMS`). */
+  dims?: number;
+  /** Per-call cost-event callback (FR-002 / BFR-AM-007). Non-breaking: ha undefined, nincs emit. */
+  onCostEvent?: DyNTS_AI_CostEventCallback;
+}
+
+/**
+ * `DyNTS_AI_Embedding_MockService` (BFR-AM-008) — determinisztikus, hash-alapú, fix-dimenziós,
+ * l2-normalizált pszeudo-vektor a szövegből. Provider- és hálózat-mentes → a tesztek + a tsc-/offline-
+ * smoke valódi API-kulcs nélkül futnak. Azonos `(model, text)` → azonos vektor (idempotens), így a
+ * koszinusz-keresés determinisztikusan tesztelhető. A FAM `FAM_Mock_EmbeddingProvider` workaround-ját
+ * emeli bedrock-szintre, mint újrahasználható test-double.
+ *
+ * **Cost-event (BFR-AM-007):** minden call után `emitCostEvent`-tel jelez (fake token-fogyasztás,
+ * 4 char ≈ 1 token), provider `'mock'`, callType `embedding-single` / `embedding-batch`. Így a
+ * cost-aggregáló pipeline mock-providerrel is end-to-end tesztelhető.
+ */
+export class DyNTS_AI_Embedding_MockService extends DyNTS_AI_Embedding_ServiceBase {
+
+  /** A mock a `LocalAI` provider-enum alá tartozik (nincs külső hívás). */
+  readonly aiProvider: DyFM_AI_Provider = DyFM_AI_Provider.LocalAI;
+
+  /** A cost-event provider-string (a `DyNTS_AI_CostEvent.provider` szabad-string mezőjéhez). */
+  protected readonly costProvider: string = 'mock';
+
+  /** Mock capability-k: csak embedding (determinisztikus). */
+  readonly capabilities: DyFM_AI_ProviderCapabilities = {
+    chat: false,
+    embeddings: true,
+    imageGeneration: false,
+    vision: false,
+    audioGeneration: false,
+    audioAnalysis: false,
+    functionCalling: false,
+    streaming: false,
+    batchOperations: true,
+    supportedModelTypes: [],
+  };
+
+  /** A generált vektor dimenziója. */
+  protected dims: number;
+
+  /** @param set opcionális dims + onCostEvent. */
+  constructor(set?: DyNTS_AI_Embedding_MockSettings) {
+    super();
+    this.dims = set?.dims && set.dims > 0 ? set.dims : DyNTS_AI_MOCK_EMBEDDING_DIMS;
+    if (set?.onCostEvent) {
+      this.onCostEvent = set.onCostEvent;
+    }
+  }
+
+  /** A mock-nak nincs külső config-ja; a `setup` a dimenzió override-jára szolgál (config.dimensions). */
+  setup(config: DyFM_AI_Config): void {
+    const dims: unknown = Reflect.get(config ?? {}, 'dimensions');
+    if (typeof dims === 'number' && dims > 0) {
+      this.dims = dims;
+    }
+  }
+
+  /**
+   * Egy determinisztikus embedding. A `model`-t beleszövi a seed-be, hogy modell-váltás más vektort
+   * adjon (re-embed teszteléshez). `fullResponse=true` → OpenAI-alakú válasz-objektum.
+   */
+  async createEmbedding(
+    set: {
+      text: string;
+      model: string;
+      fullResponse?: boolean;
+      issuer: string;
+    }
+  ): Promise<number[] | CreateEmbeddingResponse> {
+    const start: number = Date.now();
+    const vector: number[] = this.deterministicVector(`${set.model}::${set.text ?? ''}`);
+    const durationMs: number = Date.now() - start;
+
+    this.emitMockCostEvent('embedding-single', set.model, [set.text ?? ''], durationMs, set.issuer);
+
+    if (set.fullResponse) {
+      return this.toResponse([vector], set.model, [set.text ?? '']);
+    }
+    return vector;
+  }
+
+  /**
+   * Determinisztikus batch-embedding: minden szöveghez a `(model, text)` seed-ből generál egy fix-
+   * dimenziós, l2-normalizált vektort. A `texts` sorrendje == a visszaadott `number[][]` sorrendje.
+   */
+  async createEmbeddings(
+    set: {
+      texts: string[];
+      model: string;
+      fullResponse?: boolean;
+      issuer: string;
+    }
+  ): Promise<number[][] | CreateEmbeddingResponse> {
+    const texts: string[] = set.texts ?? [];
+    const start: number = Date.now();
+    const vectors: number[][] = texts.map((text) => this.deterministicVector(`${set.model}::${text}`));
+    const durationMs: number = Date.now() - start;
+
+    this.emitMockCostEvent('embedding-batch', set.model, texts, durationMs, set.issuer);
+
+    if (set.fullResponse) {
+      return this.toResponse(vectors, set.model, texts);
+    }
+    return vectors;
+  }
+
+  /** Embedding model-info: provider `LocalAI`, model a megadott azonosító. */
+  getEmbeddingInfo(model: string): DyFM_DAI_EmbeddingInfo {
+    return {
+      provider: DyFM_AI_Provider.LocalAI,
+      model: model,
+    };
+  }
+
+  /** A mock mindig elérhető (nincs külső függőség). */
+  async testConnection(_issuer: string): Promise<boolean> {
+    return true;
+  }
+
+  // =========================================================================
+  // belső: determinisztikus vektor + cost-event + response-alak
+  // =========================================================================
+
+  /**
+   * Egy determinisztikus, l2-normalizált vektor a seed-ből. A SHA-256 hash bájtjait körkörösen
+   * használja a `dims` kitöltésére, [-1, 1) tartományra képzi, majd l2-normalizál (egységhossz a
+   * koszinuszhoz). Egy második hash-bájttal kever, hogy a hosszabb dimenziókon ne ismétlődjön a minta.
+   */
+  protected deterministicVector(seed: string): number[] {
+    const hash: Buffer = crypto.createHash('sha256').update(seed).digest();
+    const vector: number[] = [];
+    for (let i = 0; i < this.dims; i++) {
+      const byte: number = hash[i % hash.length];
+      const mix: number = hash[(i * 7 + 3) % hash.length];
+      const combined: number = (byte ^ mix) & 0xff;
+      vector.push((combined / 255) * 2 - 1);
+    }
+    return this.l2Normalize(vector);
+  }
+
+  /** L2-normalizálás (egységhossz). Nulla-vektor → változatlan (elkerüli a 0-osztást). */
+  protected l2Normalize(vector: number[]): number[] {
+    let sumSq: number = 0;
+    for (const value of vector) {
+      sumSq += value * value;
+    }
+    const norm: number = Math.sqrt(sumSq);
+    if (!norm) {
+      return vector;
+    }
+    return vector.map((value) => value / norm);
+  }
+
+  /** OpenAI-alakú válasz-objektum a vektorokból (a `fullResponse=true` ághoz). */
+  protected toResponse(vectors: number[][], model: string, texts: string[]): CreateEmbeddingResponse {
+    const tokens: number = this.estimateTokens(texts);
+    return {
+      object: 'list',
+      model: model,
+      data: vectors.map((embedding, index) => ({ object: 'embedding', embedding: embedding, index: index })),
+      usage: {
+        prompt_tokens: tokens,
+        total_tokens: tokens,
+      },
+    };
+  }
+
+  /** Cost-event emit (BFR-AM-007) fake tokennel (4 char ≈ 1 token), provider `'mock'`. */
+  protected emitMockCostEvent(
+    callType: 'embedding-single' | 'embedding-batch',
+    model: string,
+    texts: string[],
+    durationMs: number,
+    issuer: string,
+  ): void {
+    const tokens: number = this.estimateTokens(texts);
+    this.emitCostEvent({
+      callType: callType,
+      provider: this.costProvider,
+      model: model,
+      tokensUsed: {
+        input: tokens,
+        total: tokens,
+      },
+      durationMs: durationMs,
+      issuer: issuer,
+      timestamp: new Date(),
+      estimatedCostUsd: 0,
+    });
+  }
+
+  /** Becsült (fake) token-szám: 4 char ≈ 1 token. */
+  protected estimateTokens(texts: string[]): number {
+    let chars: number = 0;
+    for (const text of texts) {
+      chars += (text ?? '').length;
+    }
+    return Math.max(1, Math.ceil(chars / 4));
+  }
+}