@copilotkit/aimock 1.42.1 → 1.44.0

package/dist/message-text.cjs

@@ -0,0 +1,192 @@
+const require_constants = require('./constants.cjs');
+const require_echo_text = require('./echo-text.cjs');
+
+//#region src/message-text.ts
+/**
+* The one message builder of MCP fakes: every error and warning message of
+* mcp-fakes.ts, the `FixtureLoadError` message (fixture-loader.ts) and the MCP
+* identity error messages (helpers.ts) are built here. A message is a list of
+* parts: fixed text written by aimock, kept whole, and user parts (a tool
+* name, an id, a source, a JSON path, a value, a thrown message), each quoted
+* or rendered as JSON when it is made. `build` gives the user parts their
+* shares of the message's length budget and cuts each one once, with
+* `cutText` (echo-text.ts), so the fixed text is never cut and every
+* `… (<n> more chars)` count is the true count of chars left out of that
+* part. A leaf module (it imports only constants.ts and echo-text.ts).
+*/
+/**
+* User data in a message: its whole text, not cut until the message is built.
+* `units` is what a cut of it must not split; `max` is the most chars it may
+* take, whatever the budget: at least 1 (`Infinity` too), so a cut part
+* always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.
+*
+* @internal
+*/
+var UserText = class {
+	constructor(text, units, max) {
+		this.text = text;
+		this.units = units;
+		this.max = max;
+		if (!(max >= 1)) throw new RangeError(`a user part max must be at least 1, got ${max}`);
+		Object.freeze(this);
+	}
+};
+/**
+* A message that is not built yet: fixed text and user parts, in order.
+*
+* @internal
+*/
+var Message = class {
+	parts;
+	constructor(parts) {
+		this.parts = Object.freeze([...parts]);
+		Object.freeze(this);
+	}
+};
+/**
+* A message from a template: its literal text is fixed text, a number is
+* fixed text, a `Message` is spliced in part by part, and a `UserText` is a
+* user part.
+*
+* @internal
+*/
+function msg(strings, ...values) {
+	const parts = [];
+	strings.forEach((literal, i) => {
+		if (literal !== "") parts.push(literal);
+		if (i >= values.length) return;
+		const value = values[i];
+		if (typeof value === "number") parts.push(String(value));
+		else if (value instanceof Message) parts.push(...value.parts);
+		else parts.push(value);
+	});
+	return new Message(parts);
+}
+/**
+* Aimock's own text as a message: a constant, a fixed list, a built-in tag,
+* or a message that was already built. Never user data.
+*
+* @internal
+*/
+function fixed(text) {
+	return new Message([text]);
+}
+/**
+* Every control char (C0, DEL, C1) and the line and paragraph separators.
+* `JSON.stringify` escapes C0 controls but keeps DEL, C1 controls and the
+* separators raw; text that is not JSON (a text `FixtureLoadError` detail) can
+* hold any of them.
+*/
+const RAW_CONTROLS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g;
+/**
+* `text` JSON-quoted: quotes, backslashes and control chars escaped, DEL, C1
+* controls and U+2028 / U+2029 too (as `\uXXXX`), so the result is one line
+* of printable text that `JSON.parse` reads back as `text`.
+*
+* @internal
+*/
+function quoteJson(text) {
+	return escapeRawControls(JSON.stringify(text));
+}
+function escapeRawControls(json) {
+	return json.replace(RAW_CONTROLS, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+/**
+* A user string as a message part: JSON-quoted by `quoteJson`, cut as JSON
+* text (never inside an escape) to its share, and never to more than `max`
+* chars.
+*
+* @internal
+*/
+function quote(text, max = require_constants.MCP_FAKES_ECHO_LIMIT) {
+	return jsonText(JSON.stringify(text), max);
+}
+/**
+* User data already rendered as JSON text (a value, or a JSON path whose keys
+* are JSON-quoted), as a message part: every raw control char (C0, DEL, C1)
+* and line separator in it escaped as `\uXXXX` (in JSON text they can only be
+* inside its strings), cut as JSON text.
+*
+* @internal
+*/
+function jsonText(json, max = require_constants.MCP_FAKES_ECHO_LIMIT) {
+	return new UserText(escapeRawControls(json), "json", max);
+}
+/**
+* Text that is not JSON as a message part, cut as text (never inside a
+* surrogate pair).
+*
+* @internal
+*/
+function plainText(text, max = require_constants.MCP_FAKES_ECHO_LIMIT) {
+	return new UserText(text, "text", max);
+}
+/**
+* `message` built in a budget of its own (`limit` chars), as fixed text of
+* the message it goes into: a part of a message with its own cap.
+*
+* @internal
+*/
+function within(limit, message) {
+	return fixed(build(message, limit));
+}
+/**
+* The text of `message`, no longer than `limit` when its fixed text and one
+* char per user part fit in `limit`. The fixed text is kept whole. The user
+* parts share what is left: a part that fits in an equal share keeps all of
+* it, and the others split the rest (water-filling), each at most its `max`.
+* Each user part is then cut once, by `cutText`, to its share. A `limit` of
+* `Infinity` cuts each part only to its `max`. A `NaN` limit is a
+* `RangeError`; a limit too small for the fixed text still gives each
+* non-empty user part 1 char, a bare `…`.
+*
+* @internal
+*/
+function build(message, limit = Infinity) {
+	if (Number.isNaN(limit)) throw new RangeError("build limit must be a number, got NaN");
+	const users = message.parts.filter((part) => part instanceof UserText);
+	let fixedLength = 0;
+	for (const part of message.parts) if (typeof part === "string") fixedLength += part.length;
+	const shares = allocate(users, limit - fixedLength);
+	let i = 0;
+	return message.parts.map((part) => typeof part === "string" ? part : require_echo_text.cutText(part.text, shares[i++], part.units)).join("");
+}
+/**
+* Each user part's share of `room` chars, by water-filling: at least 1 char
+* each (a bare `…` when room runs out), but never more than the part's cap.
+*/
+function allocate(users, room) {
+	const caps = users.map((u) => Math.min(u.text.length, Math.floor(u.max)));
+	const order = caps.map((_, i) => i).sort((a, b) => caps[a] - caps[b]);
+	const shares = new Array(users.length).fill(0);
+	let left = Math.max(0, room);
+	order.forEach((index, k) => {
+		const fair = Math.floor(left / (order.length - k));
+		const share = Math.min(caps[index], Math.max(1, fair));
+		shares[index] = share;
+		left -= share;
+	});
+	return shares;
+}
+/**
+* The text of `message` with no cut at all: for a message that goes, as
+* text, into a user part of another message (a placeholder reason inside a
+* rendered value), which is then cut once there.
+*
+* @internal
+*/
+function fullText(message) {
+	return message.parts.map((part) => typeof part === "string" ? part : part.text).join("");
+}
+
+//#endregion
+exports.build = build;
+exports.fixed = fixed;
+exports.fullText = fullText;
+exports.jsonText = jsonText;
+exports.msg = msg;
+exports.plainText = plainText;
+exports.quote = quote;
+exports.quoteJson = quoteJson;
+exports.within = within;
+//# sourceMappingURL=message-text.cjs.map

package/dist/message-text.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.cjs","names":["MCP_FAKES_ECHO_LIMIT","cutText"],"sources":["../src/message-text.ts"],"sourcesContent":["/**\n * The one message builder of MCP fakes: every error and warning message of\n * mcp-fakes.ts, the `FixtureLoadError` message (fixture-loader.ts) and the MCP\n * identity error messages (helpers.ts) are built here. A message is a list of\n * parts: fixed text written by aimock, kept whole, and user parts (a tool\n * name, an id, a source, a JSON path, a value, a thrown message), each quoted\n * or rendered as JSON when it is made. `build` gives the user parts their\n * shares of the message's length budget and cuts each one once, with\n * `cutText` (echo-text.ts), so the fixed text is never cut and every\n * `… (<n> more chars)` count is the true count of chars left out of that\n * part. A leaf module (it imports only constants.ts and echo-text.ts).\n */\nimport { MCP_FAKES_ECHO_LIMIT } from \"./constants.js\";\nimport { cutText, type CutUnits } from \"./echo-text.js\";\n\n/**\n * User data in a message: its whole text, not cut until the message is built.\n * `units` is what a cut of it must not split; `max` is the most chars it may\n * take, whatever the budget: at least 1 (`Infinity` too), so a cut part\n * always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.\n *\n * @internal\n */\nexport class UserText {\n  constructor(\n    readonly text: string,\n    readonly units: CutUnits,\n    readonly max: number,\n  ) {\n    if (!(max >= 1)) throw new RangeError(`a user part max must be at least 1, got ${max}`);\n    Object.freeze(this);\n  }\n}\n\n/**\n * A message that is not built yet: fixed text and user parts, in order.\n *\n * @internal\n */\nexport class Message {\n  readonly parts: readonly (string | UserText)[];\n\n  constructor(parts: readonly (string | UserText)[]) {\n    this.parts = Object.freeze([...parts]);\n    Object.freeze(this);\n  }\n}\n\n/** What a `msg` template may interpolate: a user part, a message, or a number. */\nexport type MessageValue = UserText | Message | number;\n\n/**\n * A message from a template: its literal text is fixed text, a number is\n * fixed text, a `Message` is spliced in part by part, and a `UserText` is a\n * user part.\n *\n * @internal\n */\nexport function msg(strings: TemplateStringsArray, ...values: readonly MessageValue[]): Message {\n  const parts: (string | UserText)[] = [];\n  strings.forEach((literal, i) => {\n    if (literal !== \"\") parts.push(literal);\n    if (i >= values.length) return;\n    const value = values[i];\n    if (typeof value === \"number\") parts.push(String(value));\n    else if (value instanceof Message) parts.push(...value.parts);\n    else parts.push(value);\n  });\n  return new Message(parts);\n}\n\n/**\n * Aimock's own text as a message: a constant, a fixed list, a built-in tag,\n * or a message that was already built. Never user data.\n *\n * @internal\n */\nexport function fixed(text: string): Message {\n  return new Message([text]);\n}\n\n/**\n * Every control char (C0, DEL, C1) and the line and paragraph separators.\n * `JSON.stringify` escapes C0 controls but keeps DEL, C1 controls and the\n * separators raw; text that is not JSON (a text `FixtureLoadError` detail) can\n * hold any of them.\n */\n// eslint-disable-next-line no-control-regex -- matching control chars is the point\nconst RAW_CONTROLS = /[\\u0000-\\u001f\\u007f-\\u009f\\u2028\\u2029]/g;\n\n/**\n * `text` JSON-quoted: quotes, backslashes and control chars escaped, DEL, C1\n * controls and U+2028 / U+2029 too (as `\\uXXXX`), so the result is one line\n * of printable text that `JSON.parse` reads back as `text`.\n *\n * @internal\n */\nexport function quoteJson(text: string): string {\n  return escapeRawControls(JSON.stringify(text));\n}\n\nfunction escapeRawControls(json: string): string {\n  return json.replace(RAW_CONTROLS, (c) => `\\\\u${c.charCodeAt(0).toString(16).padStart(4, \"0\")}`);\n}\n\n/**\n * A user string as a message part: JSON-quoted by `quoteJson`, cut as JSON\n * text (never inside an escape) to its share, and never to more than `max`\n * chars.\n *\n * @internal\n */\nexport function quote(text: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return jsonText(JSON.stringify(text), max);\n}\n\n/**\n * User data already rendered as JSON text (a value, or a JSON path whose keys\n * are JSON-quoted), as a message part: every raw control char (C0, DEL, C1)\n * and line separator in it escaped as `\\uXXXX` (in JSON text they can only be\n * inside its strings), cut as JSON text.\n *\n * @internal\n */\nexport function jsonText(json: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return new UserText(escapeRawControls(json), \"json\", max);\n}\n\n/**\n * Text that is not JSON as a message part, cut as text (never inside a\n * surrogate pair).\n *\n * @internal\n */\nexport function plainText(text: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return new UserText(text, \"text\", max);\n}\n\n/**\n * `message` built in a budget of its own (`limit` chars), as fixed text of\n * the message it goes into: a part of a message with its own cap.\n *\n * @internal\n */\nexport function within(limit: number, message: Message): Message {\n  return fixed(build(message, limit));\n}\n\n/**\n * The text of `message`, no longer than `limit` when its fixed text and one\n * char per user part fit in `limit`. The fixed text is kept whole. The user\n * parts share what is left: a part that fits in an equal share keeps all of\n * it, and the others split the rest (water-filling), each at most its `max`.\n * Each user part is then cut once, by `cutText`, to its share. A `limit` of\n * `Infinity` cuts each part only to its `max`. A `NaN` limit is a\n * `RangeError`; a limit too small for the fixed text still gives each\n * non-empty user part 1 char, a bare `…`.\n *\n * @internal\n */\nexport function build(message: Message, limit = Infinity): string {\n  if (Number.isNaN(limit)) throw new RangeError(\"build limit must be a number, got NaN\");\n  const users = message.parts.filter((part): part is UserText => part instanceof UserText);\n  let fixedLength = 0;\n  for (const part of message.parts) if (typeof part === \"string\") fixedLength += part.length;\n  const shares = allocate(users, limit - fixedLength);\n  let i = 0;\n  return message.parts\n    .map((part) => (typeof part === \"string\" ? part : cutText(part.text, shares[i++], part.units)))\n    .join(\"\");\n}\n\n/**\n * Each user part's share of `room` chars, by water-filling: at least 1 char\n * each (a bare `…` when room runs out), but never more than the part's cap.\n */\nfunction allocate(users: readonly UserText[], room: number): number[] {\n  // `max` is at least 1 (UserText checks it), so a non-empty part's cap is too.\n  const caps = users.map((u) => Math.min(u.text.length, Math.floor(u.max)));\n  const order = caps.map((_, i) => i).sort((a, b) => caps[a] - caps[b]);\n  const shares: number[] = new Array<number>(users.length).fill(0);\n  let left = Math.max(0, room);\n  order.forEach((index, k) => {\n    const fair = Math.floor(left / (order.length - k));\n    const share = Math.min(caps[index], Math.max(1, fair));\n    shares[index] = share;\n    left -= share;\n  });\n  return shares;\n}\n\n/**\n * The text of `message` with no cut at all: for a message that goes, as\n * text, into a user part of another message (a placeholder reason inside a\n * rendered value), which is then cut once there.\n *\n * @internal\n */\nexport function fullText(message: Message): string {\n  return message.parts.map((part) => (typeof part === \"string\" ? part : part.text)).join(\"\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,WAAb,MAAsB;CACpB,YACE,AAAS,MACT,AAAS,OACT,AAAS,KACT;EAHS;EACA;EACA;AAET,MAAI,EAAE,OAAO,GAAI,OAAM,IAAI,WAAW,2CAA2C,MAAM;AACvF,SAAO,OAAO,KAAK;;;;;;;;AASvB,IAAa,UAAb,MAAqB;CACnB,AAAS;CAET,YAAY,OAAuC;AACjD,OAAK,QAAQ,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC;AACtC,SAAO,OAAO,KAAK;;;;;;;;;;AAcvB,SAAgB,IAAI,SAA+B,GAAG,QAA0C;CAC9F,MAAM,QAA+B,EAAE;AACvC,SAAQ,SAAS,SAAS,MAAM;AAC9B,MAAI,YAAY,GAAI,OAAM,KAAK,QAAQ;AACvC,MAAI,KAAK,OAAO,OAAQ;EACxB,MAAM,QAAQ,OAAO;AACrB,MAAI,OAAO,UAAU,SAAU,OAAM,KAAK,OAAO,MAAM,CAAC;WAC/C,iBAAiB,QAAS,OAAM,KAAK,GAAG,MAAM,MAAM;MACxD,OAAM,KAAK,MAAM;GACtB;AACF,QAAO,IAAI,QAAQ,MAAM;;;;;;;;AAS3B,SAAgB,MAAM,MAAuB;AAC3C,QAAO,IAAI,QAAQ,CAAC,KAAK,CAAC;;;;;;;;AAU5B,MAAM,eAAe;;;;;;;;AASrB,SAAgB,UAAU,MAAsB;AAC9C,QAAO,kBAAkB,KAAK,UAAU,KAAK,CAAC;;AAGhD,SAAS,kBAAkB,MAAsB;AAC/C,QAAO,KAAK,QAAQ,eAAe,MAAM,MAAM,EAAE,WAAW,EAAE,CAAC,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,GAAG;;;;;;;;;AAUjG,SAAgB,MAAM,MAAc,MAAcA,wCAAgC;AAChF,QAAO,SAAS,KAAK,UAAU,KAAK,EAAE,IAAI;;;;;;;;;;AAW5C,SAAgB,SAAS,MAAc,MAAcA,wCAAgC;AACnF,QAAO,IAAI,SAAS,kBAAkB,KAAK,EAAE,QAAQ,IAAI;;;;;;;;AAS3D,SAAgB,UAAU,MAAc,MAAcA,wCAAgC;AACpF,QAAO,IAAI,SAAS,MAAM,QAAQ,IAAI;;;;;;;;AASxC,SAAgB,OAAO,OAAe,SAA2B;AAC/D,QAAO,MAAM,MAAM,SAAS,MAAM,CAAC;;;;;;;;;;;;;;AAerC,SAAgB,MAAM,SAAkB,QAAQ,UAAkB;AAChE,KAAI,OAAO,MAAM,MAAM,CAAE,OAAM,IAAI,WAAW,wCAAwC;CACtF,MAAM,QAAQ,QAAQ,MAAM,QAAQ,SAA2B,gBAAgB,SAAS;CACxF,IAAI,cAAc;AAClB,MAAK,MAAM,QAAQ,QAAQ,MAAO,KAAI,OAAO,SAAS,SAAU,gBAAe,KAAK;CACpF,MAAM,SAAS,SAAS,OAAO,QAAQ,YAAY;CACnD,IAAI,IAAI;AACR,QAAO,QAAQ,MACZ,KAAK,SAAU,OAAO,SAAS,WAAW,OAAOC,0BAAQ,KAAK,MAAM,OAAO,MAAM,KAAK,MAAM,CAAE,CAC9F,KAAK,GAAG;;;;;;AAOb,SAAS,SAAS,OAA4B,MAAwB;CAEpE,MAAM,OAAO,MAAM,KAAK,MAAM,KAAK,IAAI,EAAE,KAAK,QAAQ,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC;CACzE,MAAM,QAAQ,KAAK,KAAK,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,KAAK,KAAK,KAAK,GAAG;CACrE,MAAM,SAAmB,IAAI,MAAc,MAAM,OAAO,CAAC,KAAK,EAAE;CAChE,IAAI,OAAO,KAAK,IAAI,GAAG,KAAK;AAC5B,OAAM,SAAS,OAAO,MAAM;EAC1B,MAAM,OAAO,KAAK,MAAM,QAAQ,MAAM,SAAS,GAAG;EAClD,MAAM,QAAQ,KAAK,IAAI,KAAK,QAAQ,KAAK,IAAI,GAAG,KAAK,CAAC;AACtD,SAAO,SAAS;AAChB,UAAQ;GACR;AACF,QAAO;;;;;;;;;AAUT,SAAgB,SAAS,SAA0B;AACjD,QAAO,QAAQ,MAAM,KAAK,SAAU,OAAO,SAAS,WAAW,OAAO,KAAK,KAAM,CAAC,KAAK,GAAG"}

package/dist/message-text.d.cts

@@ -0,0 +1,31 @@
+import { CutUnits } from "./echo-text.cjs";
+
+//#region src/message-text.d.ts
+
+/**
+ * User data in a message: its whole text, not cut until the message is built.
+ * `units` is what a cut of it must not split; `max` is the most chars it may
+ * take, whatever the budget: at least 1 (`Infinity` too), so a cut part
+ * always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.
+ *
+ * @internal
+ */
+declare class UserText {
+  readonly text: string;
+  readonly units: CutUnits;
+  readonly max: number;
+  constructor(text: string, units: CutUnits, max: number);
+}
+/**
+ * A message that is not built yet: fixed text and user parts, in order.
+ *
+ * @internal
+ */
+declare class Message {
+  readonly parts: readonly (string | UserText)[];
+  constructor(parts: readonly (string | UserText)[]);
+}
+/** What a `msg` template may interpolate: a user part, a message, or a number. */
+//#endregion
+export { Message };
+//# sourceMappingURL=message-text.d.cts.map

package/dist/message-text.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.d.cts","names":[],"sources":["../src/message-text.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;AAgBA;AAAoB,cAhBP,QAAA,CAgBO;WACiB,IAAA,EAAA,MAAA;WAEG,KAAA,EAhBpB,QAgBoB;EAAQ,SAAA,GAAA,EAAA,MAAA;mCAhB5B;;;;;;;cAaP,OAAA;qCACwB;wCAEG"}

package/dist/message-text.d.ts

@@ -0,0 +1,31 @@
+import { CutUnits } from "./echo-text.js";
+
+//#region src/message-text.d.ts
+
+/**
+ * User data in a message: its whole text, not cut until the message is built.
+ * `units` is what a cut of it must not split; `max` is the most chars it may
+ * take, whatever the budget: at least 1 (`Infinity` too), so a cut part
+ * always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.
+ *
+ * @internal
+ */
+declare class UserText {
+  readonly text: string;
+  readonly units: CutUnits;
+  readonly max: number;
+  constructor(text: string, units: CutUnits, max: number);
+}
+/**
+ * A message that is not built yet: fixed text and user parts, in order.
+ *
+ * @internal
+ */
+declare class Message {
+  readonly parts: readonly (string | UserText)[];
+  constructor(parts: readonly (string | UserText)[]);
+}
+/** What a `msg` template may interpolate: a user part, a message, or a number. */
+//#endregion
+export { Message };
+//# sourceMappingURL=message-text.d.ts.map

package/dist/message-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.d.ts","names":[],"sources":["../src/message-text.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;;;;;AAgBA;AAAoB,cAhBP,QAAA,CAgBO;WACiB,IAAA,EAAA,MAAA;WAEG,KAAA,EAhBpB,QAgBoB;EAAQ,SAAA,GAAA,EAAA,MAAA;mCAhB5B;;;;;;;cAaP,OAAA;qCACwB;wCAEG"}

package/dist/message-text.js

@@ -0,0 +1,184 @@
+import { MCP_FAKES_ECHO_LIMIT } from "./constants.js";
+import { cutText } from "./echo-text.js";
+
+//#region src/message-text.ts
+/**
+* The one message builder of MCP fakes: every error and warning message of
+* mcp-fakes.ts, the `FixtureLoadError` message (fixture-loader.ts) and the MCP
+* identity error messages (helpers.ts) are built here. A message is a list of
+* parts: fixed text written by aimock, kept whole, and user parts (a tool
+* name, an id, a source, a JSON path, a value, a thrown message), each quoted
+* or rendered as JSON when it is made. `build` gives the user parts their
+* shares of the message's length budget and cuts each one once, with
+* `cutText` (echo-text.ts), so the fixed text is never cut and every
+* `… (<n> more chars)` count is the true count of chars left out of that
+* part. A leaf module (it imports only constants.ts and echo-text.ts).
+*/
+/**
+* User data in a message: its whole text, not cut until the message is built.
+* `units` is what a cut of it must not split; `max` is the most chars it may
+* take, whatever the budget: at least 1 (`Infinity` too), so a cut part
+* always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.
+*
+* @internal
+*/
+var UserText = class {
+	constructor(text, units, max) {
+		this.text = text;
+		this.units = units;
+		this.max = max;
+		if (!(max >= 1)) throw new RangeError(`a user part max must be at least 1, got ${max}`);
+		Object.freeze(this);
+	}
+};
+/**
+* A message that is not built yet: fixed text and user parts, in order.
+*
+* @internal
+*/
+var Message = class {
+	parts;
+	constructor(parts) {
+		this.parts = Object.freeze([...parts]);
+		Object.freeze(this);
+	}
+};
+/**
+* A message from a template: its literal text is fixed text, a number is
+* fixed text, a `Message` is spliced in part by part, and a `UserText` is a
+* user part.
+*
+* @internal
+*/
+function msg(strings, ...values) {
+	const parts = [];
+	strings.forEach((literal, i) => {
+		if (literal !== "") parts.push(literal);
+		if (i >= values.length) return;
+		const value = values[i];
+		if (typeof value === "number") parts.push(String(value));
+		else if (value instanceof Message) parts.push(...value.parts);
+		else parts.push(value);
+	});
+	return new Message(parts);
+}
+/**
+* Aimock's own text as a message: a constant, a fixed list, a built-in tag,
+* or a message that was already built. Never user data.
+*
+* @internal
+*/
+function fixed(text) {
+	return new Message([text]);
+}
+/**
+* Every control char (C0, DEL, C1) and the line and paragraph separators.
+* `JSON.stringify` escapes C0 controls but keeps DEL, C1 controls and the
+* separators raw; text that is not JSON (a text `FixtureLoadError` detail) can
+* hold any of them.
+*/
+const RAW_CONTROLS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g;
+/**
+* `text` JSON-quoted: quotes, backslashes and control chars escaped, DEL, C1
+* controls and U+2028 / U+2029 too (as `\uXXXX`), so the result is one line
+* of printable text that `JSON.parse` reads back as `text`.
+*
+* @internal
+*/
+function quoteJson(text) {
+	return escapeRawControls(JSON.stringify(text));
+}
+function escapeRawControls(json) {
+	return json.replace(RAW_CONTROLS, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+/**
+* A user string as a message part: JSON-quoted by `quoteJson`, cut as JSON
+* text (never inside an escape) to its share, and never to more than `max`
+* chars.
+*
+* @internal
+*/
+function quote(text, max = MCP_FAKES_ECHO_LIMIT) {
+	return jsonText(JSON.stringify(text), max);
+}
+/**
+* User data already rendered as JSON text (a value, or a JSON path whose keys
+* are JSON-quoted), as a message part: every raw control char (C0, DEL, C1)
+* and line separator in it escaped as `\uXXXX` (in JSON text they can only be
+* inside its strings), cut as JSON text.
+*
+* @internal
+*/
+function jsonText(json, max = MCP_FAKES_ECHO_LIMIT) {
+	return new UserText(escapeRawControls(json), "json", max);
+}
+/**
+* Text that is not JSON as a message part, cut as text (never inside a
+* surrogate pair).
+*
+* @internal
+*/
+function plainText(text, max = MCP_FAKES_ECHO_LIMIT) {
+	return new UserText(text, "text", max);
+}
+/**
+* `message` built in a budget of its own (`limit` chars), as fixed text of
+* the message it goes into: a part of a message with its own cap.
+*
+* @internal
+*/
+function within(limit, message) {
+	return fixed(build(message, limit));
+}
+/**
+* The text of `message`, no longer than `limit` when its fixed text and one
+* char per user part fit in `limit`. The fixed text is kept whole. The user
+* parts share what is left: a part that fits in an equal share keeps all of
+* it, and the others split the rest (water-filling), each at most its `max`.
+* Each user part is then cut once, by `cutText`, to its share. A `limit` of
+* `Infinity` cuts each part only to its `max`. A `NaN` limit is a
+* `RangeError`; a limit too small for the fixed text still gives each
+* non-empty user part 1 char, a bare `…`.
+*
+* @internal
+*/
+function build(message, limit = Infinity) {
+	if (Number.isNaN(limit)) throw new RangeError("build limit must be a number, got NaN");
+	const users = message.parts.filter((part) => part instanceof UserText);
+	let fixedLength = 0;
+	for (const part of message.parts) if (typeof part === "string") fixedLength += part.length;
+	const shares = allocate(users, limit - fixedLength);
+	let i = 0;
+	return message.parts.map((part) => typeof part === "string" ? part : cutText(part.text, shares[i++], part.units)).join("");
+}
+/**
+* Each user part's share of `room` chars, by water-filling: at least 1 char
+* each (a bare `…` when room runs out), but never more than the part's cap.
+*/
+function allocate(users, room) {
+	const caps = users.map((u) => Math.min(u.text.length, Math.floor(u.max)));
+	const order = caps.map((_, i) => i).sort((a, b) => caps[a] - caps[b]);
+	const shares = new Array(users.length).fill(0);
+	let left = Math.max(0, room);
+	order.forEach((index, k) => {
+		const fair = Math.floor(left / (order.length - k));
+		const share = Math.min(caps[index], Math.max(1, fair));
+		shares[index] = share;
+		left -= share;
+	});
+	return shares;
+}
+/**
+* The text of `message` with no cut at all: for a message that goes, as
+* text, into a user part of another message (a placeholder reason inside a
+* rendered value), which is then cut once there.
+*
+* @internal
+*/
+function fullText(message) {
+	return message.parts.map((part) => typeof part === "string" ? part : part.text).join("");
+}
+
+//#endregion
+export { build, fixed, fullText, jsonText, msg, plainText, quote, quoteJson, within };
+//# sourceMappingURL=message-text.js.map

package/dist/message-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-text.js","names":[],"sources":["../src/message-text.ts"],"sourcesContent":["/**\n * The one message builder of MCP fakes: every error and warning message of\n * mcp-fakes.ts, the `FixtureLoadError` message (fixture-loader.ts) and the MCP\n * identity error messages (helpers.ts) are built here. A message is a list of\n * parts: fixed text written by aimock, kept whole, and user parts (a tool\n * name, an id, a source, a JSON path, a value, a thrown message), each quoted\n * or rendered as JSON when it is made. `build` gives the user parts their\n * shares of the message's length budget and cuts each one once, with\n * `cutText` (echo-text.ts), so the fixed text is never cut and every\n * `… (<n> more chars)` count is the true count of chars left out of that\n * part. A leaf module (it imports only constants.ts and echo-text.ts).\n */\nimport { MCP_FAKES_ECHO_LIMIT } from \"./constants.js\";\nimport { cutText, type CutUnits } from \"./echo-text.js\";\n\n/**\n * User data in a message: its whole text, not cut until the message is built.\n * `units` is what a cut of it must not split; `max` is the most chars it may\n * take, whatever the budget: at least 1 (`Infinity` too), so a cut part\n * always keeps at least a `…`. A `max` below 1, or `NaN`, is a `RangeError`.\n *\n * @internal\n */\nexport class UserText {\n  constructor(\n    readonly text: string,\n    readonly units: CutUnits,\n    readonly max: number,\n  ) {\n    if (!(max >= 1)) throw new RangeError(`a user part max must be at least 1, got ${max}`);\n    Object.freeze(this);\n  }\n}\n\n/**\n * A message that is not built yet: fixed text and user parts, in order.\n *\n * @internal\n */\nexport class Message {\n  readonly parts: readonly (string | UserText)[];\n\n  constructor(parts: readonly (string | UserText)[]) {\n    this.parts = Object.freeze([...parts]);\n    Object.freeze(this);\n  }\n}\n\n/** What a `msg` template may interpolate: a user part, a message, or a number. */\nexport type MessageValue = UserText | Message | number;\n\n/**\n * A message from a template: its literal text is fixed text, a number is\n * fixed text, a `Message` is spliced in part by part, and a `UserText` is a\n * user part.\n *\n * @internal\n */\nexport function msg(strings: TemplateStringsArray, ...values: readonly MessageValue[]): Message {\n  const parts: (string | UserText)[] = [];\n  strings.forEach((literal, i) => {\n    if (literal !== \"\") parts.push(literal);\n    if (i >= values.length) return;\n    const value = values[i];\n    if (typeof value === \"number\") parts.push(String(value));\n    else if (value instanceof Message) parts.push(...value.parts);\n    else parts.push(value);\n  });\n  return new Message(parts);\n}\n\n/**\n * Aimock's own text as a message: a constant, a fixed list, a built-in tag,\n * or a message that was already built. Never user data.\n *\n * @internal\n */\nexport function fixed(text: string): Message {\n  return new Message([text]);\n}\n\n/**\n * Every control char (C0, DEL, C1) and the line and paragraph separators.\n * `JSON.stringify` escapes C0 controls but keeps DEL, C1 controls and the\n * separators raw; text that is not JSON (a text `FixtureLoadError` detail) can\n * hold any of them.\n */\n// eslint-disable-next-line no-control-regex -- matching control chars is the point\nconst RAW_CONTROLS = /[\\u0000-\\u001f\\u007f-\\u009f\\u2028\\u2029]/g;\n\n/**\n * `text` JSON-quoted: quotes, backslashes and control chars escaped, DEL, C1\n * controls and U+2028 / U+2029 too (as `\\uXXXX`), so the result is one line\n * of printable text that `JSON.parse` reads back as `text`.\n *\n * @internal\n */\nexport function quoteJson(text: string): string {\n  return escapeRawControls(JSON.stringify(text));\n}\n\nfunction escapeRawControls(json: string): string {\n  return json.replace(RAW_CONTROLS, (c) => `\\\\u${c.charCodeAt(0).toString(16).padStart(4, \"0\")}`);\n}\n\n/**\n * A user string as a message part: JSON-quoted by `quoteJson`, cut as JSON\n * text (never inside an escape) to its share, and never to more than `max`\n * chars.\n *\n * @internal\n */\nexport function quote(text: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return jsonText(JSON.stringify(text), max);\n}\n\n/**\n * User data already rendered as JSON text (a value, or a JSON path whose keys\n * are JSON-quoted), as a message part: every raw control char (C0, DEL, C1)\n * and line separator in it escaped as `\\uXXXX` (in JSON text they can only be\n * inside its strings), cut as JSON text.\n *\n * @internal\n */\nexport function jsonText(json: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return new UserText(escapeRawControls(json), \"json\", max);\n}\n\n/**\n * Text that is not JSON as a message part, cut as text (never inside a\n * surrogate pair).\n *\n * @internal\n */\nexport function plainText(text: string, max: number = MCP_FAKES_ECHO_LIMIT): UserText {\n  return new UserText(text, \"text\", max);\n}\n\n/**\n * `message` built in a budget of its own (`limit` chars), as fixed text of\n * the message it goes into: a part of a message with its own cap.\n *\n * @internal\n */\nexport function within(limit: number, message: Message): Message {\n  return fixed(build(message, limit));\n}\n\n/**\n * The text of `message`, no longer than `limit` when its fixed text and one\n * char per user part fit in `limit`. The fixed text is kept whole. The user\n * parts share what is left: a part that fits in an equal share keeps all of\n * it, and the others split the rest (water-filling), each at most its `max`.\n * Each user part is then cut once, by `cutText`, to its share. A `limit` of\n * `Infinity` cuts each part only to its `max`. A `NaN` limit is a\n * `RangeError`; a limit too small for the fixed text still gives each\n * non-empty user part 1 char, a bare `…`.\n *\n * @internal\n */\nexport function build(message: Message, limit = Infinity): string {\n  if (Number.isNaN(limit)) throw new RangeError(\"build limit must be a number, got NaN\");\n  const users = message.parts.filter((part): part is UserText => part instanceof UserText);\n  let fixedLength = 0;\n  for (const part of message.parts) if (typeof part === \"string\") fixedLength += part.length;\n  const shares = allocate(users, limit - fixedLength);\n  let i = 0;\n  return message.parts\n    .map((part) => (typeof part === \"string\" ? part : cutText(part.text, shares[i++], part.units)))\n    .join(\"\");\n}\n\n/**\n * Each user part's share of `room` chars, by water-filling: at least 1 char\n * each (a bare `…` when room runs out), but never more than the part's cap.\n */\nfunction allocate(users: readonly UserText[], room: number): number[] {\n  // `max` is at least 1 (UserText checks it), so a non-empty part's cap is too.\n  const caps = users.map((u) => Math.min(u.text.length, Math.floor(u.max)));\n  const order = caps.map((_, i) => i).sort((a, b) => caps[a] - caps[b]);\n  const shares: number[] = new Array<number>(users.length).fill(0);\n  let left = Math.max(0, room);\n  order.forEach((index, k) => {\n    const fair = Math.floor(left / (order.length - k));\n    const share = Math.min(caps[index], Math.max(1, fair));\n    shares[index] = share;\n    left -= share;\n  });\n  return shares;\n}\n\n/**\n * The text of `message` with no cut at all: for a message that goes, as\n * text, into a user part of another message (a placeholder reason inside a\n * rendered value), which is then cut once there.\n *\n * @internal\n */\nexport function fullText(message: Message): string {\n  return message.parts.map((part) => (typeof part === \"string\" ? part : part.text)).join(\"\");\n}\n"],"mappings":"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"}

package/dist/messages.cjs

@@ -1,9 +1,9 @@
 const require_helpers = require('./helpers.cjs');
-const require_router = require('./router.cjs');
 const require_sse_writer = require('./sse-writer.cjs');
-const require_interruption = require('./interruption.cjs');
 const require_chaos = require('./chaos.cjs');
+const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
+const require_interruption = require('./interruption.cjs');
 
 //#region src/messages.ts
 /**
@@ -562,7 +562,8 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 		blockIndex++;
 	}
 	if (blocks && blocks.length > 0) {
-		const ordered = require_helpers.resolveFixtureBlocks(blocks);
+		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
+		const ordered = outcome.ordered;
 		for (const block of ordered) if (block.type === "text") {
 			events.push({
 				type: "content_block_start",
@@ -628,7 +629,7 @@ function buildClaudeContentWithToolCallsStreamEvents(content, toolCalls, model,
 		events.push({
 			type: "message_delta",
 			delta: {
-				stop_reason: claudeStopReason(overrides?.finishReason, "tool_use"),
+				stop_reason: claudeStopReason(overrides?.finishReason, outcome.hasToolCalls ? "tool_use" : "end_turn"),
 				stop_sequence: null
 			},
 			usage: { output_tokens: claudeUsage(overrides).output_tokens }
@@ -731,8 +732,11 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 			input: argsObj
 		};
 	};
+	let blockHasTools;
 	if (blocks && blocks.length > 0) {
-		const ordered = require_helpers.resolveFixtureBlocks(blocks);
+		const outcome = require_helpers.resolveFixtureBlockOutcome(blocks);
+		const ordered = outcome.ordered;
+		blockHasTools = outcome.hasToolCalls;
 		for (const block of ordered) if (block.type === "text") contentBlocks.push({
 			type: "text",
 			text: block.text
@@ -755,7 +759,7 @@ function buildClaudeContentWithToolCallsResponse(content, toolCalls, model, logg
 		role: overrides?.role ?? "assistant",
 		content: contentBlocks,
 		model: overrides?.model ?? model,
-		stop_reason: claudeStopReason(overrides?.finishReason, "tool_use"),
+		stop_reason: claudeStopReason(overrides?.finishReason, blockHasTools === false ? "end_turn" : "tool_use"),
 		stop_sequence: null,
 		usage: claudeUsage(overrides)
 	};
@@ -826,6 +830,24 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		} }));
 		return;
 	}
+	const messagesError = !Array.isArray(claudeReq.messages) ? "messages must be an array" : claudeReq.messages.some((message) => !require_helpers.isJsonObject(message)) ? "messages entries must be JSON objects" : claudeReq.messages.some((message) => (message.role === "user" || message.role === "assistant") && typeof message.content === "number") ? "messages content must be a string or an array of content blocks" : null;
+	if (messagesError) {
+		journal.add({
+			method: req.method ?? "POST",
+			path: req.url ?? "/v1/messages",
+			headers: require_helpers.flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 400,
+				fixture: null
+			}
+		});
+		require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+			message: messagesError,
+			type: "invalid_request_error"
+		} }));
+		return;
+	}
 	const thinkingViolation = validateThinkingInvariants(claudeReq);
 	if (thinkingViolation) {
 		const effectiveStrict = require_helpers.resolveStrictMode(defaults.strict, req.headers);
@@ -854,6 +876,26 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		}
 		logger.warn(`THINKING: ${violationMessage} (strict off — replaying anyway)`);
 	}
+	if (claudeReq.tools && claudeReq.tools.length > 0) {
+		const toolsError = !Array.isArray(claudeReq.tools) ? "tools must be an array" : claudeReq.tools.some((tool) => tool === null) ? "tools entries must not be null" : null;
+		if (toolsError) {
+			journal.add({
+				method: req.method ?? "POST",
+				path: req.url ?? "/v1/messages",
+				headers: require_helpers.flattenHeaders(req.headers),
+				body: null,
+				response: {
+					status: 400,
+					fixture: null
+				}
+			});
+			require_sse_writer.writeErrorResponse(res, 400, JSON.stringify({ error: {
+				message: toolsError,
+				type: "invalid_request_error"
+			} }));
+			return;
+		}
+	}
 	const completionReq = claudeToCompletionRequest(claudeReq);
 	completionReq._context = require_helpers.getContext(req);
 	const testId = require_helpers.getTestId(req);
@@ -866,7 +908,7 @@ async function handleMessages(req, res, raw, fixtures, journal, defaults, setCor
 		const snippet = typeof lastUserMsg?.content === "string" ? lastUserMsg.content.slice(0, 80) : "";
 		logger.debug(`No fixture matched for request (model=${completionReq.model ?? "?"}, msg="${snippet}")`);
 	}
-	if (require_chaos.applyChaos(res, fixture, defaults.chaos, req.headers, req.url, journal, {
+	if (await require_chaos.applyChaosAsync(res, fixture, defaults.chaos, req.headers, req.url, journal, {
 		method: req.method ?? "POST",
 		path: req.url ?? "/v1/messages",
 		headers: require_helpers.flattenHeaders(req.headers),