@futdevpro/nts-dynamo 1.15.104 → 1.15.107

package/src/_modules/ai/_modules/ai-mock/_collections/aim-fixture-serializer.util.spec.ts

@@ -0,0 +1,56 @@
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_FixtureSerializer_Util } from './aim-fixture-serializer.util';
+
+describe('| DyNTS_AIMock_FixtureSerializer_Util', () => {
+
+  function fixture(model: string, inputHash: string): DyNTS_AIMock_Fixture {
+    return {
+      provider: 'open-ai',
+      model: model,
+      modality: DyNTS_AIMock_Modality.text,
+      input: 'ping',
+      inputHash: inputHash,
+      output: 'pong',
+      capturedAt: '2026-07-21T00:00:00.000Z',
+    };
+  }
+
+  it('| determinisztikus: a fixture-ok SORRENDJETOL fuggetlenul azonos kimenet', () => {
+    const a: DyNTS_AIMock_Fixture[] = [ fixture('m-b', 'h2'), fixture('m-a', 'h1') ];
+    const b: DyNTS_AIMock_Fixture[] = [ fixture('m-a', 'h1'), fixture('m-b', 'h2') ];
+
+    const first: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: a });
+    const second: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: b });
+
+    expect(first).toBe(second);
+  });
+
+  it('| az objektum-kulcsok abc-sorrendben jonnek ki (stabil diff)', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({
+      constName: 'X',
+      fixtures: [ fixture('m-a', 'h1') ],
+    });
+
+    expect(output.indexOf('"capturedAt"')).toBeLessThan(output.indexOf('"input"'));
+    expect(output.indexOf('"input"')).toBeLessThan(output.indexOf('"model"'));
+    expect(output.indexOf('"model"')).toBeLessThan(output.indexOf('"provider"'));
+  });
+
+  it('| valid TS-konstans vazat ad (import + export const + tipus)', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({
+      constName: 'DyNTS_AIMock_TestFixtures',
+      fixtures: [ fixture('m-a', 'h1') ],
+    });
+
+    expect(output).toContain(`from '@futdevpro/nts-dynamo/ai/ai-mock'`);
+    expect(output).toContain('export const DyNTS_AIMock_TestFixtures: DyNTS_AIMock_Fixture[] = [');
+    expect(output.trim().endsWith('];')).toBe(true);
+  });
+
+  it('| ures keszlet → ures tomb-literal', () => {
+    const output: string = DyNTS_AIMock_FixtureSerializer_Util.toConstantFile({ constName: 'X', fixtures: [] });
+
+    expect(output).toContain('export const X: DyNTS_AIMock_Fixture[] = [');
+  });
+});

package/src/_modules/ai/_modules/ai-mock/_collections/aim-fixture-serializer.util.ts

@@ -0,0 +1,107 @@
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+
+/**
+ * Beegetett fixture-ok **determinisztikus** TS-konstans fajlla alakitasa (D6: git-tracked, NEM env-fuggo).
+ *
+ * A determinizmus itt nem kozmetika: a fixture-fajlok verziokezeltek, ezert ugyanaz a fixture-keszlet
+ * MINDIG ugyanazt a fajl-tartalmat kell adja — kulonben minden ujra-generalas zajos diff-et okoz, es a
+ * code-review hasznalhatatlanna valik. Ezert: a fixture-ok **match-kulcs szerint rendezve**, az objektum-
+ * kulcsok pedig **rekurzivan abc-sorrendben** kerulnek ki.
+ */
+export class DyNTS_AIMock_FixtureSerializer_Util {
+
+  /** Behuzas egy szintje. */
+  private static readonly indentUnit: string = '  ';
+
+  /**
+   * Fixture-tomb → teljes TS-konstans fajl tartalma (import + export const + JSDoc-fejlec).
+   * @param set - a konstans neve + a fixture-ok + opcionalis fejlec-megjegyzes
+   */
+  static toConstantFile(
+    set: {
+      constName: string,
+      fixtures: DyNTS_AIMock_Fixture[],
+      headerNote?: string,
+    }
+  ): string {
+    const sorted: DyNTS_AIMock_Fixture[] = this.sortFixtures(set.fixtures);
+    const body: string = sorted
+      .map((fixture: DyNTS_AIMock_Fixture) => this.stringify(fixture, this.indentUnit))
+      .join(',\n');
+
+    const note: string = set.headerNote ?? 'Auto-generalt fixture-keszlet — kezzel NE szerkeszd.';
+
+    return [
+      `import { DyNTS_AIMock_Fixture } from '@futdevpro/nts-dynamo/ai/ai-mock';`,
+      '',
+      '/**',
+      ` * ${note}`,
+      ' *',
+      ' * Determinisztikus sorrend (match-kulcs szerint) + rendezett objektum-kulcsok, hogy az ujra-generalas',
+      ' * ne okozzon zajos diff-et. Forras: `DyNTS_AIMock_FixtureSerializer_Util`.',
+      ' */',
+      `export const ${set.constName}: DyNTS_AIMock_Fixture[] = [`,
+      body,
+      '];',
+      '',
+    ].join('\n');
+  }
+
+  /** Fixture-ok stabil rendezese (provider|model|modality|inputHash). */
+  private static sortFixtures(fixtures: DyNTS_AIMock_Fixture[]): DyNTS_AIMock_Fixture[] {
+    return [ ...fixtures ].sort((a: DyNTS_AIMock_Fixture, b: DyNTS_AIMock_Fixture) => {
+      return this.sortKeyOf(a).localeCompare(this.sortKeyOf(b));
+    });
+  }
+
+  /** A rendezesi kulcs egy fixture-hoz. */
+  private static sortKeyOf(fixture: DyNTS_AIMock_Fixture): string {
+    return `${fixture.provider}|${fixture.model}|${fixture.modality}|${fixture.inputHash}`;
+  }
+
+  /**
+   * Rekurziv, kulcs-rendezett stringify (a `JSON.stringify` a beszurasi sorrendet tartana meg — az nem stabil).
+   * @param value - a szerializalando ertek
+   * @param indent - az aktualis behuzas
+   */
+  private static stringify(value: unknown, indent: string): string {
+    if (value === null || value === undefined) {
+      return `${indent}null`;
+    }
+
+    if (Array.isArray(value)) {
+      if (!value.length) {
+        return `${indent}[]`;
+      }
+      const items: string = value
+        .map((item: unknown) => this.stringify(item, indent + this.indentUnit))
+        .join(',\n');
+
+      return `${indent}[\n${items}\n${indent}]`;
+    }
+
+    if (typeof value === 'object') {
+      // `Object.entries` a generikus `object`-en is mukodik → nincs szukseg `as`-castra.
+      const source: Map<string, unknown> = new Map(Object.entries(value));
+      const keys: string[] = [ ...source.keys() ]
+        .filter((key: string) => source.get(key) !== undefined)
+        .sort();
+
+      if (!keys.length) {
+        return `${indent}{}`;
+      }
+
+      const entries: string = keys
+        .map((key: string) => {
+          const rendered: string = this.stringify(source.get(key), indent + this.indentUnit).trimStart();
+
+          return `${indent}${this.indentUnit}${JSON.stringify(key)}: ${rendered}`;
+        })
+        .join(',\n');
+
+      return `${indent}{\n${entries}\n${indent}}`;
+    }
+
+    return `${indent}${JSON.stringify(value)}`;
+  }
+}

package/src/_modules/ai/_modules/ai-mock/_enums/aim-modality.enum.ts

@@ -0,0 +1,15 @@
+/**
+ * Az AI-mock által kezelt modalitások. A mock MINDEN modalitásra ugyanazt a replay / reject-on-unknown
+ * viselkedést adja (l. `documentations/plans/ai-mocking-system/HYPERPLAN.md` D3). A `value` a beégetett
+ * fixture-ök + a match-kulcs modality-szegmense.
+ */
+export enum DyNTS_AIMock_Modality {
+  /** Szöveg-completion (chat / LLM). */
+  text = 'text',
+  /** Embedding-vektor kimenet. */
+  embedding = 'embedding',
+  /** Kép-generálás (base64 kimenet). */
+  image = 'image',
+  /** Hang: transcription (audio→szöveg) vagy TTS (szöveg→base64-audio). */
+  audio = 'audio',
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-call-input.interface.ts

@@ -0,0 +1,14 @@
+/**
+ * Egy mock modalitás-hívás bemenete — a modalitást a hívott metódus adja (`chatCompletion` → text stb.),
+ * ezért itt NINCS `modality` mező (v.ö. `DyNTS_AIMock_Request`, ami a teljes match-kulcs bemenete).
+ */
+export interface DyNTS_AIMock_CallInput {
+  /** Provider-azonosító (pl. 'open-ai'). */
+  provider: string;
+  /** Pontos API modell-azonosító (pl. 'gpt-4o-mini'). */
+  model: string;
+  /** Provider-specifikus config-paraméterek. */
+  config?: Record<string, unknown>;
+  /** Modalitás-függő bemenet. */
+  input: unknown;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-error.interface.ts

@@ -0,0 +1,11 @@
+import { DyNTS_AI_ProviderError } from '../../../../_models/interfaces/dynts-ai-provider-error.interface';
+
+/**
+ * Provider-faithful hiba egy fixture-höz — a mock UGYANEZT reprodukálja, mintha a valódi provider dobná
+ * (pl. reasoning-modell + `temperature` → OpenAI HTTP 400 `unsupported_parameter`).
+ *
+ * **Alias** a modul-szintű `DyNTS_AI_ProviderError`-ra (SSoT): a Layer A validátor
+ * (`DyNTS_AI_ModelConfig_Validator`) és a Layer B fixture-ök UGYANAZT a hiba-alakot használják — nincs
+ * párhuzamos shape. A név megmarad, hogy az ai-mock oldali olvashatóság ne romoljon.
+ */
+export type DyNTS_AIMock_Error = DyNTS_AI_ProviderError;

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-fixture.interface.ts

@@ -0,0 +1,30 @@
+import { DyNTS_AIMock_Modality } from '../../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Error } from './aim-error.interface';
+
+/**
+ * Egy beégetett fixture-rekord (git-tracked konstans, D6). Az `output` XOR `error` közül PONTOSAN egy van:
+ * sikeres válasz VAGY provider-faithful hiba. Az `inputHash` a normalizált match-kulcs input-szegmense
+ * (l. `DyNTS_AIMock_FixtureMatch_Util.buildInputHash`). A `capturedAt` / `sourceModel` audit-nyomvonal (D4).
+ */
+export interface DyNTS_AIMock_Fixture {
+  /** Provider-azonosító. */
+  provider: string;
+  /** Pontos API modell-azonosító. */
+  model: string;
+  /** A fixture modalitása. */
+  modality: DyNTS_AIMock_Modality;
+  /** A rögzített config-paraméterek (a match-kulcs része). */
+  config?: Record<string, unknown>;
+  /** A normalizált input-hash (deterministic input→fixture feloldáshoz). */
+  inputHash: string;
+  /** A nyers bemenet (ember-olvasható referencia; a match az `inputHash`-en megy). */
+  input: unknown;
+  /** Sikeres kimenet (modalitás-függő). Az `error`-ral kölcsönösen kizáró. */
+  output?: unknown;
+  /** Provider-faithful hiba. Az `output`-tal kölcsönösen kizáró. */
+  error?: DyNTS_AIMock_Error;
+  /** A beégetés időbélyege (ISO). */
+  capturedAt: string;
+  /** A tényleges generáló modell (ha eltér a kért aliastól). */
+  sourceModel?: string;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-request.interface.ts

@@ -0,0 +1,19 @@
+import { DyNTS_AIMock_Modality } from '../../_enums/aim-modality.enum';
+
+/**
+ * Egy mock-hívás bemenete — EBBŐL képződik a fixture-match kulcs (`DyNTS_AIMock_FixtureMatch_Util`).
+ * A `config` a provider-specifikus hívás-paraméterek (a FR-048 `settingsSchema` ellen validálandó), az
+ * `input` modalitás-függő (prompt-szöveg / embedding-szöveg(ek) / kép-prompt / audio-referencia).
+ */
+export interface DyNTS_AIMock_Request {
+  /** Provider-azonosító (pl. 'open-ai', 'anthropic', 'fdp-ai'). */
+  provider: string;
+  /** Pontos API modell-azonosító (pl. 'gpt-4o-mini'). */
+  model: string;
+  /** A hívás modalitása. */
+  modality: DyNTS_AIMock_Modality;
+  /** Provider-specifikus config-paraméterek (temperature / dimensions / size / …). */
+  config?: Record<string, unknown>;
+  /** Modalitás-függő bemenet (prompt / szövegek / kép-prompt / audio-ref). */
+  input: unknown;
+}

package/src/_modules/ai/_modules/ai-mock/_models/interfaces/aim-service-collection.interface.ts

@@ -0,0 +1,20 @@
+import { DyFM_AI_ModelInfo } from '@futdevpro/fsm-dynamo/ai';
+
+import { DyNTS_AIMock_FixtureStore_Service } from '../../_services/aim-fixture-store.service';
+import { DyNTS_AIMock_Service } from '../../_services/aim-mock.service';
+
+/**
+ * Egy kesz, osszedrotozott AI-mock keszlet (`getDefaultAiMockServiceCollection` kimenete): a fixture-tar,
+ * a ra epulo mock-provider, es a config-validaciohoz bekototott modell-registry.
+ *
+ * A `store` azert is publikus, hogy a teszt futas kozben tovabbi fixture-oket regisztralhasson
+ * (`store.register([...])`) anelkul, hogy ujra kellene epiteni a kollekciot.
+ */
+export interface DyNTS_AIMock_ServiceCollection {
+  /** A beegetett fixture-ok tara (futas kozben bovitheto). */
+  store: DyNTS_AIMock_FixtureStore_Service;
+  /** A mock provider-surface (chat / embedding / image / audio). */
+  service: DyNTS_AIMock_Service;
+  /** A bekototott modell-registry — ebbol jon a FR-048 `settingsSchema`-alapu config-validacio. */
+  registry: DyFM_AI_ModelInfo[];
+}

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

@@ -1,115 +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);
-    });
-  });
-});
+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);
+    });
+  });
+});