@copilotkit/aimock 1.45.1 → 1.47.0

package/dist/response/lifecycle.js

@@ -0,0 +1,211 @@
+import { responseGoneReason } from "../chaos.js";
+import { createInterruptionSignal } from "../interruption.js";
+
+//#region src/response/lifecycle.ts
+/** The journal `interruptReason` for a client that left before the reply finished. */
+const CLIENT_ABORTED = "client aborted";
+/**
+* The journal `interruptReason` for a response aimock tore down itself: the
+* chaos `disconnect` action or a server-side `destroy`. It is the name the
+* chaos journal entry records (`chaosAction: "disconnect"`), so a teardown
+* aimock caused is never blamed on the client.
+*/
+const AIMOCK_DISCONNECTED = "disconnect";
+/**
+* Subscribe to `close`, guarded the same way as `awaitChaosLatency`: a partial
+* test double without `once` is not subscribed, and only a listener that was
+* added is ever removed, through a remover that exists.
+*/
+function subscribeClose(source, onClose) {
+	if (typeof source.once !== "function") return void 0;
+	source.once("close", onClose);
+	if (typeof source.off === "function") return () => source.off?.("close", onClose);
+	if (typeof source.removeListener === "function") return () => source.removeListener?.("close", onClose);
+}
+function createLifecycle(interruption, goneAtStart, subscribe) {
+	const controller = new AbortController();
+	let firstCause;
+	const abortWith = (cause) => {
+		if (controller.signal.aborted) return;
+		firstCause = cause;
+		controller.abort();
+	};
+	const onFixtureAbort = () => abortWith("fixture");
+	interruption?.signal.addEventListener("abort", onFixtureAbort, { once: true });
+	let unsubscribe;
+	if (goneAtStart !== void 0) abortWith(goneAtStart);
+	else unsubscribe = subscribe(abortWith);
+	return {
+		signal: controller.signal,
+		cause: () => firstCause,
+		reason: () => {
+			if (firstCause === "fixture") return interruption?.reason();
+			if (firstCause === "client") return CLIENT_ABORTED;
+			if (firstCause === "server") return AIMOCK_DISCONNECTED;
+		},
+		tick: () => {
+			interruption?.tick();
+		},
+		dispose: () => {
+			unsubscribe?.();
+			unsubscribe = void 0;
+			interruption?.signal.removeEventListener("abort", onFixtureAbort);
+			interruption?.cleanup();
+		}
+	};
+}
+/** The request socket of `res`, or `undefined` when it carries none. */
+function requestSocket(res) {
+	const owner = res;
+	return owner.req?.socket ?? owner.socket ?? void 0;
+}
+/**
+* THE client hang-up rule, shared by the delivery lifecycle and the proxy
+* relay: the client's socket closed or reset.
+*
+* - A reset, or a write into a socket the peer closed, leaves `errored` set
+*   (ECONNRESET / EPIPE).
+* - aimock's server keeps Node's default `httpAllowHalfOpen: false`, so a
+*   client FIN makes Node end our write side: the socket is `writableEnded`
+*   while the response is not. That is the evidence the client closed.
+*
+* A FIN alone (`readableEnded` with neither of those) is not a hang-up: it is
+* what the socket shows when aimock tore the response down before Node
+* answered the FIN. A real client FIN that Node has not answered yet looks the
+* same, so this rule also classifies it as not a hang-up. aimock's own
+* `destroy()` leaves neither signal.
+*/
+function closedByClient(socket) {
+	return (socket.errored ?? null) !== null || socket.writableEnded === true;
+}
+/**
+* Who tore down a response that is gone without having ended. After the fact
+* `res.destroyed` reads the same either way, so this reads the evidence:
+*
+* - a chaos `disconnect` marked the response before destroying it: aimock;
+* - the request socket meets {@link closedByClient}: the client;
+* - neither: aimock destroyed it server-side.
+*
+* `socket` defaults to the response's request socket. With no socket to read
+* (a partial test double) the client attribution is kept.
+*/
+function teardownCause(res, socket = requestSocket(res)) {
+	if (responseGoneReason(res) === "chaos-disconnected") return "server";
+	if (!socket) return "client";
+	return closedByClient(socket) ? "client" : "server";
+}
+/**
+* The request socket's `bytesWritten` when each delivery started, so the
+* status-line rule counts only this response's bytes on a keep-alive socket.
+*/
+const deliveryStartBytes = /* @__PURE__ */ new WeakMap();
+/**
+* Record where this response's bytes start on its socket. A response whose
+* head was already committed when the delivery started is not recorded:
+* {@link statusLineSent} keeps the `headersSent` rule for it.
+*/
+function noteDeliveryStart(res) {
+	if (deliveryStartBytes.has(res) || res.headersSent) return;
+	const bytes = requestSocket(res)?.bytesWritten;
+	if (typeof bytes === "number") deliveryStartBytes.set(res, bytes);
+}
+/**
+* Whether this response's status line reached the client's socket: a byte of
+* it was handed to the socket after {@link noteDeliveryStart}. `headersSent`
+* is not that test: `writeHead` sets it before any byte is written. With no
+* recorded start, or no socket to read, `headersSent` is the fallback.
+*/
+function statusLineSent(res) {
+	const start = deliveryStartBytes.get(res);
+	const bytes = requestSocket(res)?.bytesWritten;
+	if (start === void 0 || typeof bytes !== "number") return res.headersSent;
+	return bytes > start;
+}
+/** The journal `interruptReason` for {@link teardownCause}. */
+function teardownReason(res) {
+	return teardownCause(res) === "client" ? CLIENT_ABORTED : AIMOCK_DISCONNECTED;
+}
+/**
+* HTTP delivery lifecycle. A `close` before `res.writableFinished` aborts it,
+* and {@link teardownCause} decides whose teardown it was: the client
+* (`"client"`) or aimock itself (`"server"`). A response that is already gone
+* at construction aborts at once with the same attribution. A chaos
+* `disconnect` destroys without ending, so no `writableEnded` check stops a
+* writer for it. Only an already-ended response does not abort: the frame
+* loop exits on its `writableEnded` check. The fixture interruption is
+* created only when `streaming` is true (it is streaming-only).
+*/
+function httpLifecycle(res, fixture, opts) {
+	const interruption = opts.streaming && fixture ? createInterruptionSignal(fixture) : null;
+	const gone = responseGoneReason(res);
+	return createLifecycle(interruption, gone === null || gone === "already-ended" ? void 0 : teardownCause(res), (onGone) => subscribeClose(res, () => {
+		if (!res.writableFinished) onGone(teardownCause(res));
+	}));
+}
+/**
+* Per watched connection: whether its `close` event has fired. Only sockets
+* watched while open are recorded, so an entry is evidence, not a guess.
+*/
+const wsCloseEmitted = /* @__PURE__ */ new WeakMap();
+/**
+* Start recording when `ws` emits `close`, so {@link wsClosedCause} can tell
+* aimock's own close from the client's. Each WS transport calls it when the
+* connection opens. Idempotent, and a no-op once closed.
+*/
+function watchWsClose(ws) {
+	if (ws.isClosed || wsCloseEmitted.has(ws)) return;
+	const source = ws;
+	if (typeof source.once !== "function") return;
+	wsCloseEmitted.set(ws, false);
+	source.once("close", () => wsCloseEmitted.set(ws, true));
+}
+/**
+* Who closed a socket that reads `isClosed`, or `undefined` while it is open.
+*
+* `WebSocketConnection` marks itself closed and emits `close` in the same step
+* for a client close frame, a lost connection, and `destroy()`. Only aimock's
+* own `close()` (a write or buffer limit, a bad frame, a strict miss, shutdown)
+* marks it closed at once and emits `close` about 100ms later. So a socket
+* watched while open ({@link watchWsClose}) that is closed with no `close` yet
+* was closed by aimock (`"server"`). Any other closed socket reads as the
+* client leaving, as before.
+*/
+function wsClosedCause(ws) {
+	if (!ws.isClosed) return void 0;
+	return wsCloseEmitted.get(ws) === false ? "server" : "client";
+}
+/**
+* WebSocket turn lifecycle. A WS turn is always a stream, so it always owns
+* the fixture interruption. A `close` means the client left. A socket already
+* closed at construction aborts at once with {@link wsClosedCause}. Callers
+* never create their own interruption object.
+*/
+function wsLifecycle(ws, fixture) {
+	return createLifecycle(fixture ? createInterruptionSignal(fixture) : null, wsClosedCause(ws), (onGone) => subscribeClose(ws, () => onGone("client")));
+}
+/**
+* Journal a WS turn that stopped because its lifecycle aborted or its socket
+* closed. This is the closed-socket rule every WS transport uses: the
+* lifecycle's reason when it has one, else the closed socket's cause
+* ({@link wsClosedCause}): {@link AIMOCK_DISCONNECTED} for aimock's own close,
+* {@link CLIENT_ABORTED} for the client. A turn with no lifecycle (it never
+* waits) passes none.
+*/
+function markWsTurnStopped(entry, ws, lifecycle) {
+	const cause = wsClosedCause(ws);
+	const socketReason = cause === "server" ? AIMOCK_DISCONNECTED : cause === "client" ? CLIENT_ABORTED : void 0;
+	markInterrupted(entry, lifecycle?.reason() ?? socketReason);
+}
+/**
+* Mark a journal entry interrupted. The reason is set only when the entry has
+* none, so a later `undefined` never erases an earlier reason. The status is
+* never changed: the entry keeps the status it was journaled with.
+*/
+function markInterrupted(entry, reason) {
+	entry.response.interrupted = true;
+	if (entry.response.interruptReason === void 0 && reason !== void 0) entry.response.interruptReason = reason;
+}
+
+//#endregion
+export { AIMOCK_DISCONNECTED, CLIENT_ABORTED, closedByClient, httpLifecycle, markInterrupted, markWsTurnStopped, noteDeliveryStart, requestSocket, statusLineSent, teardownCause, teardownReason, watchWsClose, wsLifecycle };
+//# sourceMappingURL=lifecycle.js.map

package/dist/response/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","names":[],"sources":["../../src/response/lifecycle.ts"],"sourcesContent":["import type * as http from \"node:http\";\nimport type { Fixture, JournalEntry } from \"../types.js\";\nimport type { WebSocketConnection } from \"../ws-framing.js\";\nimport { createInterruptionSignal, type InterruptionControl } from \"../interruption.js\";\nimport { responseGoneReason } from \"../chaos.js\";\n\n/** The journal `interruptReason` for a client that left before the reply finished. */\nexport const CLIENT_ABORTED = \"client aborted\";\n\n/**\n * The journal `interruptReason` for a response aimock tore down itself: the\n * chaos `disconnect` action or a server-side `destroy`. It is the name the\n * chaos journal entry records (`chaosAction: \"disconnect\"`), so a teardown\n * aimock caused is never blamed on the client.\n */\nexport const AIMOCK_DISCONNECTED = \"disconnect\";\n\n/**\n * Which side stopped a delivery first: the client, the fixture's own\n * interruption, or aimock tearing the response down (`\"server\"`).\n */\nexport type InterruptCause = \"client\" | \"fixture\" | \"server\";\n\n/**\n * One delivery's stop signal. It merges the fixture interruption\n * (`truncateAfterChunks` / `disconnectAfterMs`) with the client going away\n * and with aimock tearing the response down (`\"server\"`).\n * The first cause wins: a later cause never reclassifies it.\n */\nexport interface DeliveryLifecycle {\n  /** Aborts on the first cause: fixture, client, or server. */\n  readonly signal: AbortSignal;\n  /** The cause that aborted `signal`, or `undefined` while it has not aborted. */\n  cause(): InterruptCause | undefined;\n  /**\n   * The fixture's reason, {@link CLIENT_ABORTED}, {@link AIMOCK_DISCONNECTED},\n   * or `undefined` while running.\n   */\n  reason(): string | undefined;\n  /** Forwards a sent chunk to the fixture interruption (counts toward `truncateAfterChunks`). */\n  tick(): void;\n  /** Removes the close and fixture-abort listeners and clears the fixture's `disconnectAfterMs` timer. */\n  dispose(): void;\n}\n\n/** The part of an EventEmitter a close source may expose. Test doubles may carry less. */\ninterface CloseSource {\n  once?: (event: \"close\", listener: () => void) => unknown;\n  off?: (event: \"close\", listener: () => void) => unknown;\n  removeListener?: (event: \"close\", listener: () => void) => unknown;\n}\n\n/**\n * Subscribe to `close`, guarded the same way as `awaitChaosLatency`: a partial\n * test double without `once` is not subscribed, and only a listener that was\n * added is ever removed, through a remover that exists.\n */\nfunction subscribeClose(source: CloseSource, onClose: () => void): (() => void) | undefined {\n  if (typeof source.once !== \"function\") return undefined;\n  source.once(\"close\", onClose);\n  if (typeof source.off === \"function\") return () => source.off?.(\"close\", onClose);\n  if (typeof source.removeListener === \"function\")\n    return () => source.removeListener?.(\"close\", onClose);\n  return undefined;\n}\n\nfunction createLifecycle(\n  interruption: InterruptionControl | null,\n  goneAtStart: InterruptCause | undefined,\n  subscribe: (onGone: (cause: InterruptCause) => void) => (() => void) | undefined,\n): DeliveryLifecycle {\n  const controller = new AbortController();\n  let firstCause: InterruptCause | undefined;\n  const abortWith = (cause: InterruptCause): void => {\n    if (controller.signal.aborted) return;\n    firstCause = cause;\n    controller.abort();\n  };\n  const onFixtureAbort = (): void => abortWith(\"fixture\");\n  interruption?.signal.addEventListener(\"abort\", onFixtureAbort, { once: true });\n  let unsubscribe: (() => void) | undefined;\n  if (goneAtStart !== undefined) abortWith(goneAtStart);\n  else unsubscribe = subscribe(abortWith);\n  return {\n    signal: controller.signal,\n    cause: () => firstCause,\n    reason: () => {\n      if (firstCause === \"fixture\") return interruption?.reason();\n      if (firstCause === \"client\") return CLIENT_ABORTED;\n      if (firstCause === \"server\") return AIMOCK_DISCONNECTED;\n      return undefined;\n    },\n    tick: () => {\n      interruption?.tick();\n    },\n    dispose: () => {\n      unsubscribe?.();\n      unsubscribe = undefined;\n      interruption?.signal.removeEventListener(\"abort\", onFixtureAbort);\n      interruption?.cleanup();\n    },\n  };\n}\n\n/** The request socket fields the teardown rule and the status-line rule read. */\nexport interface PeerSocket {\n  readonly errored?: Error | null;\n  readonly writableEnded?: boolean;\n  readonly bytesWritten?: number;\n}\n\n/** Where a response's request socket can be read from. Test doubles may carry neither. */\ninterface SocketOwner {\n  readonly req?: { readonly socket?: PeerSocket | null };\n  readonly socket?: PeerSocket | null;\n}\n\n/** The request socket of `res`, or `undefined` when it carries none. */\nexport function requestSocket(res: http.ServerResponse): PeerSocket | undefined {\n  const owner: SocketOwner = res;\n  return owner.req?.socket ?? owner.socket ?? undefined;\n}\n\n/**\n * THE client hang-up rule, shared by the delivery lifecycle and the proxy\n * relay: the client's socket closed or reset.\n *\n * - A reset, or a write into a socket the peer closed, leaves `errored` set\n *   (ECONNRESET / EPIPE).\n * - aimock's server keeps Node's default `httpAllowHalfOpen: false`, so a\n *   client FIN makes Node end our write side: the socket is `writableEnded`\n *   while the response is not. That is the evidence the client closed.\n *\n * A FIN alone (`readableEnded` with neither of those) is not a hang-up: it is\n * what the socket shows when aimock tore the response down before Node\n * answered the FIN. A real client FIN that Node has not answered yet looks the\n * same, so this rule also classifies it as not a hang-up. aimock's own\n * `destroy()` leaves neither signal.\n */\nexport function closedByClient(socket: PeerSocket): boolean {\n  return (socket.errored ?? null) !== null || socket.writableEnded === true;\n}\n\n/**\n * Who tore down a response that is gone without having ended. After the fact\n * `res.destroyed` reads the same either way, so this reads the evidence:\n *\n * - a chaos `disconnect` marked the response before destroying it: aimock;\n * - the request socket meets {@link closedByClient}: the client;\n * - neither: aimock destroyed it server-side.\n *\n * `socket` defaults to the response's request socket. With no socket to read\n * (a partial test double) the client attribution is kept.\n */\nexport function teardownCause(\n  res: http.ServerResponse,\n  socket: PeerSocket | null | undefined = requestSocket(res),\n): \"client\" | \"server\" {\n  if (responseGoneReason(res) === \"chaos-disconnected\") return \"server\";\n  if (!socket) return \"client\";\n  return closedByClient(socket) ? \"client\" : \"server\";\n}\n\n/**\n * The request socket's `bytesWritten` when each delivery started, so the\n * status-line rule counts only this response's bytes on a keep-alive socket.\n */\nconst deliveryStartBytes = new WeakMap<http.ServerResponse, number>();\n\n/**\n * Record where this response's bytes start on its socket. A response whose\n * head was already committed when the delivery started is not recorded:\n * {@link statusLineSent} keeps the `headersSent` rule for it.\n */\nexport function noteDeliveryStart(res: http.ServerResponse): void {\n  if (deliveryStartBytes.has(res) || res.headersSent) return;\n  const bytes = requestSocket(res)?.bytesWritten;\n  if (typeof bytes === \"number\") deliveryStartBytes.set(res, bytes);\n}\n\n/**\n * Whether this response's status line reached the client's socket: a byte of\n * it was handed to the socket after {@link noteDeliveryStart}. `headersSent`\n * is not that test: `writeHead` sets it before any byte is written. With no\n * recorded start, or no socket to read, `headersSent` is the fallback.\n */\nexport function statusLineSent(res: http.ServerResponse): boolean {\n  const start = deliveryStartBytes.get(res);\n  const bytes = requestSocket(res)?.bytesWritten;\n  if (start === undefined || typeof bytes !== \"number\") return res.headersSent;\n  return bytes > start;\n}\n\n/** The journal `interruptReason` for {@link teardownCause}. */\nexport function teardownReason(res: http.ServerResponse): string {\n  return teardownCause(res) === \"client\" ? CLIENT_ABORTED : AIMOCK_DISCONNECTED;\n}\n\n/**\n * HTTP delivery lifecycle. A `close` before `res.writableFinished` aborts it,\n * and {@link teardownCause} decides whose teardown it was: the client\n * (`\"client\"`) or aimock itself (`\"server\"`). A response that is already gone\n * at construction aborts at once with the same attribution. A chaos\n * `disconnect` destroys without ending, so no `writableEnded` check stops a\n * writer for it. Only an already-ended response does not abort: the frame\n * loop exits on its `writableEnded` check. The fixture interruption is\n * created only when `streaming` is true (it is streaming-only).\n */\nexport function httpLifecycle(\n  res: http.ServerResponse,\n  fixture: Fixture | null,\n  opts: { streaming: boolean },\n): DeliveryLifecycle {\n  const interruption = opts.streaming && fixture ? createInterruptionSignal(fixture) : null;\n  const gone = responseGoneReason(res);\n  const goneAtStart = gone === null || gone === \"already-ended\" ? undefined : teardownCause(res);\n  return createLifecycle(interruption, goneAtStart, (onGone) =>\n    subscribeClose(res, () => {\n      if (!res.writableFinished) onGone(teardownCause(res));\n    }),\n  );\n}\n\n/**\n * Per watched connection: whether its `close` event has fired. Only sockets\n * watched while open are recorded, so an entry is evidence, not a guess.\n */\nconst wsCloseEmitted = new WeakMap<WebSocketConnection, boolean>();\n\n/**\n * Start recording when `ws` emits `close`, so {@link wsClosedCause} can tell\n * aimock's own close from the client's. Each WS transport calls it when the\n * connection opens. Idempotent, and a no-op once closed.\n */\nexport function watchWsClose(ws: WebSocketConnection): void {\n  if (ws.isClosed || wsCloseEmitted.has(ws)) return;\n  const source: CloseSource = ws;\n  if (typeof source.once !== \"function\") return;\n  wsCloseEmitted.set(ws, false);\n  source.once(\"close\", () => wsCloseEmitted.set(ws, true));\n}\n\n/**\n * Who closed a socket that reads `isClosed`, or `undefined` while it is open.\n *\n * `WebSocketConnection` marks itself closed and emits `close` in the same step\n * for a client close frame, a lost connection, and `destroy()`. Only aimock's\n * own `close()` (a write or buffer limit, a bad frame, a strict miss, shutdown)\n * marks it closed at once and emits `close` about 100ms later. So a socket\n * watched while open ({@link watchWsClose}) that is closed with no `close` yet\n * was closed by aimock (`\"server\"`). Any other closed socket reads as the\n * client leaving, as before.\n */\nexport function wsClosedCause(ws: WebSocketConnection): \"client\" | \"server\" | undefined {\n  if (!ws.isClosed) return undefined;\n  return wsCloseEmitted.get(ws) === false ? \"server\" : \"client\";\n}\n\n/**\n * WebSocket turn lifecycle. A WS turn is always a stream, so it always owns\n * the fixture interruption. A `close` means the client left. A socket already\n * closed at construction aborts at once with {@link wsClosedCause}. Callers\n * never create their own interruption object.\n */\nexport function wsLifecycle(ws: WebSocketConnection, fixture: Fixture | null): DeliveryLifecycle {\n  const interruption = fixture ? createInterruptionSignal(fixture) : null;\n  return createLifecycle(interruption, wsClosedCause(ws), (onGone) =>\n    subscribeClose(ws, () => onGone(\"client\")),\n  );\n}\n\n/**\n * Journal a WS turn that stopped because its lifecycle aborted or its socket\n * closed. This is the closed-socket rule every WS transport uses: the\n * lifecycle's reason when it has one, else the closed socket's cause\n * ({@link wsClosedCause}): {@link AIMOCK_DISCONNECTED} for aimock's own close,\n * {@link CLIENT_ABORTED} for the client. A turn with no lifecycle (it never\n * waits) passes none.\n */\nexport function markWsTurnStopped(\n  entry: JournalEntry,\n  ws: WebSocketConnection,\n  lifecycle?: DeliveryLifecycle,\n): void {\n  const cause = wsClosedCause(ws);\n  const socketReason =\n    cause === \"server\" ? AIMOCK_DISCONNECTED : cause === \"client\" ? CLIENT_ABORTED : undefined;\n  markInterrupted(entry, lifecycle?.reason() ?? socketReason);\n}\n\n/**\n * Mark a journal entry interrupted. The reason is set only when the entry has\n * none, so a later `undefined` never erases an earlier reason. The status is\n * never changed: the entry keeps the status it was journaled with.\n */\nexport function markInterrupted(entry: JournalEntry, reason: string | undefined): void {\n  entry.response.interrupted = true;\n  if (entry.response.interruptReason === undefined && reason !== undefined) {\n    entry.response.interruptReason = reason;\n  }\n}\n"],"mappings":"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"}

package/dist/response/policy.cjs

@@ -0,0 +1,126 @@
+
+//#region src/response/policy.ts
+/** Entry points choose whether a failed parse warns or becomes a CLI usage error. */
+function parsePolicyEntry(key, value) {
+	if (key === "requiredHeaders") {
+		const normalized = typeof value === "string" ? value.toLowerCase() : void 0;
+		if (normalized === "off" || normalized === "enforce") return {
+			ok: true,
+			key,
+			value: normalized
+		};
+		return {
+			ok: false,
+			reason: "expected \"off\" or \"enforce\"."
+		};
+	}
+	if (key === "authErrors" || key === "modelCatalog") {
+		const normalized = typeof value === "string" ? value.toLowerCase() : void 0;
+		if (normalized === "legacy" || normalized === "native") return {
+			ok: true,
+			key,
+			value: normalized
+		};
+		return {
+			ok: false,
+			reason: "expected \"legacy\" or \"native\"."
+		};
+	}
+	return {
+		ok: false,
+		reason: "unknown policy key."
+	};
+}
+/** Store one parsed entry without widening either key's value type. */
+function assignPolicyEntry(target, entry) {
+	if (entry.key === "requiredHeaders") target.requiredHeaders = entry.value;
+	else target[entry.key] = entry.value;
+}
+/** Parse each programmatic entry independently without changing the caller's object. */
+function parsePolicy(value, warn) {
+	const result = {};
+	if (value === void 0) return result;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		warn("Ignoring policy: expected an object.");
+		return result;
+	}
+	for (const [key, entry] of Object.entries(value)) {
+		const parsed = parsePolicyEntry(key, entry);
+		if (parsed.ok) assignPolicyEntry(result, parsed);
+		else warn(`Ignoring policy.${key}: ${parsed.reason}`);
+	}
+	return result;
+}
+/** A bad header entry does not erase a prior valid entry or other policy keys. */
+function parsePolicyHeader(rawHeaders, warn) {
+	const result = {};
+	const header = rawHeaders?.["x-aimock-policy"];
+	if (header === void 0) return result;
+	const text = Array.isArray(header) ? header.join(",") : header;
+	for (const rawEntry of text.split(",")) {
+		const entry = rawEntry.trim();
+		const separator = entry.indexOf("=");
+		if (separator < 0) {
+			warn(`Ignoring policy entry ${JSON.stringify(entry)}: expected key=value.`);
+			continue;
+		}
+		const key = entry.slice(0, separator);
+		const parsed = parsePolicyEntry(key, entry.slice(separator + 1));
+		if (parsed.ok) assignPolicyEntry(result, parsed);
+		else warn(`Ignoring policy.${key}: ${parsed.reason}`);
+	}
+	return result;
+}
+/** Resolve from the direct-handler input, preserving the independent legacy strict bit. */
+function resolvePolicy(defaults, rawHeaders, warn = (message) => defaults.logger.warn(message)) {
+	const strict = resolveStrictMode(defaults.strict, rawHeaders);
+	const server = parsePolicy(defaults.policy, warn);
+	const request = parsePolicyHeader(rawHeaders, warn);
+	return Object.freeze({
+		strict,
+		requiredHeaders: request.requiredHeaders ?? server.requiredHeaders ?? "off",
+		authErrors: request.authErrors ?? server.authErrors ?? "legacy",
+		modelCatalog: request.modelCatalog ?? server.modelCatalog ?? "legacy"
+	});
+}
+/** Preserve the legacy request strict header grammar and server fallback. */
+function resolveStrictMode(serverDefault, rawHeaders) {
+	if (rawHeaders) {
+		const header = rawHeaders["x-aimock-strict"];
+		const rawVal = typeof header === "string" ? header : Array.isArray(header) ? header[0] : void 0;
+		if (typeof rawVal === "string") {
+			const val = rawVal.trim().toLowerCase();
+			if (val === "true" || val === "1") return true;
+			if (val === "false" || val === "0") return false;
+		}
+	}
+	return serverDefault ?? false;
+}
+/** Journal fields retain their existing omitted-versus-overridden shape. */
+function strictOverrideField(serverDefault, rawHeaders) {
+	const effective = resolveStrictMode(serverDefault, rawHeaders);
+	if (effective !== (serverDefault ?? false)) return { strictOverride: effective };
+	return {};
+}
+/** Named legacy decisions share one header read at the caller's existing site. */
+function resolveRequestDecisions(serverDefault, rawHeaders) {
+	const strict = resolveStrictMode(serverDefault, rawHeaders);
+	return Object.freeze({
+		strict,
+		fixtureMiss: strict,
+		upstream: !strict,
+		reasoningSuppression: strict,
+		thinkingRejection: strict,
+		mcpRecordingStrict: strict,
+		strictOverride: strict !== (serverDefault ?? false) ? strict : void 0
+	});
+}
+
+//#endregion
+exports.assignPolicyEntry = assignPolicyEntry;
+exports.parsePolicy = parsePolicy;
+exports.parsePolicyEntry = parsePolicyEntry;
+exports.resolvePolicy = resolvePolicy;
+exports.resolveRequestDecisions = resolveRequestDecisions;
+exports.strictOverrideField = strictOverrideField;
+//# sourceMappingURL=policy.cjs.map

package/dist/response/policy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.cjs","names":[],"sources":["../../src/response/policy.ts"],"sourcesContent":["import type { IncomingHttpHeaders } from \"node:http\";\nimport type { AimockPolicy, HandlerDefaults } from \"../types.js\";\n\n/** Entry points choose whether a failed parse warns or becomes a CLI usage error. */\nexport function parsePolicyEntry(\n  key: string,\n  value: unknown,\n):\n  | { ok: true; key: \"requiredHeaders\"; value: \"off\" | \"enforce\" }\n  | { ok: true; key: \"authErrors\" | \"modelCatalog\"; value: \"legacy\" | \"native\" }\n  | { ok: false; reason: string } {\n  if (key === \"requiredHeaders\") {\n    const normalized = typeof value === \"string\" ? value.toLowerCase() : undefined;\n    if (normalized === \"off\" || normalized === \"enforce\") {\n      return { ok: true, key, value: normalized };\n    }\n    return { ok: false, reason: 'expected \"off\" or \"enforce\".' };\n  }\n  if (key === \"authErrors\" || key === \"modelCatalog\") {\n    const normalized = typeof value === \"string\" ? value.toLowerCase() : undefined;\n    if (normalized === \"legacy\" || normalized === \"native\") {\n      return { ok: true, key, value: normalized };\n    }\n    return { ok: false, reason: 'expected \"legacy\" or \"native\".' };\n  }\n  return { ok: false, reason: \"unknown policy key.\" };\n}\n\n/** Store one parsed entry without widening either key's value type. */\nexport function assignPolicyEntry(\n  target: AimockPolicy,\n  entry: Exclude<ReturnType<typeof parsePolicyEntry>, { ok: false }>,\n): void {\n  if (entry.key === \"requiredHeaders\") target.requiredHeaders = entry.value;\n  else target[entry.key] = entry.value;\n}\n\n/** Parse each programmatic entry independently without changing the caller's object. */\nexport function parsePolicy(value: unknown, warn: (message: string) => void): AimockPolicy {\n  const result: AimockPolicy = {};\n  if (value === undefined) return result;\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    warn(\"Ignoring policy: expected an object.\");\n    return result;\n  }\n  for (const [key, entry] of Object.entries(value)) {\n    const parsed = parsePolicyEntry(key, entry);\n    if (parsed.ok) assignPolicyEntry(result, parsed);\n    else warn(`Ignoring policy.${key}: ${parsed.reason}`);\n  }\n  return result;\n}\n\n/** A bad header entry does not erase a prior valid entry or other policy keys. */\nexport function parsePolicyHeader(\n  rawHeaders: IncomingHttpHeaders | undefined,\n  warn: (message: string) => void,\n): AimockPolicy {\n  const result: AimockPolicy = {};\n  const header = rawHeaders?.[\"x-aimock-policy\"];\n  if (header === undefined) return result;\n  const text = Array.isArray(header) ? header.join(\",\") : header;\n  for (const rawEntry of text.split(\",\")) {\n    const entry = rawEntry.trim();\n    const separator = entry.indexOf(\"=\");\n    if (separator < 0) {\n      warn(`Ignoring policy entry ${JSON.stringify(entry)}: expected key=value.`);\n      continue;\n    }\n    const key = entry.slice(0, separator);\n    const parsed = parsePolicyEntry(key, entry.slice(separator + 1));\n    if (parsed.ok) assignPolicyEntry(result, parsed);\n    else warn(`Ignoring policy.${key}: ${parsed.reason}`);\n  }\n  return result;\n}\n\n/** Resolve from the direct-handler input, preserving the independent legacy strict bit. */\nexport function resolvePolicy(\n  defaults: HandlerDefaults,\n  rawHeaders?: IncomingHttpHeaders,\n  warn: (message: string) => void = (message) => defaults.logger.warn(message),\n) {\n  const strict = resolveStrictMode(defaults.strict, rawHeaders);\n  const server = parsePolicy(defaults.policy, warn);\n  const request = parsePolicyHeader(rawHeaders, warn);\n  return Object.freeze({\n    strict,\n    requiredHeaders: request.requiredHeaders ?? server.requiredHeaders ?? \"off\",\n    authErrors: request.authErrors ?? server.authErrors ?? \"legacy\",\n    modelCatalog: request.modelCatalog ?? server.modelCatalog ?? \"legacy\",\n  });\n}\n\n/** Preserve the legacy request strict header grammar and server fallback. */\nexport function resolveStrictMode(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n): boolean {\n  if (rawHeaders) {\n    const header = rawHeaders[\"x-aimock-strict\"];\n    const rawVal =\n      typeof header === \"string\" ? header : Array.isArray(header) ? header[0] : undefined;\n    if (typeof rawVal === \"string\") {\n      const val = rawVal.trim().toLowerCase();\n      if (val === \"true\" || val === \"1\") return true;\n      if (val === \"false\" || val === \"0\") return false;\n    }\n  }\n  return serverDefault ?? false;\n}\n\n/** Journal fields retain their existing omitted-versus-overridden shape. */\nexport function strictOverrideField(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n): { strictOverride?: boolean } {\n  const effective = resolveStrictMode(serverDefault, rawHeaders);\n  if (effective !== (serverDefault ?? false)) {\n    return { strictOverride: effective };\n  }\n  return {};\n}\n\n/** Named legacy decisions share one header read at the caller's existing site. */\nexport function resolveRequestDecisions(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n) {\n  const strict = resolveStrictMode(serverDefault, rawHeaders);\n  return Object.freeze({\n    strict,\n    fixtureMiss: strict,\n    upstream: !strict,\n    reasoningSuppression: strict,\n    thinkingRejection: strict,\n    mcpRecordingStrict: strict,\n    strictOverride: strict !== (serverDefault ?? false) ? strict : undefined,\n  });\n}\n"],"mappings":"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"}

package/dist/response/policy.js

@@ -0,0 +1,120 @@
+//#region src/response/policy.ts
+/** Entry points choose whether a failed parse warns or becomes a CLI usage error. */
+function parsePolicyEntry(key, value) {
+	if (key === "requiredHeaders") {
+		const normalized = typeof value === "string" ? value.toLowerCase() : void 0;
+		if (normalized === "off" || normalized === "enforce") return {
+			ok: true,
+			key,
+			value: normalized
+		};
+		return {
+			ok: false,
+			reason: "expected \"off\" or \"enforce\"."
+		};
+	}
+	if (key === "authErrors" || key === "modelCatalog") {
+		const normalized = typeof value === "string" ? value.toLowerCase() : void 0;
+		if (normalized === "legacy" || normalized === "native") return {
+			ok: true,
+			key,
+			value: normalized
+		};
+		return {
+			ok: false,
+			reason: "expected \"legacy\" or \"native\"."
+		};
+	}
+	return {
+		ok: false,
+		reason: "unknown policy key."
+	};
+}
+/** Store one parsed entry without widening either key's value type. */
+function assignPolicyEntry(target, entry) {
+	if (entry.key === "requiredHeaders") target.requiredHeaders = entry.value;
+	else target[entry.key] = entry.value;
+}
+/** Parse each programmatic entry independently without changing the caller's object. */
+function parsePolicy(value, warn) {
+	const result = {};
+	if (value === void 0) return result;
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		warn("Ignoring policy: expected an object.");
+		return result;
+	}
+	for (const [key, entry] of Object.entries(value)) {
+		const parsed = parsePolicyEntry(key, entry);
+		if (parsed.ok) assignPolicyEntry(result, parsed);
+		else warn(`Ignoring policy.${key}: ${parsed.reason}`);
+	}
+	return result;
+}
+/** A bad header entry does not erase a prior valid entry or other policy keys. */
+function parsePolicyHeader(rawHeaders, warn) {
+	const result = {};
+	const header = rawHeaders?.["x-aimock-policy"];
+	if (header === void 0) return result;
+	const text = Array.isArray(header) ? header.join(",") : header;
+	for (const rawEntry of text.split(",")) {
+		const entry = rawEntry.trim();
+		const separator = entry.indexOf("=");
+		if (separator < 0) {
+			warn(`Ignoring policy entry ${JSON.stringify(entry)}: expected key=value.`);
+			continue;
+		}
+		const key = entry.slice(0, separator);
+		const parsed = parsePolicyEntry(key, entry.slice(separator + 1));
+		if (parsed.ok) assignPolicyEntry(result, parsed);
+		else warn(`Ignoring policy.${key}: ${parsed.reason}`);
+	}
+	return result;
+}
+/** Resolve from the direct-handler input, preserving the independent legacy strict bit. */
+function resolvePolicy(defaults, rawHeaders, warn = (message) => defaults.logger.warn(message)) {
+	const strict = resolveStrictMode(defaults.strict, rawHeaders);
+	const server = parsePolicy(defaults.policy, warn);
+	const request = parsePolicyHeader(rawHeaders, warn);
+	return Object.freeze({
+		strict,
+		requiredHeaders: request.requiredHeaders ?? server.requiredHeaders ?? "off",
+		authErrors: request.authErrors ?? server.authErrors ?? "legacy",
+		modelCatalog: request.modelCatalog ?? server.modelCatalog ?? "legacy"
+	});
+}
+/** Preserve the legacy request strict header grammar and server fallback. */
+function resolveStrictMode(serverDefault, rawHeaders) {
+	if (rawHeaders) {
+		const header = rawHeaders["x-aimock-strict"];
+		const rawVal = typeof header === "string" ? header : Array.isArray(header) ? header[0] : void 0;
+		if (typeof rawVal === "string") {
+			const val = rawVal.trim().toLowerCase();
+			if (val === "true" || val === "1") return true;
+			if (val === "false" || val === "0") return false;
+		}
+	}
+	return serverDefault ?? false;
+}
+/** Journal fields retain their existing omitted-versus-overridden shape. */
+function strictOverrideField(serverDefault, rawHeaders) {
+	const effective = resolveStrictMode(serverDefault, rawHeaders);
+	if (effective !== (serverDefault ?? false)) return { strictOverride: effective };
+	return {};
+}
+/** Named legacy decisions share one header read at the caller's existing site. */
+function resolveRequestDecisions(serverDefault, rawHeaders) {
+	const strict = resolveStrictMode(serverDefault, rawHeaders);
+	return Object.freeze({
+		strict,
+		fixtureMiss: strict,
+		upstream: !strict,
+		reasoningSuppression: strict,
+		thinkingRejection: strict,
+		mcpRecordingStrict: strict,
+		strictOverride: strict !== (serverDefault ?? false) ? strict : void 0
+	});
+}
+
+//#endregion
+export { assignPolicyEntry, parsePolicy, parsePolicyEntry, resolvePolicy, resolveRequestDecisions, strictOverrideField };
+//# sourceMappingURL=policy.js.map

package/dist/response/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","names":[],"sources":["../../src/response/policy.ts"],"sourcesContent":["import type { IncomingHttpHeaders } from \"node:http\";\nimport type { AimockPolicy, HandlerDefaults } from \"../types.js\";\n\n/** Entry points choose whether a failed parse warns or becomes a CLI usage error. */\nexport function parsePolicyEntry(\n  key: string,\n  value: unknown,\n):\n  | { ok: true; key: \"requiredHeaders\"; value: \"off\" | \"enforce\" }\n  | { ok: true; key: \"authErrors\" | \"modelCatalog\"; value: \"legacy\" | \"native\" }\n  | { ok: false; reason: string } {\n  if (key === \"requiredHeaders\") {\n    const normalized = typeof value === \"string\" ? value.toLowerCase() : undefined;\n    if (normalized === \"off\" || normalized === \"enforce\") {\n      return { ok: true, key, value: normalized };\n    }\n    return { ok: false, reason: 'expected \"off\" or \"enforce\".' };\n  }\n  if (key === \"authErrors\" || key === \"modelCatalog\") {\n    const normalized = typeof value === \"string\" ? value.toLowerCase() : undefined;\n    if (normalized === \"legacy\" || normalized === \"native\") {\n      return { ok: true, key, value: normalized };\n    }\n    return { ok: false, reason: 'expected \"legacy\" or \"native\".' };\n  }\n  return { ok: false, reason: \"unknown policy key.\" };\n}\n\n/** Store one parsed entry without widening either key's value type. */\nexport function assignPolicyEntry(\n  target: AimockPolicy,\n  entry: Exclude<ReturnType<typeof parsePolicyEntry>, { ok: false }>,\n): void {\n  if (entry.key === \"requiredHeaders\") target.requiredHeaders = entry.value;\n  else target[entry.key] = entry.value;\n}\n\n/** Parse each programmatic entry independently without changing the caller's object. */\nexport function parsePolicy(value: unknown, warn: (message: string) => void): AimockPolicy {\n  const result: AimockPolicy = {};\n  if (value === undefined) return result;\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    warn(\"Ignoring policy: expected an object.\");\n    return result;\n  }\n  for (const [key, entry] of Object.entries(value)) {\n    const parsed = parsePolicyEntry(key, entry);\n    if (parsed.ok) assignPolicyEntry(result, parsed);\n    else warn(`Ignoring policy.${key}: ${parsed.reason}`);\n  }\n  return result;\n}\n\n/** A bad header entry does not erase a prior valid entry or other policy keys. */\nexport function parsePolicyHeader(\n  rawHeaders: IncomingHttpHeaders | undefined,\n  warn: (message: string) => void,\n): AimockPolicy {\n  const result: AimockPolicy = {};\n  const header = rawHeaders?.[\"x-aimock-policy\"];\n  if (header === undefined) return result;\n  const text = Array.isArray(header) ? header.join(\",\") : header;\n  for (const rawEntry of text.split(\",\")) {\n    const entry = rawEntry.trim();\n    const separator = entry.indexOf(\"=\");\n    if (separator < 0) {\n      warn(`Ignoring policy entry ${JSON.stringify(entry)}: expected key=value.`);\n      continue;\n    }\n    const key = entry.slice(0, separator);\n    const parsed = parsePolicyEntry(key, entry.slice(separator + 1));\n    if (parsed.ok) assignPolicyEntry(result, parsed);\n    else warn(`Ignoring policy.${key}: ${parsed.reason}`);\n  }\n  return result;\n}\n\n/** Resolve from the direct-handler input, preserving the independent legacy strict bit. */\nexport function resolvePolicy(\n  defaults: HandlerDefaults,\n  rawHeaders?: IncomingHttpHeaders,\n  warn: (message: string) => void = (message) => defaults.logger.warn(message),\n) {\n  const strict = resolveStrictMode(defaults.strict, rawHeaders);\n  const server = parsePolicy(defaults.policy, warn);\n  const request = parsePolicyHeader(rawHeaders, warn);\n  return Object.freeze({\n    strict,\n    requiredHeaders: request.requiredHeaders ?? server.requiredHeaders ?? \"off\",\n    authErrors: request.authErrors ?? server.authErrors ?? \"legacy\",\n    modelCatalog: request.modelCatalog ?? server.modelCatalog ?? \"legacy\",\n  });\n}\n\n/** Preserve the legacy request strict header grammar and server fallback. */\nexport function resolveStrictMode(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n): boolean {\n  if (rawHeaders) {\n    const header = rawHeaders[\"x-aimock-strict\"];\n    const rawVal =\n      typeof header === \"string\" ? header : Array.isArray(header) ? header[0] : undefined;\n    if (typeof rawVal === \"string\") {\n      const val = rawVal.trim().toLowerCase();\n      if (val === \"true\" || val === \"1\") return true;\n      if (val === \"false\" || val === \"0\") return false;\n    }\n  }\n  return serverDefault ?? false;\n}\n\n/** Journal fields retain their existing omitted-versus-overridden shape. */\nexport function strictOverrideField(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n): { strictOverride?: boolean } {\n  const effective = resolveStrictMode(serverDefault, rawHeaders);\n  if (effective !== (serverDefault ?? false)) {\n    return { strictOverride: effective };\n  }\n  return {};\n}\n\n/** Named legacy decisions share one header read at the caller's existing site. */\nexport function resolveRequestDecisions(\n  serverDefault: boolean | undefined,\n  rawHeaders?: IncomingHttpHeaders,\n) {\n  const strict = resolveStrictMode(serverDefault, rawHeaders);\n  return Object.freeze({\n    strict,\n    fixtureMiss: strict,\n    upstream: !strict,\n    reasoningSuppression: strict,\n    thinkingRejection: strict,\n    mcpRecordingStrict: strict,\n    strictOverride: strict !== (serverDefault ?? false) ? strict : undefined,\n  });\n}\n"],"mappings":"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"}

package/dist/response/profiles.cjs

@@ -0,0 +1,69 @@
+
+//#region src/response/profiles.ts
+/** Inbound HTTP auth uses only provider-owned paths; shared routes stay legacy. */
+function authErrorDialectForPath(pathname) {
+	if (pathname === "/v1/messages" || pathname === "/v1/messages/count_tokens") return "messages";
+	if (pathname.startsWith("/v1beta/") || /^\/v1\/projects\/[^/]+\/locations\/[^/]+\/publishers\/google\//.test(pathname)) return "gemini";
+	return "openai";
+}
+/**
+* Shared catalog response dialect. The list route uses it only under
+* `policy.modelCatalog: "native"`. Auth retains its pathname-selected dialect.
+*/
+function isAnthropicModelRequest(headers) {
+	return headers["anthropic-version"] !== void 0 || headers["x-api-key"] !== void 0 && headers.authorization === void 0;
+}
+/** Static wire facts only. Status selection and transport behavior belong to callers. */
+const errorProfiles = {
+	openai: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	messages: {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		requiredHeaders: ["anthropic-version"]
+	},
+	bedrock: {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		toolArgumentType: "InternalServerException"
+	},
+	"bedrock-converse": {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		toolArgumentType: "InternalServerException"
+	},
+	ollama: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	"ollama-embed": {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	cohere: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	interactions: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	gemini: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	}
+};
+/** Bedrock's body-level version and other wire families have no header requirement. */
+function missingRequiredHeader(wire, headers) {
+	if (wire !== "messages") return;
+	return errorProfiles.messages.requiredHeaders.find((name) => headers[name] === void 0);
+}
+
+//#endregion
+exports.authErrorDialectForPath = authErrorDialectForPath;
+exports.errorProfiles = errorProfiles;
+exports.isAnthropicModelRequest = isAnthropicModelRequest;
+exports.missingRequiredHeader = missingRequiredHeader;
+//# sourceMappingURL=profiles.cjs.map

package/dist/response/profiles.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.cjs","names":[],"sources":["../../src/response/profiles.ts"],"sourcesContent":["import type { IncomingHttpHeaders } from \"node:http\";\n\n/** Inbound HTTP auth uses only provider-owned paths; shared routes stay legacy. */\nexport function authErrorDialectForPath(pathname: string): \"messages\" | \"gemini\" | \"openai\" {\n  if (pathname === \"/v1/messages\" || pathname === \"/v1/messages/count_tokens\") return \"messages\";\n  if (\n    pathname.startsWith(\"/v1beta/\") ||\n    /^\\/v1\\/projects\\/[^/]+\\/locations\\/[^/]+\\/publishers\\/google\\//.test(pathname)\n  )\n    return \"gemini\";\n  return \"openai\";\n}\n\n/**\n * Shared catalog response dialect. The list route uses it only under\n * `policy.modelCatalog: \"native\"`. Auth retains its pathname-selected dialect.\n */\nexport function isAnthropicModelRequest(headers: IncomingHttpHeaders): boolean {\n  return (\n    headers[\"anthropic-version\"] !== undefined ||\n    (headers[\"x-api-key\"] !== undefined && headers.authorization === undefined)\n  );\n}\n\n/** Static wire facts only. Status selection and transport behavior belong to callers. */\nexport const errorProfiles = {\n  openai: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  messages: {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    requiredHeaders: [\"anthropic-version\"],\n  },\n  bedrock: {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    toolArgumentType: \"InternalServerException\",\n  },\n  \"bedrock-converse\": {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    toolArgumentType: \"InternalServerException\",\n  },\n  ollama: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  \"ollama-embed\": { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  cohere: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  interactions: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  gemini: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n} as const;\n\nexport type ErrorWire = keyof typeof errorProfiles;\n\n/** Bedrock's body-level version and other wire families have no header requirement. */\nexport function missingRequiredHeader(\n  wire: ErrorWire,\n  headers: IncomingHttpHeaders,\n): string | undefined {\n  if (wire !== \"messages\") return;\n  return errorProfiles.messages.requiredHeaders.find((name) => headers[name] === undefined);\n}\n"],"mappings":";;;AAGA,SAAgB,wBAAwB,UAAoD;AAC1F,KAAI,aAAa,kBAAkB,aAAa,4BAA6B,QAAO;AACpF,KACE,SAAS,WAAW,WAAW,IAC/B,iEAAiE,KAAK,SAAS,CAE/E,QAAO;AACT,QAAO;;;;;;AAOT,SAAgB,wBAAwB,SAAuC;AAC7E,QACE,QAAQ,yBAAyB,UAChC,QAAQ,iBAAiB,UAAa,QAAQ,kBAAkB;;;AAKrE,MAAa,gBAAgB;CAC3B,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,UAAU;EACR,aAAa;EACb,gBAAgB;EAChB,iBAAiB,CAAC,oBAAoB;EACvC;CACD,SAAS;EACP,aAAa;EACb,gBAAgB;EAChB,kBAAkB;EACnB;CACD,oBAAoB;EAClB,aAAa;EACb,gBAAgB;EAChB,kBAAkB;EACnB;CACD,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,gBAAgB;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACxF,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,cAAc;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACtF,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACjF;;AAKD,SAAgB,sBACd,MACA,SACoB;AACpB,KAAI,SAAS,WAAY;AACzB,QAAO,cAAc,SAAS,gBAAgB,MAAM,SAAS,QAAQ,UAAU,OAAU"}