@copilotkit/aimock 1.43.0 → 1.45.0

package/dist/mcp-fakes.d.cts

@@ -0,0 +1,504 @@
+import { FixtureLoadError, FixtureLoadErrorJSON } from "./fixture-loader.cjs";
+import { McpFakeCallAnswer, McpFakeCallMatch, McpFakeDeepReadonly, McpFakeIdentity, McpFakeNotification, McpFakeRecorded, McpFakeScope, McpFakeSource, McpFakeUndeclaredPolicy } from "./types.cjs";
+
+//#region src/mcp-fakes.d.ts
+
+/**
+ * The finer rules of the recorded `mcpFakes` keys FA1-FA5. A malformed FA key
+ * throws `FixtureLoadError` with the rule `mcp-fakes/bad-block:h` (the rule
+ * 1.44.0 gave these keys, then unknown), and its message names one of these
+ * in brackets after the rule. A recorded file that breaks a `fakes:` rule
+ * throws its `mcp-fakes/` value and names none of these.
+ */
+declare const RECORD_REPLAY_LOAD_RULES: readonly ["record-replay/fa-list", "record-replay/fa-recorded", "record-replay/fa-notifications", "record-replay/fa-duration", "record-replay/fa-timing"];
+type RecordReplayLoadRule = (typeof RECORD_REPLAY_LOAD_RULES)[number];
+/** Default `mount` path of a block. */
+
+/**
+ * One validated call entry, with its entry id. Deeply frozen: its `args` /
+ * `result` are frozen copies of the caller's values (never the caller's objects).
+ */
+type ValidatedCall = Readonly<{
+  /**
+   * Full entry id: `<source><load>[<block>]:<local>`, where `local` is the
+   * user `id` or `<tool>#<index>`.
+   */
+  id: string;
+  /** Position in its tool's `calls`. */
+  index: number;
+  /** FA3: recorded notifications, in stream order. */
+  notifications?: McpFakeDeepReadonly<McpFakeNotification[]>;
+  /** FA4: recorded response time in ms. */
+  durationMs?: number;
+}> & McpFakeDeepReadonly<McpFakeCallMatch> & McpFakeDeepReadonly<McpFakeCallAnswer>;
+/** One validated tool. Deeply frozen; `inputSchema` is a frozen copy. */
+interface ValidatedTool {
+  readonly name: string;
+  readonly description?: string;
+  readonly inputSchema?: McpFakeDeepReadonly<Record<string, unknown>>;
+  readonly calls: readonly ValidatedCall[];
+}
+/**
+ * Scope tiers, most specific first. A tool's candidate entries come from the
+ * first tier with an applicable block that declares it.
+ */
+type McpFakeTier = "testId+context" | "testId" | "context" | "shared";
+/** One validated block. Deeply frozen: the store hands it out as is. */
+interface ValidatedBlock {
+  /** Entry-id `source`: the file's source string, or `code#<n>` / `control-api#<n>`. */
+  readonly source: string;
+  /** Entry-id load suffix: `""` for the first load of a source, `@<k>` for the k-th. */
+  readonly load: string;
+  /** `null` when `mcpFakes` was a single object. */
+  readonly blockIndex: number | null;
+  /** `<source><load>[<block>]`. */
+  readonly blockId: string;
+  readonly scope: McpFakeScope;
+  readonly tier: McpFakeTier;
+  readonly mount: string;
+  readonly undeclaredTools?: McpFakeUndeclaredPolicy;
+  readonly tools: readonly ValidatedTool[];
+  /** FA1: the recorded `tools/list`, verbatim. */
+  readonly list?: McpFakeDeepReadonly<Record<string, unknown>[]>;
+  /** FA2: provenance; never used for matching. */
+  readonly recorded?: McpFakeDeepReadonly<McpFakeRecorded>;
+  /** FA5: `"recorded"` unless the block says `"immediate"`. */
+  readonly timing: "recorded" | "immediate";
+}
+/**
+ * A validation warning: an `args` entry shadowed by an earlier `anyArgs` entry
+ * of the same tool. Errors are `FixtureLoadError` instances.
+ */
+interface McpFakeIssue {
+  file: string | null;
+  blockId: string | null;
+  entryId: string | null;
+  message: string;
+}
+/** A `tools/call` result. */
+type McpFakeCallToolResult = {
+  content: unknown[];
+} & Record<string, unknown>;
+/**
+ * One declared entry as named in a mismatch claim or a snapshot. Deeply
+ * frozen; `args` is a frozen copy.
+ */
+type McpFakeDeclaredEntry = Readonly<{
+  id: string;
+  consumed: boolean;
+}> & McpFakeDeepReadonly<McpFakeCallMatch>;
+/**
+ * What `McpFakeStore.claim` returns. Frozen, as is everything in it that the
+ * store owns (`entry`, `block`, `declared`, `matchingIds`); `result` is a
+ * fresh mutable copy for the mount to send, and `received` is the caller's
+ * `args` value as given (not copied or frozen), or a new `{}` when it was
+ * `undefined`.
+ */
+type McpFakeClaim = Readonly<{
+  kind: "answer";
+  tool: string;
+  entry: ValidatedCall;
+  block: ValidatedBlock;
+  tier: McpFakeTier;
+  result: McpFakeCallToolResult;
+}> | Readonly<{
+  kind: "mismatch";
+  tool: string;
+  received: unknown;
+  declared: readonly McpFakeDeclaredEntry[];
+  firstDifference: string;
+}> | Readonly<{
+  kind: "exhausted";
+  tool: string;
+  received: unknown;
+  matchingDeclared: number;
+  matchingConsumed: number;
+  matchingIds: readonly string[];
+}> | Readonly<{
+  /**
+   * The test id's consumption state was dropped by the FIFO cap, so
+   * which entries it already used is unknown. Fail loud rather than replay
+   * an entry; only `resetState(testId)` (or a full reset) clears this. The
+   * mark never ages out.
+   */
+  kind: "evicted";
+  tool: string;
+  testId: string;
+  maxTestIds: number;
+}> | Readonly<{
+  kind: "none";
+}>;
+interface McpFakeToolListing {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+/** One block of `McpFakeStore.snapshot()`. Deeply frozen. */
+interface McpFakeBlockSnapshot {
+  readonly blockId: string;
+  readonly source: string;
+  readonly mount: string;
+  readonly scope: McpFakeScope;
+  readonly undeclaredTools: McpFakeUndeclaredPolicy;
+  /**
+   * The requested test id's consumption state was evicted by the FIFO cap. Its
+   * entries then show `consumed: false` because which ones it used is unknown,
+   * and a claim from it of a tool an applicable block declares fails as
+   * `evicted` until it is reset.
+   */
+  readonly evicted: boolean;
+  readonly tools: ReadonlyArray<Readonly<{
+    name: string;
+    entries: readonly McpFakeDeclaredEntry[];
+  }>>;
+}
+/** `Omit` over each member of a union. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * RP2: one `tools/call` on a mount, as its fake event log keeps it. Every
+ * `tools/call` is logged, fakes or not.
+ */
+type McpFakeReportEvent = {
+  /** Process-wide increasing counter (module-level in mcp-fakes.ts), set by logEvent; orders events across mounts (S4). */
+  seq: number;
+  tool: string;
+  args: unknown;
+  context: string | null;
+  mount: string;
+} & ({
+  outcome: "answered";
+  entryId: string;
+} | {
+  outcome: "mismatch" | "exhausted" | "not_declared" | "evicted" | "internal_error";
+  code: string;
+} | {
+  outcome: "unfaked";
+  answeredBy: "handler" | "config" | "empty" | "unknown-tool" | "upstream";
+});
+/** What callers pass to logEvent: the event without `seq` (the store assigns it). */
+type McpFakeReportEventInput = DistributiveOmit<McpFakeReportEvent, "seq">;
+/**
+ * RP3: this mount's part of a fake report, for one test id and context.
+ * `served` and `failures` rows carry `seq`, which the report module sorts on
+ * across mounts and strips from the JSON it serves.
+ */
+interface McpFakeReportPart {
+  evicted: boolean;
+  served: {
+    entryId: string;
+    mount: string;
+    tool: string;
+    args: unknown;
+    seq: number;
+  }[];
+  unconsumed: {
+    entryId: string;
+    mount: string;
+    tool: string;
+    args?: unknown;
+    anyArgs?: true;
+  }[];
+  unfaked: {
+    mount: string;
+    tool: string;
+    args: unknown;
+    answeredBy: string;
+  }[];
+  failures: {
+    code: string;
+    mount: string;
+    tool: string;
+    args: unknown;
+    seq: number;
+  }[];
+  sharedUnconsumed: {
+    entryId: string;
+    mount: string;
+    tool: string;
+  }[];
+}
+interface McpFakeAddOrigin {
+  /**
+   * `file`: blocks keep their `source` and `blockIndex`, and the per-source
+   * load counter (`@<k>`) applies.
+   * `code` / `control-api`: one run-time addition; every block gets the source
+   * `code#<n>` / `control-api#<n>`, whatever `source` it carried. The
+   * input is one `mcpFakes` value of that addition: a single item with a null
+   * `blockIndex` is the single-object form (no `[<i>]`); otherwise each block
+   * is numbered by its position in the input (`[0]`, `[1]`, ...).
+   */
+  kind: "file" | "code" | "control-api";
+}
+/**
+ * The origin of an add inside aimock: a public `McpFakeAddOrigin`, or
+ * `record`, a run-time addition written by the MCP recorder (MR12), numbered
+ * as `code` / `control-api` are, with the source `record#<n>`. Kept off the
+ * public `McpFakeAddOrigin`, so that a user `Mountable.addMcpFakes` that
+ * switches over its `kind` stays exhaustive.
+ *
+ * @internal
+ */
+interface McpFakeAddOriginInternal {
+  kind: McpFakeAddOrigin["kind"] | "record";
+}
+/** What a successful `McpFakeStore.add` / `Mountable.addMcpFakes` returns. */
+interface McpFakeAddResult {
+  /** Shadowed-entry warnings of the added blocks, with their real entry ids. */
+  warnings: McpFakeIssue[];
+}
+/**
+ * `McpFakesAddError.toJSON()`: the first error's `rule`, `file`, `blockId` and
+ * `entryId`, the combined `message`, and every error and warning.
+ */
+interface McpFakesAddErrorJSON extends FixtureLoadErrorJSON {
+  name: "McpFakesAddError";
+  errors: FixtureLoadErrorJSON[];
+  warnings: McpFakeIssue[];
+}
+/**
+ * The error a failed add throws. It is a `FixtureLoadError` whose `rule`,
+ * `file`, `blockId` and `entryId` are those of the first error, and whose
+ * `message` is the first error's message plus the count of the others.
+ * `errors` holds every error found in the input, in order (the first
+ * included; see `validateBlock` for the checks that stop early), and
+ * `warnings` the shadowed-entry warnings of the blocks that passed every
+ * check. Both are frozen, non-writable arrays; `toJSON()` returns copies.
+ */
+declare class McpFakesAddError extends FixtureLoadError {
+  readonly name = "McpFakesAddError";
+  readonly errors: readonly FixtureLoadError[];
+  readonly warnings: readonly Readonly<McpFakeIssue>[];
+  constructor(errors: readonly FixtureLoadError[], warnings: readonly McpFakeIssue[]);
+  toJSON(): McpFakesAddErrorJSON;
+}
+/**
+ * The one own-key listing for input data: own, enumerable, string keys.
+ * Inherited names (`constructor`, `toString`, `__proto__`) are never listed.
+ *
+ * @internal
+ */
+
+interface McpFakeStoreOptions {
+  /**
+   * FIFO cap on distinct test ids that keep consumption state; `0` is
+   * unbounded. Default 500. A value that is not a non-negative safe integer
+   * throws a `RangeError`.
+   */
+  maxTestIds?: number;
+}
+interface McpFakeSelection {
+  tier: McpFakeTier;
+  entries: Array<{
+    block: ValidatedBlock;
+    entry: ValidatedCall;
+  }>;
+}
+declare class McpFakeStore {
+  private blocks;
+  /** Entry id → the block id that owns it, for every loaded entry. */
+  private ids;
+  /** Block id → its `source`, for every loaded block. */
+  private blockIds;
+  /**
+   * Consumption state: supplied test id → consumed entry ids. Map insertion
+   * order is the FIFO order of the cap.
+   */
+  private consumed;
+  /** Consumed entry ids for requests with no test id. Never evicted. */
+  private untagged;
+  /**
+   * Test ids whose state the cap evicted. A claim from one of them, of a tool
+   * an applicable block declares, is `evicted` until the test id is reset; a
+   * mark never ages out, because a forgotten mark would silently replay
+   * entries the test id already consumed. Memory stays bounded per evicted
+   * test id: one id string, against the entry-id set the cap dropped. The set only grows with distinct test ids, and every
+   * reset door clears it (`resetState`, `clear`). A cap of `0` evicts
+   * nothing, so marks made under an earlier cap stay until reset.
+   */
+  private evicted;
+  /**
+   * The last `<n>` of `code#<n>` / `control-api#<n>` used by a run-time
+   * addition (see `nextRuntimeNumber`). Never rewound.
+   */
+  private runtimeAdds;
+  /**
+   * The `<k>` of `@<k>`: loads per source string, skipping a `@<k>` that a
+   * loaded block id already starts (see `add`). Never rewound.
+   */
+  private loadCounts;
+  private maxTestIds;
+  /**
+   * RP2 fake event logs: supplied test id → its events, oldest first. Map
+   * insertion order is the FIFO order of the test-id cap.
+   */
+  private events;
+  /** The event log of requests with no test id: a ring of the newest events. */
+  private untaggedEvents;
+  /** The untagged event log dropped an event (C9). */
+  private untaggedOverflow;
+  /**
+   * C9: test ids whose event log overflowed or was evicted, so their report
+   * is incomplete (`evicted: true`). Report-only: `claim`, `snapshot` and
+   * `policy` never read it, so tool calls are unchanged.
+   */
+  private reportOverflow;
+  constructor(options?: McpFakeStoreOptions);
+  /**
+   * Set the FIFO cap on distinct test ids; an MCP mount can pass the
+   * journal's `fixtureCountsMaxTestIdsCap`. A lower cap evicts the oldest test
+   * ids at once. `0` is unbounded: nothing is evicted, and test ids already
+   * marked evicted stay marked until reset. An invalid cap throws a
+   * `RangeError` and leaves the cap unchanged.
+   */
+  setMaxTestIds(cap: number): void;
+  /**
+   * Take one plain-data snapshot of `sources` and `origin` (getters are not
+   * run, inherited fields not read, holes, symbol keys, proxies that throw and
+   * non-plain objects are errors), validate the whole snapshot, derive entry
+   * ids and their counters, check that every block id and every entry id is
+   * unique against the mount and inside the input (bad block (f), naming the
+   * block that already owns the id and, for a block id, that block's source),
+   * then append. Every block is checked,
+   * valid or not (no first-stop; `validateBlock` says which checks stop
+   * early). On any error, throws one `McpFakesAddError` carrying every error
+   * found, and the warnings of the blocks that passed every check, and adds
+   * nothing (no counter is consumed); it never throws anything else for a bad
+   * input (a throw from a defect in aimock itself is not caught). An empty
+   * input, an invalid `origin` or an invalid source item (not an object, an
+   * empty `source`, a `blockIndex` that is not `null` or a non-negative
+   * integer) is a bad block (i).
+   *
+   * With `kind: "file"`, consecutive sources with the same `source` string
+   * and increasing `blockIndex` form one load (one `@<k>`). A load whose
+   * derived block ids a loaded block already has (a file named `"a@2"`
+   * starts the ids of `@2`; a file named `"a[0]"` has the id of block 0 of
+   * the first load) takes the next free `@<k>`, so a file name never blocks
+   * later loads of another source. A file loaded after the block whose id
+   * its name spells is still the bad block (f). With a run-time origin,
+   * blocks are numbered per `McpFakeAddOrigin`; a block given with a null
+   * `blockIndex` keeps the single-object depth limit.
+   */
+  add(sources: readonly McpFakeSource[], origin: McpFakeAddOriginInternal): McpFakeAddResult;
+  /**
+   * The `<n>` for the next run-time add of `kind`: one more than the last one
+   * used, skipping any number whose `<kind>#<n>` already starts a loaded block
+   * id (and so every entry id of that block). A file source may be spelled
+   * `code#1`; without the skip, every later run-time add would collide with it
+   * and fail, and a failed add does not advance `<n>`. Blocks loaded after a
+   * run-time add still collide with it as usual (the later block fails).
+   */
+  private nextRuntimeNumber;
+  /**
+   * A loaded block id (or one in `pending`, the blocks earlier in the same
+   * input) starts with `prefix` and does not go on with a digit, so `prefix`
+   * would start a colliding block or entry id (`a@2` is taken by `a@2` and
+   * `a@2[0]`, not by `a@23`).
+   */
+  private blockIdPrefixTaken;
+  /** Unload every fake and its state. The id counters (`<n>`, `<k>`) are kept. */
+  clear(): void;
+  /**
+   * Reset consumption state for one test id, or all. Also clears an
+   * `evicted` mark. `MCP_FAKES_DEFAULT_TEST_ID` resets the untagged state as
+   * well as an explicit test id of that name. That matches
+   * `Journal.clearMatchCounts` (which `LLMock.resetMatchCounts` calls), where
+   * untagged requests and an explicit `__default__` share one key.
+   */
+  resetState(testId?: string): void;
+  /**
+   * MR12: mark entries consumed for `testId` (null = untagged), as a claim
+   * would. Ids not loaded on this mount are ignored, and so is a test id the
+   * cap evicted (its claims fail as `evicted` until it is reset).
+   */
+  markConsumed(testId: string | null, entryIds: readonly string[]): void;
+  /**
+   * AM7/FA1: the `list` of the most specific applicable tier that has one,
+   * else null. Inside a tier, the first block in load order with a `list`.
+   */
+  recordedList(identity: McpFakeIdentity): readonly Record<string, unknown>[] | null;
+  /** FA5 timing and the FA3/FA4 values of an answered entry (for MR15 framing). */
+  replayOf(entryId: string): {
+    timing: "recorded" | "immediate";
+    notifications: readonly McpFakeNotification[];
+    durationMs: number | undefined;
+  } | null;
+  /** C7: true when any loaded call entry has a `notifications/message` (gates logging). */
+  hasRecordedLogs(): boolean;
+  /**
+   * RP2: append one event to the identity's log, with the next process-wide
+   * `seq` and its `args` bounded (`MCP_FAKES_MAX_EVENT_ARGS_BYTES`). A log
+   * past `MCP_FAKES_MAX_EVENTS_PER_LOG` drops its oldest event and its report
+   * says `evicted: true`; a new test id past the test-id cap evicts the
+   * oldest test id's log the same way (C9). Never touches consumption state.
+   */
+  logEvent(identity: McpFakeIdentity, event: McpFakeReportEventInput): void;
+  /**
+   * RP3 parts for this mount (report assembly is src/mcp-fakes-report.ts).
+   * `served`, `failures` and `unfaked` come from the events whose context is
+   * exactly `context`, in `seq` order; `unconsumed` (tiers `testId+context`
+   * and `testId`) and `sharedUnconsumed` (tiers `context` and `shared`) are
+   * the applicable entries of this store that `testId` has not consumed,
+   * labelled with `mount`, the path the store's mock is served at. Every
+   * block in the store answers there (`claim` does not read `block.mount`),
+   * so none is left out by its own `mount` value: a mock that loaded its own
+   * fakes (default mount "/mcp") and is mounted at another path still reports
+   * them. Reads only: building a report changes no state.
+   */
+  reportPart(testId: string | null, context: string | null, mount: string): McpFakeReportPart;
+  /** Every entry id on this mount, in load order. */
+  allEntryIds(): string[];
+  /** The blocks whose scope matches `identity`, in load order. A frozen list of frozen blocks. */
+  applicable(identity: McpFakeIdentity): readonly ValidatedBlock[];
+  /** The candidate entries for `tool` from the most specific tier declaring it. */
+  selectTier(tool: string, identity: McpFakeIdentity): McpFakeSelection | null;
+  /**
+   * Find the first unconsumed matching entry of the selected tier (load order,
+   * then `calls` order) and mark it consumed, synchronously (no `await`
+   * between find and mark), so concurrent calls never share an entry. The
+   * result is built and checked to serialize as JSON before the entry is
+   * marked, so a result that cannot be sent throws and leaves the entry
+   * unconsumed. An `anyArgs` entry answers any `arguments`, a non-object
+   * value included; only an `args` entry needs an object.
+   */
+  claim(tool: string, args: unknown, identity: McpFakeIdentity): McpFakeClaim;
+  /**
+   * The undeclared-tool policy, first of: `override` (`null` or omitted falls
+   * back to `identity.undeclared`, the request's or session's
+   * `X-AIMock-MCP-Undeclared` / `?undeclared=` value) → `deny` when any
+   * applicable scoped block says `deny` → `allow`.
+   */
+  policy(identity: McpFakeIdentity, override?: McpFakeUndeclaredPolicy | null): McpFakeUndeclaredPolicy;
+  /** Tool names any applicable block (any tier) declares, in load order. */
+  declaredTools(identity: McpFakeIdentity): string[];
+  /**
+   * Fake tools for `tools/list`, metadata from the most specific
+   * tier declaring each tool; inside that tier, the first block in load order
+   * that declares it. A tool with no `inputSchema` lists `{ type: "object" }`.
+   * Merging with registered tools is the mount's job.
+   */
+  listTools(identity: McpFakeIdentity): McpFakeToolListing[];
+  /**
+   * For `GET /__aimock/mcp/fakes`: applicable blocks with consumed state for
+   * `testId`. For a test id the cap evicted, every block says `evicted: true`.
+   * Deeply frozen.
+   */
+  snapshot(testId: string | null, context: string | null): readonly McpFakeBlockSnapshot[];
+  /** The consumed ids for `testId` (`null`: untagged), without creating state. */
+  private stateOf;
+  private stateFor;
+  /**
+   * FIFO cap: evict the oldest test ids until the cap holds, marking each
+   * evicted. A cap of `0` evicts nothing. The marks are not capped (see
+   * `evicted`).
+   */
+  private enforceCap;
+  /**
+   * The test-id FIFO cap on event logs: evict the oldest logs until the cap
+   * holds, marking each in the report-only `reportOverflow` (never `evicted`).
+   */
+  private enforceEventCap;
+}
+//# sourceMappingURL=mcp-fakes.d.ts.map
+//#endregion
+export { McpFakeAddOrigin, McpFakeAddOriginInternal, McpFakeAddResult, McpFakeBlockSnapshot, McpFakeDeclaredEntry, McpFakeIssue, McpFakeReportEvent, McpFakeReportPart, McpFakeStore, McpFakesAddError, McpFakesAddErrorJSON, RecordReplayLoadRule };
+//# sourceMappingURL=mcp-fakes.d.cts.map

package/dist/mcp-fakes.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-fakes.d.cts","names":[],"sources":["../src/mcp-fakes.ts"],"sourcesContent":[],"mappings":"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"}