@futdevpro/nts-dynamo 1.15.105 → 1.15.107

package/src/_modules/ai/_modules/ai-mock/_collections/aim-default-collection.util.spec.ts

@@ -0,0 +1,72 @@
+import { DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
+
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_ServiceCollection } from '../_models/interfaces/aim-service-collection.interface';
+import { DyNTS_AIMock_FixtureMatch_Util } from './aim-fixture-match.util';
+import { getDefaultAiMockServiceCollection } from './aim-default-collection.util';
+
+describe('| getDefaultAiMockServiceCollection (MP-7 SP-7.1)', () => {
+
+  function fixture(modality: DyNTS_AIMock_Modality, input: string): DyNTS_AIMock_Fixture {
+    return {
+      provider: 'open-ai',
+      model: 'gpt-5.4-mini',
+      modality: modality,
+      input: input,
+      inputHash: DyNTS_AIMock_FixtureMatch_Util.buildInputHash(input),
+      output: 'out',
+      capturedAt: '2026-07-21T00:00:00.000Z',
+    };
+  }
+
+  it('| default: mindharom schema-s provider registry-je be van kotve', () => {
+    const collection: DyNTS_AIMock_ServiceCollection = getDefaultAiMockServiceCollection();
+
+    expect(collection.registry.length).toBeGreaterThan(0);
+    expect(collection.registry.some((model) => model.provider === DyFM_AI_Provider.OpenAI)).toBe(true);
+    expect(collection.registry.some((model) => model.provider === DyFM_AI_Provider.Anthropic)).toBe(true);
+    expect(collection.registry.some((model) => model.provider === DyFM_AI_Provider.Google)).toBe(true);
+  });
+
+  it('| providers szukites: csak a kert provider modelljei', () => {
+    const collection: DyNTS_AIMock_ServiceCollection = getDefaultAiMockServiceCollection({
+      providers: [DyFM_AI_Provider.OpenAI],
+    });
+
+    expect(collection.registry.length).toBeGreaterThan(0);
+    expect(collection.registry.every((model) => model.provider === DyFM_AI_Provider.OpenAI)).toBe(true);
+  });
+
+  it('| service + store ossze van drotozva (a store futas kozben bovitheto)', () => {
+    const collection: DyNTS_AIMock_ServiceCollection = getDefaultAiMockServiceCollection();
+
+    expect(collection.store.size).toBe(0);
+
+    collection.store.register([fixture(DyNTS_AIMock_Modality.text, 'ping')]);
+
+    expect(collection.store.size).toBe(1);
+  });
+
+  it('| modalities szukites: csak az adott modalitasu fixture-ok kerulnek a tarba', () => {
+    const collection: DyNTS_AIMock_ServiceCollection = getDefaultAiMockServiceCollection({
+      modalities: [DyNTS_AIMock_Modality.embedding],
+      fixtures: [
+        fixture(DyNTS_AIMock_Modality.text, 'a'),
+        fixture(DyNTS_AIMock_Modality.embedding, 'b'),
+      ],
+    });
+
+    expect(collection.store.size).toBe(1);
+  });
+
+  it('| a bekototett fixture azonnal replay-elheto a service-en at', async () => {
+    const collection: DyNTS_AIMock_ServiceCollection = getDefaultAiMockServiceCollection({
+      fixtures: [fixture(DyNTS_AIMock_Modality.text, 'ping')],
+    });
+
+    await expectAsync(
+      collection.service.chatCompletion({ provider: 'open-ai', model: 'gpt-5.4-mini', input: 'ping' })
+    ).toBeResolvedTo('out');
+  });
+});

package/src/_modules/ai/_modules/ai-mock/_collections/aim-default-collection.util.ts

@@ -0,0 +1,71 @@
+import { DyFM_AI_ModelInfo, DyFM_AI_Provider } from '@futdevpro/fsm-dynamo/ai';
+import { DyFM_OAI_Models } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyFM_AAI_Models } from '@futdevpro/fsm-dynamo/ai/anthropic';
+import { DyFM_GAI_Models } from '@futdevpro/fsm-dynamo/ai/google';
+
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Fixture } from '../_models/interfaces/aim-fixture.interface';
+import { DyNTS_AIMock_ServiceCollection } from '../_models/interfaces/aim-service-collection.interface';
+import { DyNTS_AIMock_FixtureStore_Service } from '../_services/aim-fixture-store.service';
+import { DyNTS_AIMock_Service } from '../_services/aim-mock.service';
+
+/**
+ * Provider → modell-registry hozzarendeles.
+ *
+ * CSAK azok a providerek szerepelnek, amelyeknek van FR-048 `settingsSchema`-juk — a `local-ai` es az
+ * `fdp-ai` szandekosan schema-mentes (runtime/gateway-fuggo), igy a registry-be emelesuk a validaciohoz
+ * semmit nem adna hozza. L. a fsm registry-fejleceket + `FR-048-LAYER-A.md`.
+ */
+const REGISTRY_BY_PROVIDER: Record<string, DyFM_AI_ModelInfo[]> = {
+  [DyFM_AI_Provider.OpenAI]: DyFM_OAI_Models,
+  [DyFM_AI_Provider.Anthropic]: DyFM_AAI_Models,
+  [DyFM_AI_Provider.Google]: DyFM_GAI_Models,
+};
+
+/** Provider-default: minden schema-val rendelkezo provider. */
+const DEFAULT_PROVIDERS: DyFM_AI_Provider[] = [
+  DyFM_AI_Provider.OpenAI,
+  DyFM_AI_Provider.Anthropic,
+  DyFM_AI_Provider.Google,
+];
+
+/**
+ * **Default-bundle factory** (MP-7 SP-7.1) — egy hivassal osszeallit egy hasznalatra kesz AI-mock keszletet:
+ * fixture-tar + mock-provider + a config-validaciohoz bekototott modell-registry.
+ *
+ * A `fdp-templates` `getApiDefaultSettings`-mintajat koveti: a consumer teszt-modul egyetlen sorral kap egy
+ * mukodo mockot, es DI-vel a valodi provider helyere teheti.
+ *
+ * @param set - opcionalis szukites: mely providerek registry-je legyen bekotve, mely modalitasok
+ *   fixture-oi keruljenek be, es a kezdo fixture-keszlet.
+ */
+export function getDefaultAiMockServiceCollection(
+  set?: {
+    /** Mely providerek registry-je legyen bekotve a config-validaciohoz (default: mind a harom schema-s). */
+    providers?: DyFM_AI_Provider[],
+    /** Ha meg van adva, CSAK az itt felsorolt modalitasu fixture-ok kerulnek a tarba. */
+    modalities?: DyNTS_AIMock_Modality[],
+    /** A kezdo (beegetett) fixture-keszlet. */
+    fixtures?: DyNTS_AIMock_Fixture[],
+  }
+): DyNTS_AIMock_ServiceCollection {
+  const providers: DyFM_AI_Provider[] = set?.providers?.length ? set.providers : DEFAULT_PROVIDERS;
+
+  const registry: DyFM_AI_ModelInfo[] = providers.reduce(
+    (all: DyFM_AI_ModelInfo[], provider: DyFM_AI_Provider) => all.concat(REGISTRY_BY_PROVIDER[provider] ?? []),
+    []
+  );
+
+  const allFixtures: DyNTS_AIMock_Fixture[] = set?.fixtures ?? [];
+  const fixtures: DyNTS_AIMock_Fixture[] = set?.modalities?.length ?
+    allFixtures.filter((fixture: DyNTS_AIMock_Fixture) => set.modalities.includes(fixture.modality)) :
+    allFixtures;
+
+  const store: DyNTS_AIMock_FixtureStore_Service = new DyNTS_AIMock_FixtureStore_Service(fixtures);
+
+  return {
+    store: store,
+    service: new DyNTS_AIMock_Service(store, registry),
+    registry: registry,
+  };
+}

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

@@ -0,0 +1,57 @@
+import { DyNTS_AIMock_Modality } from '../_enums/aim-modality.enum';
+import { DyNTS_AIMock_Request } from '../_models/interfaces/aim-request.interface';
+import { DyNTS_AIMock_FixtureMatch_Util } from './aim-fixture-match.util';
+
+describe('DyNTS_AIMock_FixtureMatch_Util', () => {
+
+  function req(overrides: Partial<DyNTS_AIMock_Request>): DyNTS_AIMock_Request {
+    return {
+      provider: 'open-ai',
+      model: 'gpt-4o-mini',
+      modality: DyNTS_AIMock_Modality.text,
+      config: { temperature: 0 },
+      input: 'ping',
+      ...overrides,
+    };
+  }
+
+  it('determinisztikus — azonos request kétszer → azonos kulcs', () => {
+    expect(DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({}))).toBe(
+      DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({}))
+    );
+  });
+
+  it('config-kulcs-sorrend független', () => {
+    const a: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ config: { temperature: 0, topP: 1 } }));
+    const b: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ config: { topP: 1, temperature: 0 } }));
+
+    expect(a).toBe(b);
+  });
+
+  it('input-whitespace független', () => {
+    const a: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ input: 'hello   world' }));
+    const b: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ input: '  hello world  ' }));
+
+    expect(a).toBe(b);
+  });
+
+  it('eltérő input → eltérő kulcs', () => {
+    const a: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ input: 'ping' }));
+    const b: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ input: 'pong' }));
+
+    expect(a).not.toBe(b);
+  });
+
+  it('eltérő modalitás → eltérő kulcs (azonos input mellett is)', () => {
+    const a: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ modality: DyNTS_AIMock_Modality.text }));
+    const b: string = DyNTS_AIMock_FixtureMatch_Util.buildMatchKey(req({ modality: DyNTS_AIMock_Modality.embedding }));
+
+    expect(a).not.toBe(b);
+  });
+
+  it('buildInputHash stabil ugyanarra a szövegre', () => {
+    expect(DyNTS_AIMock_FixtureMatch_Util.buildInputHash('alpha')).toBe(
+      DyNTS_AIMock_FixtureMatch_Util.buildInputHash('alpha')
+    );
+  });
+});

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

@@ -0,0 +1,60 @@
+import * as crypto from 'crypto';
+
+import { DyNTS_AIMock_Request } from '../_models/interfaces/aim-request.interface';
+
+/**
+ * A fixture-match kulcs DETERMINISZTIKUS képzése. Cél: azonos „jelentésű" request → azonos kulcs,
+ * függetlenül a config-kulcsok sorrendjétől és az input whitespace-variánsaitól (különben false
+ * reject-on-unknown, l. HYPERPLAN D3 + MP-3 SP-3.1). NEM végez generálást — tiszta, hálózat-mentes.
+ */
+export class DyNTS_AIMock_FixtureMatch_Util {
+  /**
+   * A teljes match-kulcs: `provider|model|modality|<config-hash>|<input-hash>`.
+   * @param request - a mock-hívás bemenete
+   */
+  static buildMatchKey(request: DyNTS_AIMock_Request): string {
+    const configHash: string = this.hash(this.canonicalizeConfig(request.config ?? {}));
+    const inputHash: string = this.buildInputHash(request.input);
+
+    return `${request.provider}|${request.model}|${request.modality}|${configHash}|${inputHash}`;
+  }
+
+  /**
+   * Csak az input-hash (a `DyNTS_AIMock_Fixture.inputHash`-hez): a kanonizált input SHA-256-ja.
+   * @param input - a modalitás-függő bemenet
+   */
+  static buildInputHash(input: unknown): string {
+    return this.hash(this.canonicalizeInput(input));
+  }
+
+  /**
+   * Kulcs-rendezett, stabil szöveg egy config-objektumból (a config-kulcsok sorrend-függetlenségéhez).
+   * Megjegyzés: a nested-objektum mély-kanonizációja jövőbeli finomítás (a shallow key-sort a config-flat
+   * paramétereket — temperature/dimensions/size — fedi).
+   * @param config - a kanonizálandó config
+   */
+  private static canonicalizeConfig(config: Record<string, unknown>): string {
+    const sortedKeys: string[] = Object.keys(config).sort();
+    const parts: string[] = sortedKeys.map((key: string) => `${key}:${JSON.stringify(config[key])}`);
+
+    return parts.join('|');
+  }
+
+  /**
+   * Input-kanonizáció: string → trim + belső whitespace-összevonás; egyéb (pl. embedding-szöveg-tömb) →
+   * stabil JSON (a sorrend jelentős, pl. batch-embedding).
+   * @param input - a bemenet
+   */
+  private static canonicalizeInput(input: unknown): string {
+    if (typeof input === 'string') {
+      return input.trim().replace(/\s+/g, ' ');
+    }
+
+    return JSON.stringify(input);
+  }
+
+  /** SHA-256 hex az adott szövegből. */
+  private static hash(value: string): string {
+    return crypto.createHash('sha256').update(value).digest('hex');
+  }
+}

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

@@ -5,7 +5,7 @@ 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';
+import { DyNTS_AI_CostEvent } from '../../../_models/interfaces/dynts-ai-cost-event.interface';
 
 describe('| DyNTS_AI_Embedding_MockService', () => {
 

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

@@ -4,8 +4,8 @@ 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_CostEventCallback } from '../_models/interfaces/dynts-ai-cost-event-callback.interface';
-import { DyNTS_AI_Embedding_ServiceBase } from './ai-embedding.service-base';
+import { DyNTS_AI_CostEventCallback } from '../../../_models/interfaces/dynts-ai-cost-event-callback.interface';
+import { DyNTS_AI_Embedding_ServiceBase } from '../../../_services/ai-embedding.service-base';
 
 /** 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;