@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/fixture-loader-services.js

@@ -0,0 +1,114 @@
+import { fixturesOf, hasMcpFakesKey, listFixtureDir, readFixtureJson } from "./fixture-loader.js";
+import { McpFakesAddError, validateMcpFakes } from "./mcp-fakes.js";
+import { join } from "node:path";
+
+//#region src/fixture-loader-services.ts
+/**
+* Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`
+* variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM
+* fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).
+*
+* They live outside fixture-loader.ts because they validate blocks with
+* `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from
+* fixture-loader.ts at module load (`McpFakesAddError extends
+* FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts
+* is an import cycle that leaves `FixtureLoadError` uninitialized whenever
+* fixture-loader.ts is loaded first.
+*/
+/**
+* Load one parsed file into `load.out`: its `mcpFakes` blocks under
+* `source`, then its LLM fixtures. A file with a bad block adds nothing; its
+* errors go to `load.errors`, and the load goes on so every bad block of
+* every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are
+* kept either way.
+*/
+function loadServicesFile(filePath, source, load, logger, liveOptions) {
+	const { out } = load;
+	const read = readFixtureJson(filePath, logger);
+	if (read === null) {
+		out.unreadable.push(source);
+		return;
+	}
+	const parsed = read.value;
+	const withFakes = hasMcpFakesKey(parsed);
+	if (withFakes) {
+		const raw = parsed.mcpFakes;
+		const validation = validateMcpFakes(raw, source);
+		out.mcpFakeWarnings.push(...validation.warnings);
+		if (validation.errors.length > 0) {
+			load.errors.push(...validation.errors);
+			return;
+		}
+		if (Array.isArray(raw)) raw.forEach((block, blockIndex) => {
+			out.mcpFakes.push({
+				source,
+				blockIndex,
+				raw: block
+			});
+		});
+		else out.mcpFakes.push({
+			source,
+			blockIndex: null,
+			raw
+		});
+	}
+	out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));
+}
+/**
+* The result of a finished load, or its errors thrown: the one
+* `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and
+* the L8 warnings, so no warning is lost when the load fails.
+*/
+function finish(load) {
+	const { out, errors } = load;
+	const [first] = errors;
+	if (first === void 0) return out;
+	if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;
+	throw new McpFakesAddError(errors, out.mcpFakeWarnings);
+}
+function newLoad() {
+	return {
+		out: {
+			fixtures: [],
+			mcpFakes: [],
+			mcpFakeWarnings: [],
+			unreadable: []
+		},
+		errors: []
+	};
+}
+/**
+* Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A
+* fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`
+* as given, or `sourceLabel` when set (the URL of a remote fixture file).
+* A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there
+* is more than one error, or L8 warnings to keep with it).
+*/
+function loadFixtureFileWithServices(filePath, logger, liveOptions, sourceLabel) {
+	const load = newLoad();
+	loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);
+	return finish(load);
+}
+function loadServicesDir(dirPath, relDir, load, logger, liveOptions) {
+	const listing = listFixtureDir(dirPath, logger);
+	if (listing === null) return;
+	for (const name of listing.jsonFiles) loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);
+	for (const sub of listing.subdirs) loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);
+}
+/**
+* Load every `.json` file under `dirPath` (sorted, then subdirectories, at
+* full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`
+* blocks. Each block's `source` (spec I6) is its file's path relative to
+* `dirPath`, with `/` separators. Every file is checked before anything is
+* thrown: the bad blocks of all files are reported together, as in
+* {@link loadFixtureFileWithServices}.
+*/
+function loadFixturesFromDirWithServices(dirPath, logger, liveOptions) {
+	const load = newLoad();
+	loadServicesDir(dirPath, "", load, logger, liveOptions);
+	return finish(load);
+}
+
+//#endregion
+export { loadFixtureFileWithServices, loadFixturesFromDirWithServices };
+//# sourceMappingURL=fixture-loader-services.js.map

package/dist/fixture-loader-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-loader-services.js","names":[],"sources":["../src/fixture-loader-services.ts"],"sourcesContent":["/**\n * Fixture loaders that carry MCP fakes (spec F1): the `…WithServices`\n * variants of `loadFixtureFile` / `loadFixturesFromDir`. They return the LLM\n * fixtures and the raw `mcpFakes` blocks with their entry-id `source` (I6).\n *\n * They live outside fixture-loader.ts because they validate blocks with\n * `validateMcpFakes`, and mcp-fakes.ts imports `FixtureLoadError` from\n * fixture-loader.ts at module load (`McpFakesAddError extends\n * FixtureLoadError`): a value import of mcp-fakes.ts from fixture-loader.ts\n * is an import cycle that leaves `FixtureLoadError` uninitialized whenever\n * fixture-loader.ts is loaded first.\n */\nimport { join } from \"node:path\";\nimport type { LiveOptions } from \"./live-types.js\";\nimport type { Logger } from \"./logger.js\";\nimport {\n  fixturesOf,\n  hasMcpFakesKey,\n  listFixtureDir,\n  readFixtureJson,\n  type FixtureLoadError,\n} from \"./fixture-loader.js\";\nimport { McpFakesAddError, validateMcpFakes, type McpFakeIssue } from \"./mcp-fakes.js\";\nimport type { Fixture, McpFakeSource } from \"./types.js\";\n\n/** What {@link loadFixtureFileWithServices} and {@link loadFixturesFromDirWithServices} return. */\nexport interface FixturesWithServices {\n  /** LLM fixtures, as the old loaders return them. */\n  fixtures: Fixture[];\n  /**\n   * The raw `mcpFakes` blocks, one per block, in load order, each with its\n   * entry-id `source` (spec I6) and `blockIndex` (`null` for the\n   * single-object form). Validated per file; checks across files and loads\n   * (entry-id collisions) happen when a mount adds them.\n   */\n  mcpFakes: McpFakeSource[];\n  /** Shadowed-entry warnings (L8) of those blocks, for the caller to print. */\n  mcpFakeWarnings: McpFakeIssue[];\n  /**\n   * The entry-id `source` (I6) of each file that could not be read or was\n   * not valid JSON. Such a file is warned and skipped, as before, so it adds\n   * no fixtures and no blocks; a `--watch` reload uses this list to tell a\n   * file it could not parse from a file whose `mcpFakes` were removed.\n   */\n  unreadable: string[];\n}\n\n/** A load in progress: the result, plus every bad-block error of every file. */\ninterface ServicesLoad {\n  out: FixturesWithServices;\n  errors: FixtureLoadError[];\n}\n\n/**\n * Load one parsed file into `load.out`: its `mcpFakes` blocks under\n * `source`, then its LLM fixtures. A file with a bad block adds nothing; its\n * errors go to `load.errors`, and the load goes on so every bad block of\n * every file is reported (fail-loud rule, spec 5.4; L3). Its L8 warnings are\n * kept either way.\n */\nfunction loadServicesFile(\n  filePath: string,\n  source: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const { out } = load;\n  const read = readFixtureJson(filePath, logger);\n  if (read === null) {\n    out.unreadable.push(source);\n    return;\n  }\n  const parsed = read.value;\n  const withFakes = hasMcpFakesKey(parsed);\n  if (withFakes) {\n    const raw = parsed.mcpFakes;\n    const validation = validateMcpFakes(raw, source);\n    out.mcpFakeWarnings.push(...validation.warnings);\n    if (validation.errors.length > 0) {\n      load.errors.push(...validation.errors);\n      return;\n    }\n    if (Array.isArray(raw)) {\n      raw.forEach((block: unknown, blockIndex: number) => {\n        out.mcpFakes.push({ source, blockIndex, raw: block });\n      });\n    } else {\n      out.mcpFakes.push({ source, blockIndex: null, raw });\n    }\n  }\n  out.fixtures.push(...fixturesOf(parsed, filePath, logger, liveOptions, withFakes, source));\n}\n\n/**\n * The result of a finished load, or its errors thrown: the one\n * `FixtureLoadError` alone, else a `McpFakesAddError` holding every error and\n * the L8 warnings, so no warning is lost when the load fails.\n */\nfunction finish(load: ServicesLoad): FixturesWithServices {\n  const { out, errors } = load;\n  const [first] = errors;\n  if (first === undefined) return out;\n  if (errors.length === 1 && out.mcpFakeWarnings.length === 0) throw first;\n  throw new McpFakesAddError(errors, out.mcpFakeWarnings);\n}\n\nfunction newLoad(): ServicesLoad {\n  return { out: { fixtures: [], mcpFakes: [], mcpFakeWarnings: [], unreadable: [] }, errors: [] };\n}\n\n/**\n * Load one fixture file: its LLM fixtures and its `mcpFakes` blocks. A\n * fakes-only file is accepted. The blocks' `source` (spec I6) is `filePath`\n * as given, or `sourceLabel` when set (the URL of a remote fixture file).\n * A bad block throws a `FixtureLoadError` (a `McpFakesAddError` when there\n * is more than one error, or L8 warnings to keep with it).\n */\nexport function loadFixtureFileWithServices(\n  filePath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n  sourceLabel?: string,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesFile(filePath, sourceLabel ?? filePath, load, logger, liveOptions);\n  return finish(load);\n}\n\nfunction loadServicesDir(\n  dirPath: string,\n  relDir: string,\n  load: ServicesLoad,\n  logger: Logger | undefined,\n  liveOptions: LiveOptions | undefined,\n): void {\n  const listing = listFixtureDir(dirPath, logger);\n  if (listing === null) return;\n  for (const name of listing.jsonFiles) {\n    loadServicesFile(join(dirPath, name), relDir + name, load, logger, liveOptions);\n  }\n  for (const sub of listing.subdirs) {\n    loadServicesDir(join(dirPath, sub), `${relDir}${sub}/`, load, logger, liveOptions);\n  }\n}\n\n/**\n * Load every `.json` file under `dirPath` (sorted, then subdirectories, at\n * full depth, as {@link loadFixturesFromDir}): LLM fixtures and `mcpFakes`\n * blocks. Each block's `source` (spec I6) is its file's path relative to\n * `dirPath`, with `/` separators. Every file is checked before anything is\n * thrown: the bad blocks of all files are reported together, as in\n * {@link loadFixtureFileWithServices}.\n */\nexport function loadFixturesFromDirWithServices(\n  dirPath: string,\n  logger?: Logger,\n  liveOptions?: LiveOptions,\n): FixturesWithServices {\n  const load = newLoad();\n  loadServicesDir(dirPath, \"\", load, logger, liveOptions);\n  return finish(load);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAS,iBACP,UACA,QACA,MACA,QACA,aACM;CACN,MAAM,EAAE,QAAQ;CAChB,MAAM,OAAO,gBAAgB,UAAU,OAAO;AAC9C,KAAI,SAAS,MAAM;AACjB,MAAI,WAAW,KAAK,OAAO;AAC3B;;CAEF,MAAM,SAAS,KAAK;CACpB,MAAM,YAAY,eAAe,OAAO;AACxC,KAAI,WAAW;EACb,MAAM,MAAM,OAAO;EACnB,MAAM,aAAa,iBAAiB,KAAK,OAAO;AAChD,MAAI,gBAAgB,KAAK,GAAG,WAAW,SAAS;AAChD,MAAI,WAAW,OAAO,SAAS,GAAG;AAChC,QAAK,OAAO,KAAK,GAAG,WAAW,OAAO;AACtC;;AAEF,MAAI,MAAM,QAAQ,IAAI,CACpB,KAAI,SAAS,OAAgB,eAAuB;AAClD,OAAI,SAAS,KAAK;IAAE;IAAQ;IAAY,KAAK;IAAO,CAAC;IACrD;MAEF,KAAI,SAAS,KAAK;GAAE;GAAQ,YAAY;GAAM;GAAK,CAAC;;AAGxD,KAAI,SAAS,KAAK,GAAG,WAAW,QAAQ,UAAU,QAAQ,aAAa,WAAW,OAAO,CAAC;;;;;;;AAQ5F,SAAS,OAAO,MAA0C;CACxD,MAAM,EAAE,KAAK,WAAW;CACxB,MAAM,CAAC,SAAS;AAChB,KAAI,UAAU,OAAW,QAAO;AAChC,KAAI,OAAO,WAAW,KAAK,IAAI,gBAAgB,WAAW,EAAG,OAAM;AACnE,OAAM,IAAI,iBAAiB,QAAQ,IAAI,gBAAgB;;AAGzD,SAAS,UAAwB;AAC/B,QAAO;EAAE,KAAK;GAAE,UAAU,EAAE;GAAE,UAAU,EAAE;GAAE,iBAAiB,EAAE;GAAE,YAAY,EAAE;GAAE;EAAE,QAAQ,EAAE;EAAE;;;;;;;;;AAUjG,SAAgB,4BACd,UACA,QACA,aACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,kBAAiB,UAAU,eAAe,UAAU,MAAM,QAAQ,YAAY;AAC9E,QAAO,OAAO,KAAK;;AAGrB,SAAS,gBACP,SACA,QACA,MACA,QACA,aACM;CACN,MAAM,UAAU,eAAe,SAAS,OAAO;AAC/C,KAAI,YAAY,KAAM;AACtB,MAAK,MAAM,QAAQ,QAAQ,UACzB,kBAAiB,KAAK,SAAS,KAAK,EAAE,SAAS,MAAM,MAAM,QAAQ,YAAY;AAEjF,MAAK,MAAM,OAAO,QAAQ,QACxB,iBAAgB,KAAK,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,IAAI,MAAM,QAAQ,YAAY;;;;;;;;;;AAYtF,SAAgB,gCACd,SACA,QACA,aACsB;CACtB,MAAM,OAAO,SAAS;AACtB,iBAAgB,SAAS,IAAI,MAAM,QAAQ,YAAY;AACvD,QAAO,OAAO,KAAK"}