@tangle-network/agent-eval 0.149.0 → 0.150.1

package/dist/{external-optimizer-subprocess-DU1KM8yV.js → external-optimizer-subprocess-Dn90UqN2.js}

@@ -2,7 +2,7 @@ import { s as ValidationError } from "./errors-Dngq5h35.js";
 import { t as canonicalJson } from "./verdict-cache-mZf5FEiY.js";
 import { c as costForTokenPricing, i as CostLedger } from "./cost-ledger-B1qx30B4.js";
 import { a as appendLedgerLine, o as tryWithLedgerFileLock } from "./ledger-core-DTae9rv_.js";
-import { h as ModelSubstitutionError, v as assertServedModel } from "./llm-client-BMuxYoZy.js";
+import { h as ModelSubstitutionError, v as assertServedModel, y as assertServedModelPolicy } from "./llm-client-Bg32RW0j.js";
 import { createRequire } from "node:module";
 import { randomBytes } from "node:crypto";
 import { isAbsolute, join, resolve } from "node:path";
@@ -247,6 +247,469 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
+//#region src/campaign/external-optimizer-anthropic.ts
+/**
+* Translate between the Anthropic Messages API and the canonical owner-call
+* contract used by the metered optimizer model proxy.
+*
+* The `claude` CLI driven by GEPA agent engines speaks `POST /v1/messages`.
+* Each request becomes one canonical `ExternalOptimizerChatRequest`, so the
+* shared reservation, receipt, and execution-evidence pipeline applies
+* unchanged. Tool use translates in both directions: Anthropic `tools`,
+* `tool_choice`, `tool_use`, and `tool_result` map onto the canonical
+* function-tool contract, and a tool-calling response is synthesized back as
+* the Anthropic stream shape the CLI expects.
+*
+* Anything without a full-fidelity mapping onto the canonical contract is
+* refused with a loud Anthropic error envelope, with two exceptions:
+*
+* - `metadata` and `cache_control` are dropped silently: the CLI always sends
+*   both, neither has a canonical slot, and dropping them changes no content.
+* - Claude-specific control fields (`thinking`, `context_management`,
+*   `output_config`, replayed reasoning blocks, and unknown tool-entry keys)
+*   are STRIPPED AND RECORDED. They carry no token-billing semantics on the
+*   owner wire, and the real CLI sends them on every request — refusing them
+*   makes every real CLI call impossible. The dropped names are returned in
+*   `strippedFields` so accounting discloses exactly what the shim removed.
+*/
+var AnthropicRequestRefusal = class extends Error {
+	status;
+	errorType;
+	constructor(status, errorType, message) {
+		super(message);
+		this.status = status;
+		this.errorType = errorType;
+	}
+};
+const REQUEST_FIELDS = /* @__PURE__ */ new Set([
+	"model",
+	"max_tokens",
+	"messages",
+	"system",
+	"temperature",
+	"stream",
+	"metadata",
+	"tools",
+	"tool_choice"
+]);
+const STRIPPED_REQUEST_FIELDS = /* @__PURE__ */ new Set([
+	"thinking",
+	"context_management",
+	"output_config"
+]);
+const REFUSED_REQUEST_FIELDS = {
+	top_p: "top_p has no canonical execution-owner slot",
+	top_k: "top_k has no canonical execution-owner slot",
+	stop_sequences: "stop_sequences has no canonical execution-owner slot"
+};
+function translateAnthropicMessagesRequest(raw, expectedModel, maxOutputTokensPerRequest) {
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
+	} catch {
+		throw refuse("request must be valid JSON");
+	}
+	if (!isRecord(parsed)) throw refuse("request must be a JSON object");
+	const stripped = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(parsed)) {
+		if (REQUEST_FIELDS.has(key)) continue;
+		if (STRIPPED_REQUEST_FIELDS.has(key)) {
+			stripped.add(key);
+			continue;
+		}
+		const reason = REFUSED_REQUEST_FIELDS[key];
+		throw refuse(reason ?? `request field '${key}' has no metered translation and is not supported`);
+	}
+	if (parsed.model !== expectedModel) throw refuse(`request must use configured model '${expectedModel}'`);
+	const maxTokens = parsed.max_tokens;
+	if (!Number.isSafeInteger(maxTokens) || maxTokens <= 0) throw refuse("request requires a positive integer max_tokens");
+	if (maxTokens > maxOutputTokensPerRequest) throw refuse("request max_tokens exceeds maxOutputTokensPerRequest");
+	if (parsed.stream !== void 0 && typeof parsed.stream !== "boolean") throw refuse("request stream must be a boolean");
+	if (parsed.temperature !== void 0 && (typeof parsed.temperature !== "number" || !Number.isFinite(parsed.temperature))) throw refuse("request temperature must be a finite number");
+	const messages = [];
+	const systemText = translateSystem(parsed.system);
+	if (systemText !== void 0) messages.push({
+		role: "system",
+		content: systemText
+	});
+	messages.push(...translateConversation(parsed.messages, stripped));
+	const tools = translateTools(parsed.tools, stripped);
+	const toolChoice = translateToolChoice(parsed.tool_choice, stripped);
+	return {
+		request: {
+			model: expectedModel,
+			messages,
+			maxTokens,
+			...parsed.temperature !== void 0 ? { temperature: parsed.temperature } : {},
+			...tools === void 0 ? {} : { tools },
+			...toolChoice === void 0 ? {} : { toolChoice }
+		},
+		maxOutputTokens: maxTokens,
+		stream: parsed.stream === true,
+		strippedFields: [...stripped].sort()
+	};
+}
+const TOOL_ENTRY_FIELDS = /* @__PURE__ */ new Set([
+	"name",
+	"description",
+	"input_schema",
+	"type",
+	"cache_control"
+]);
+function translateTools(value, stripped) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.length === 0) throw refuse("tools must be a non-empty array of tool definitions");
+	return value.map((entry, index) => {
+		if (!isRecord(entry)) throw refuse(`tools[${index}] must be an object`);
+		if (entry.type !== void 0 && entry.type !== "custom") throw refuse(`tools[${index}] type '${String(entry.type)}' has no metered translation; only client function tools are served`);
+		if (typeof entry.name !== "string" || !entry.name.trim()) throw refuse(`tools[${index}] requires a non-empty name`);
+		if (entry.description !== void 0 && typeof entry.description !== "string") throw refuse(`tools[${index}] description must be a string`);
+		if (!isRecord(entry.input_schema)) throw refuse(`tools[${index}] requires an input_schema object`);
+		for (const key of Object.keys(entry)) {
+			if (TOOL_ENTRY_FIELDS.has(key)) continue;
+			stripped.add(`tools.${key}`);
+		}
+		return {
+			type: "function",
+			function: {
+				name: entry.name,
+				...entry.description === void 0 ? {} : { description: entry.description },
+				parameters: entry.input_schema
+			}
+		};
+	});
+}
+function translateToolChoice(value, stripped) {
+	if (value === void 0) return void 0;
+	if (!isRecord(value) || typeof value.type !== "string") throw refuse("tool_choice must be an object with a type");
+	for (const key of Object.keys(value)) {
+		if (key === "type") continue;
+		if (key === "name" && value.type === "tool") continue;
+		if (key === "disable_parallel_tool_use") {
+			stripped.add("tool_choice.disable_parallel_tool_use");
+			continue;
+		}
+		throw refuse(`tool_choice field '${key}' has no metered translation`);
+	}
+	if (value.type === "auto") return "auto";
+	if (value.type === "none") return "none";
+	if (value.type === "any") return "required";
+	if (value.type === "tool") {
+		if (typeof value.name !== "string" || !value.name.trim()) throw refuse("tool_choice type tool requires a tool name");
+		return {
+			type: "function",
+			function: { name: value.name }
+		};
+	}
+	throw refuse(`tool_choice type '${String(value.type)}' has no metered translation`);
+}
+function translateSystem(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) throw refuse("system must be a string or an array of text blocks");
+	return joinTextBlocks(value, "system");
+}
+function translateConversation(value, stripped) {
+	if (!Array.isArray(value) || value.length === 0) throw refuse("request requires a non-empty messages array");
+	const out = [];
+	for (const entry of value) {
+		if (!isRecord(entry)) throw refuse("each message must be an object");
+		if (entry.role !== "user" && entry.role !== "assistant") throw refuse(`message role must be 'user' or 'assistant'`);
+		if (typeof entry.content === "string") {
+			out.push({
+				role: entry.role,
+				content: entry.content
+			});
+			continue;
+		}
+		if (!Array.isArray(entry.content) || entry.content.length === 0) throw refuse(`${entry.role} message content must be a string or a non-empty block array`);
+		if (entry.role === "assistant") out.push(translateAssistantBlocks(entry.content, stripped));
+		else out.push(...translateUserBlocks(entry.content, stripped));
+	}
+	return out;
+}
+function translateAssistantBlocks(blocks, stripped) {
+	const parts = [];
+	const toolCalls = [];
+	for (const block of blocks) {
+		if (!isRecord(block)) throw refuse("assistant message content blocks must be objects");
+		if (block.type === "text") {
+			if (typeof block.text !== "string") throw refuse("assistant message text blocks require string text");
+			parts.push(block.text);
+			continue;
+		}
+		if (block.type === "tool_use") {
+			if (typeof block.id !== "string" || !block.id.trim()) throw refuse("assistant tool_use blocks require a string id");
+			if (typeof block.name !== "string" || !block.name.trim()) throw refuse("assistant tool_use blocks require a string name");
+			if (!isRecord(block.input)) throw refuse("assistant tool_use blocks require an input object");
+			toolCalls.push({
+				id: block.id,
+				name: block.name,
+				argumentsJson: JSON.stringify(block.input)
+			});
+			continue;
+		}
+		if (block.type === "thinking" || block.type === "redacted_thinking") {
+			stripped.add(`messages.${String(block.type)}`);
+			continue;
+		}
+		throw refuse(`assistant message content block type '${String(block.type)}' has no metered translation`);
+	}
+	return {
+		role: "assistant",
+		content: parts.join("\n\n"),
+		...toolCalls.length > 0 ? { toolCalls } : {}
+	};
+}
+function translateUserBlocks(blocks, stripped) {
+	const out = [];
+	const textParts = [];
+	const flushText = () => {
+		if (textParts.length === 0) return;
+		out.push({
+			role: "user",
+			content: textParts.join("\n\n")
+		});
+		textParts.length = 0;
+	};
+	for (const block of blocks) {
+		if (!isRecord(block)) throw refuse("user message content blocks must be objects");
+		if (block.type === "text") {
+			if (typeof block.text !== "string") throw refuse("user message text blocks require string text");
+			textParts.push(block.text);
+			continue;
+		}
+		if (block.type === "tool_result") {
+			if (typeof block.tool_use_id !== "string" || !block.tool_use_id.trim()) throw refuse("user tool_result blocks require a string tool_use_id");
+			if (block.is_error === true) stripped.add("messages.tool_result.is_error");
+			flushText();
+			out.push({
+				role: "tool",
+				content: toolResultText(block.content),
+				toolCallId: block.tool_use_id
+			});
+			continue;
+		}
+		throw refuse(`user message content block type '${String(block.type)}' has no metered translation`);
+	}
+	flushText();
+	return out;
+}
+function toolResultText(value) {
+	if (value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) throw refuse("user tool_result content must be a string or a block array");
+	const parts = [];
+	for (const block of value) {
+		if (!isRecord(block) || block.type !== "text" || typeof block.text !== "string") throw refuse("user tool_result content blocks must be text blocks");
+		parts.push(block.text);
+	}
+	return parts.join("\n\n");
+}
+function joinTextBlocks(blocks, label) {
+	const parts = [];
+	for (const block of blocks) {
+		if (!isRecord(block)) throw refuse(`${label} content blocks must be objects`);
+		if (block.type === "text") {
+			if (typeof block.text !== "string") throw refuse(`${label} text blocks require string text`);
+			parts.push(block.text);
+			continue;
+		}
+		throw refuse(`${label} content block type '${String(block.type)}' has no metered translation`);
+	}
+	return parts.join("\n\n");
+}
+const STOP_REASON_BY_FINISH_REASON = {
+	stop: "end_turn",
+	length: "max_tokens",
+	content_filter: "refusal",
+	tool_calls: "tool_use",
+	tool_use: "tool_use"
+};
+/**
+* Encode one canonical owner response as an Anthropic message.
+*
+* Usage fields are display-level for the CLI; the ledger receipt reads the
+* same canonical response through the proxy's strict receipt checks. An
+* uncaptured usage renders as zeros here while the receipt keeps the honest
+* unknown-cost maximum. Canonical tool calls become `tool_use` content blocks
+* after the text block, matching Anthropic block ordering.
+*/
+function encodeAnthropicMessage(response, callId) {
+	const finishReason = response.finishReason ?? "stop";
+	const stopReason = finishReason === null ? "end_turn" : STOP_REASON_BY_FINISH_REASON[finishReason];
+	if (stopReason === void 0) throw new AnthropicRequestRefusal(502, "api_error", `optimizer model finish reason '${String(finishReason)}' has no Anthropic translation`);
+	const captured = response.usage.captured !== false;
+	const cachedTokens = response.usage.cachedPromptTokens ?? 0;
+	const content = [];
+	if (response.content.length > 0) content.push({
+		type: "text",
+		text: response.content
+	});
+	for (const call of response.toolCalls ?? []) content.push({
+		type: "tool_use",
+		id: call.id,
+		name: call.name,
+		input: parseToolInput(call)
+	});
+	return {
+		id: `msg_${callId}`,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage: captured ? {
+			input_tokens: response.usage.promptTokens - cachedTokens,
+			cache_read_input_tokens: cachedTokens,
+			cache_creation_input_tokens: 0,
+			output_tokens: response.usage.completionTokens
+		} : {
+			input_tokens: 0,
+			output_tokens: 0
+		}
+	};
+}
+function parseToolInput(call) {
+	const text = call.argumentsJson.trim();
+	if (text === "") return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new AnthropicRequestRefusal(502, "api_error", `optimizer model tool call '${call.name}' returned arguments that are not valid JSON`);
+	}
+	if (!isRecord(parsed)) throw new AnthropicRequestRefusal(502, "api_error", `optimizer model tool call '${call.name}' arguments must encode a JSON object`);
+	return parsed;
+}
+/**
+* Render one completed Anthropic message as the SSE stream the CLI expects.
+*
+* The whole stream is synthesized after the owner call completes, so the
+* event burst is exact: usage is final and a cap-violating response is
+* rejected with a real status instead of a half-delivered stream. A
+* `tool_use` block streams as an empty-input `content_block_start` plus one
+* `input_json_delta` carrying the complete arguments JSON.
+*/
+function renderAnthropicSseStream(message) {
+	const content = Array.isArray(message.content) ? message.content : [];
+	const usage = isRecord(message.usage) ? message.usage : {
+		input_tokens: 0,
+		output_tokens: 0
+	};
+	const events = [{
+		event: "message_start",
+		data: {
+			type: "message_start",
+			message: {
+				...message,
+				content: [],
+				stop_reason: null,
+				stop_sequence: null
+			}
+		}
+	}];
+	for (const [index, block] of content.entries()) {
+		if (!isRecord(block)) continue;
+		if (block.type === "text") {
+			events.push({
+				event: "content_block_start",
+				data: {
+					type: "content_block_start",
+					index,
+					content_block: {
+						type: "text",
+						text: ""
+					}
+				}
+			}, {
+				event: "content_block_delta",
+				data: {
+					type: "content_block_delta",
+					index,
+					delta: {
+						type: "text_delta",
+						text: block.text
+					}
+				}
+			}, {
+				event: "content_block_stop",
+				data: {
+					type: "content_block_stop",
+					index
+				}
+			});
+			continue;
+		}
+		if (block.type === "tool_use") events.push({
+			event: "content_block_start",
+			data: {
+				type: "content_block_start",
+				index,
+				content_block: {
+					type: "tool_use",
+					id: block.id,
+					name: block.name,
+					input: {}
+				}
+			}
+		}, {
+			event: "content_block_delta",
+			data: {
+				type: "content_block_delta",
+				index,
+				delta: {
+					type: "input_json_delta",
+					partial_json: JSON.stringify(block.input)
+				}
+			}
+		}, {
+			event: "content_block_stop",
+			data: {
+				type: "content_block_stop",
+				index
+			}
+		});
+	}
+	events.push({
+		event: "message_delta",
+		data: {
+			type: "message_delta",
+			delta: {
+				stop_reason: message.stop_reason,
+				stop_sequence: null
+			},
+			usage: { output_tokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0 }
+		}
+	}, {
+		event: "message_stop",
+		data: { type: "message_stop" }
+	});
+	return events.map((entry) => `event: ${entry.event}\ndata: ${JSON.stringify(entry.data)}\n\n`).join("");
+}
+function anthropicErrorEnvelope(errorType, message) {
+	return {
+		type: "error",
+		error: {
+			type: errorType,
+			message
+		}
+	};
+}
+function anthropicErrorTypeForStatus(status) {
+	if (status === 401) return "authentication_error";
+	if (status === 403) return "permission_error";
+	if (status === 404) return "not_found_error";
+	if (status === 413) return "request_too_large";
+	if (status === 429) return "rate_limit_error";
+	if (status >= 500) return "api_error";
+	return "invalid_request_error";
+}
+function refuse(message) {
+	return new AnthropicRequestRefusal(400, "invalid_request_error", message);
+}
+//#endregion
 //#region src/campaign/external-optimizer-http.ts
 function listenLocal(server) {
 	return new Promise((resolvePromise, reject) => {
@@ -289,6 +752,16 @@ async function startExternalOptimizerModelProxy(args) {
 	const token = randomLocalToken();
 	let requestCount = 0;
 	let successfulCompletionCount = 0;
+	const wireCounts = {
+		openai: {
+			requestAttempts: 0,
+			successfulCompletions: 0
+		},
+		anthropic: {
+			requestAttempts: 0,
+			successfulCompletions: 0
+		}
+	};
 	let modelCallInvocations = 0;
 	let executionRecordCount = 0;
 	let executionSequence = 0;
@@ -319,7 +792,7 @@ async function startExternalOptimizerModelProxy(args) {
 			controller,
 			token,
 			args,
-			nextReservation: (maximumCostUsd) => {
+			nextReservation: (maximumCostUsd, wire) => {
 				if (totalRequestCount >= args.budget.maxRequests) return {
 					accepted: false,
 					reason: "optimizer model request limit reached"
@@ -329,6 +802,7 @@ async function startExternalOptimizerModelProxy(args) {
 					reason: "optimizer model cost limit reached"
 				};
 				requestCount += 1;
+				wireCounts[wire].requestAttempts += 1;
 				totalRequestCount += 1;
 				reservedForBudget += maximumCostUsd ?? 0;
 				return { accepted: true };
@@ -337,8 +811,9 @@ async function startExternalOptimizerModelProxy(args) {
 				reservedForBudget = Math.max(0, reservedForBudget - (maximumCostUsd ?? 0));
 				committedForBudget += chargedCostUsd ?? 0;
 			},
-			recordSuccessfulCompletion: () => {
+			recordSuccessfulCompletion: (wire) => {
 				successfulCompletionCount += 1;
+				wireCounts[wire].successfulCompletions += 1;
 			},
 			recordExecutionReceipt: (observation) => {
 				try {
@@ -385,6 +860,10 @@ async function startExternalOptimizerModelProxy(args) {
 		apiKey: token,
 		requestAttempts: () => requestCount,
 		successfulCompletions: () => successfulCompletionCount,
+		wireUsage: () => ({
+			openai: { ...wireCounts.openai },
+			anthropic: { ...wireCounts.anthropic }
+		}),
 		assertExecutionComplete,
 		failures: () => [...failures],
 		close
@@ -409,35 +888,51 @@ async function startExternalOptimizerModelProxy(args) {
 }
 async function handleModelProxyRequest(args) {
 	const { controller, request, response } = args;
+	let wire = "openai";
+	const respondError = (status, message, errorType) => {
+		if (wire === "anthropic") {
+			const mapped = status === 429 ? 402 : status;
+			sendJsonIfOpen(response, mapped, anthropicErrorEnvelope(errorType ?? anthropicErrorTypeForStatus(mapped), message));
+			return;
+		}
+		sendJsonIfOpen(response, status, { error: message });
+	};
 	try {
 		const path = request.url ? new URL(request.url, "http://127.0.0.1").pathname : "";
-		if (request.method !== "POST" || !MODEL_PROXY_PATHS.has(path)) {
+		const anthropicPath = path === "/v1/messages" && args.args.anthropicEndpoint === true;
+		if (request.method !== "POST" || !(MODEL_PROXY_PATHS.has(path) || anthropicPath)) {
 			sendJsonIfOpen(response, 404, { error: "not found" });
 			return;
 		}
+		if (anthropicPath) wire = "anthropic";
 		const modelPath = path;
-		if (request.headers.authorization !== `Bearer ${args.token}`) {
-			sendJsonIfOpen(response, 401, { error: "unauthorized" });
+		if (!(request.headers.authorization === `Bearer ${args.token}` || wire === "anthropic" && request.headers["x-api-key"] === args.token)) {
+			respondError(401, "unauthorized");
 			return;
 		}
 		const body = await readBody(request, args.args.budget.maxRequestBytes);
 		const parsed = parseModelProxyRequest(body, modelPath, args.args.model, args.args.budget);
 		const maximumUsage = conservativeMaximumUsage(body.byteLength, parsed.maxOutputTokens + (args.args.budget.maxReasoningTokensPerRequest ?? 0), args.args.budget.pricing);
 		const maximumCostUsd = args.args.budget.pricing ? costForTokenPricing(args.args.budget.pricing, maximumUsage) : void 0;
-		const reservation = args.nextReservation(maximumCostUsd);
+		const reservation = args.nextReservation(maximumCostUsd, wire);
 		if (!reservation.accepted) {
-			sendJsonIfOpen(response, 429, { error: reservation.reason });
+			respondError(429, reservation.reason);
 			return;
 		}
 		const timeout = setTimeout(() => controller.abort(), args.args.budget.requestTimeoutMs ?? 3e5);
 		let chargedForBudget = maximumCostUsd;
 		try {
+			const requestTags = wire === "anthropic" ? {
+				...args.args.tags ?? {},
+				wire: "anthropic",
+				...parsed.strippedFields === void 0 ? {} : { strippedFields: parsed.strippedFields.join(",") }
+			} : args.args.tags;
 			const paid = await args.args.costLedger.runPaidCall({
 				...args.args.callId ? { callId: args.args.callId } : {},
 				channel: args.args.channel ?? "optimizer",
 				phase: args.args.phase,
 				actor: args.args.actor,
-				...args.args.tags ? { tags: args.args.tags } : {},
+				...requestTags ? { tags: requestTags } : {},
 				model: args.args.model,
 				...args.args.budget.pricing ? { maximumCharge: {
 					customTokenPricing: args.args.budget.pricing,
@@ -452,7 +947,9 @@ async function handleModelProxyRequest(args) {
 					recordModelCallInvocation: args.recordModelCallInvocation,
 					path: modelPath,
 					request: parsed.request,
+					...parsed.stream === void 0 ? {} : { anthropicStream: parsed.stream },
 					model: args.args.model,
+					allowWithinFamily: args.args.servedModelPolicy === "allow-within-family",
 					maxOutputTokens: parsed.maxOutputTokens,
 					...args.args.budget.maxReasoningTokensPerRequest === void 0 ? {} : { maxReasoningTokens: args.args.budget.maxReasoningTokensPerRequest },
 					maxResponseBytes: args.args.budget.maxResponseBytes,
@@ -470,19 +967,19 @@ async function handleModelProxyRequest(args) {
 			if (!paid.succeeded) {
 				args.recordFailure(paid.error);
 				chargedForBudget = paid.receipt ? paid.receipt.usageUnknown || paid.receipt.costUnknown ? maximumCostUsd : paid.receipt.costUsd : void 0;
-				sendJsonIfOpen(response, isAbortError(paid.error) ? 504 : paid.error instanceof ProviderResponseTooLargeError || paid.error instanceof MissingModelExecutionError || paid.error instanceof ModelExecutionPersistenceError || paid.error instanceof OwnerModelContractError || paid.error instanceof ModelSubstitutionError ? 502 : 429, { error: paid.error.message });
+				respondError(isAbortError(paid.error) ? 504 : paid.error instanceof AnthropicRequestRefusal ? paid.error.status : paid.error instanceof ProviderResponseTooLargeError || paid.error instanceof MissingModelExecutionError || paid.error instanceof ModelExecutionPersistenceError || paid.error instanceof OwnerModelContractError || paid.error instanceof ModelSubstitutionError ? 502 : 429, paid.error.message, paid.error instanceof AnthropicRequestRefusal ? paid.error.errorType : void 0);
 				return;
 			}
 			if (paid.value.modelCallFailed) {
-				sendJsonIfOpen(response, 502, { error: paid.value.modelCallFailed });
+				respondError(502, paid.value.modelCallFailed);
 				return;
 			}
 			chargedForBudget = paid.value.usageComplete ? paid.receipt.costUsd : maximumCostUsd;
 			if (paid.value.usageRejected) {
-				sendJsonIfOpen(response, 502, { error: paid.value.usageRejected });
+				respondError(502, paid.value.usageRejected);
 				return;
 			}
-			if (paid.value.status >= 200 && paid.value.status < 300) args.recordSuccessfulCompletion();
+			if (paid.value.status >= 200 && paid.value.status < 300) args.recordSuccessfulCompletion(wire);
 			if (response.destroyed || response.writableEnded) return;
 			response.writeHead(paid.value.status, {
 				"content-type": paid.value.contentType,
@@ -494,7 +991,7 @@ async function handleModelProxyRequest(args) {
 			args.settleReservation(maximumCostUsd, chargedForBudget);
 		}
 	} catch (error) {
-		sendJsonIfOpen(response, error instanceof RequestBodyTooLargeError ? 413 : error instanceof Error && isAbortError(error) ? 503 : 400, { error: toErrorMessage(error) });
+		respondError(error instanceof AnthropicRequestRefusal ? error.status : error instanceof RequestBodyTooLargeError ? 413 : error instanceof Error && isAbortError(error) ? 503 : 400, toErrorMessage(error), error instanceof AnthropicRequestRefusal ? error.errorType : void 0);
 	}
 }
 async function waitForActiveHandlers(activeHandlers) {
@@ -528,8 +1025,8 @@ async function forwardModelProxyRequest(args) {
 		let authoritativeReceipt;
 		let canonicalResponse;
 		try {
-			authoritativeReceipt = snapshotModelReceipt(called.receipt, args.model);
-			canonicalResponse = snapshotChatResponse(called.response, args.model);
+			authoritativeReceipt = snapshotModelReceipt(called.receipt, args.model, args.allowWithinFamily);
+			canonicalResponse = snapshotChatResponse(called.response, args.model, args.allowWithinFamily);
 			assertResponseUsageMatchesReceipt(canonicalResponse, authoritativeReceipt);
 		} catch (error) {
 			args.recordExecutionReceipt({
@@ -556,8 +1053,12 @@ async function forwardModelProxyRequest(args) {
 		const reasoningTokens = canonicalResponse.usage.reasoningTokens ?? 0;
 		const completionTokens = canonicalResponse.usage.completionTokens - reasoningTokens;
 		const usageRejected = usageKnown && completionTokens > args.maxOutputTokens ? `optimizer model execution reported ${completionTokens} completion tokens, exceeding requested limit ${args.maxOutputTokens}` : usageKnown && args.maxReasoningTokens !== void 0 && reasoningTokens > args.maxReasoningTokens ? `optimizer model execution reported ${reasoningTokens} reasoning tokens, exceeding the declared budget ${args.maxReasoningTokens}` : void 0;
-		return {
-			status: 200,
+		const encoded = args.path === "/v1/messages" ? encodeAnthropicResponseBody({
+			callId: args.callId,
+			response: canonicalResponse,
+			stream: args.anthropicStream === true,
+			maxBytes: args.maxResponseBytes
+		}) : {
 			contentType: "application/json",
 			body: encodeCanonicalModelResponse({
 				path: args.path,
@@ -565,7 +1066,12 @@ async function forwardModelProxyRequest(args) {
 				response: canonicalResponse,
 				receipt: authoritativeReceipt,
 				maxBytes: args.maxResponseBytes
-			}),
+			})
+		};
+		return {
+			status: 200,
+			contentType: encoded.contentType,
+			body: encoded.body,
 			receipt: authoritativeReceipt,
 			usageComplete: authoritativeReceipt.usageUnknown !== true,
 			...usageRejected ? { usageRejected } : {}
@@ -581,7 +1087,7 @@ async function forwardModelProxyRequest(args) {
 			error: called.error,
 			execution
 		});
-		const failedReceipt = snapshotModelReceipt(called.receipt, args.model);
+		const failedReceipt = snapshotModelReceipt(called.receipt, args.model, args.allowWithinFamily);
 		return {
 			status: 502,
 			contentType: "application/json",
@@ -592,7 +1098,7 @@ async function forwardModelProxyRequest(args) {
 		};
 	}
 }
-function snapshotModelReceipt(value, expectedModel) {
+function snapshotModelReceipt(value, expectedModel, allowWithinFamily) {
 	let snapshot;
 	try {
 		assertJsonValue(value, "optimizer model callback receipt");
@@ -600,7 +1106,10 @@ function snapshotModelReceipt(value, expectedModel) {
 	} catch (error) {
 		throw new OwnerModelContractError(`optimizer model callback returned an invalid receipt: ${toErrorMessage(error)}`);
 	}
-	assertServedModel(expectedModel, snapshot.model, { context: "optimizer model callback receipt" });
+	assertServedModel(expectedModel, snapshot.model, {
+		context: "optimizer model callback receipt",
+		allowWithinFamily
+	});
 	return snapshot;
 }
 function freezeJsonSnapshot(value, label) {
@@ -629,6 +1138,15 @@ function assertResponseUsageMatchesReceipt(response, receipt) {
 	if (response.costUsd !== receiptCostUsd) throw new OwnerModelContractError("optimizer model response billed cost disagrees with the execution receipt");
 }
 function parseModelProxyRequest(body, path, expectedModel, budget) {
+	if (path === "/v1/messages") {
+		const translated = translateAnthropicMessagesRequest(body, expectedModel, budget.maxOutputTokensPerRequest);
+		return {
+			maxOutputTokens: translated.maxOutputTokens,
+			stream: translated.stream,
+			...translated.strippedFields.length > 0 ? { strippedFields: translated.strippedFields } : {},
+			request: freezeJsonSnapshot(translated.request, "optimizer model canonical request")
+		};
+	}
 	let value;
 	try {
 		value = JSON.parse(Buffer.from(body).toString("utf8"));
@@ -878,13 +1396,17 @@ function assertAllowedKeys(value, allowed, label = "optimizer model request") {
 	const unknown = Object.keys(value).filter((key) => !allowedSet.has(key));
 	if (unknown.length > 0) throw new Error(`${label} contains unsupported fields: ${unknown.join(", ")}`);
 }
-function snapshotChatResponse(value, expectedModel) {
+function snapshotChatResponse(value, expectedModel, allowWithinFamily) {
 	if (!isRecord(value)) throw new OwnerModelContractError("optimizer model callback response must be an object");
 	if (typeof value.content !== "string") throw new OwnerModelContractError("optimizer model callback response content must be a string");
-	assertServedModel(expectedModel, typeof value.model === "string" ? value.model : null, { context: "optimizer model callback response" });
+	assertServedModel(expectedModel, typeof value.model === "string" ? value.model : null, {
+		context: "optimizer model callback response",
+		allowWithinFamily
+	});
 	if (!isNonnegativeFiniteNumber(value.durationMs)) throw new OwnerModelContractError("optimizer model callback response durationMs must be finite and non-negative");
 	if (value.costUsd !== null && !isNonnegativeFiniteNumber(value.costUsd)) throw new OwnerModelContractError("optimizer model callback response costUsd must be null or finite and non-negative");
 	if (value.finishReason !== void 0 && value.finishReason !== null && typeof value.finishReason !== "string") throw new OwnerModelContractError("optimizer model callback response finishReason must be a string or null");
+	const toolCalls = snapshotResponseToolCalls(value.toolCalls);
 	if (value.contentEmpty !== void 0 && (typeof value.contentEmpty !== "boolean" || value.contentEmpty !== (value.content.trim().length === 0))) throw new OwnerModelContractError("optimizer model callback response contentEmpty must match content");
 	if (!isRecord(value.raw)) throw new OwnerModelContractError("optimizer model callback response raw must be an object");
 	if (!isRecord(value.usage)) throw new OwnerModelContractError("optimizer model callback response usage must be an object");
@@ -909,6 +1431,7 @@ function snapshotChatResponse(value, expectedModel) {
 	}
 	return deepFreezeJson({
 		content: value.content,
+		...toolCalls === void 0 ? {} : { toolCalls },
 		usage: {
 			promptTokens,
 			completionTokens,
@@ -925,6 +1448,28 @@ function snapshotChatResponse(value, expectedModel) {
 		raw
 	});
 }
+/** Snapshot the owner's canonical tool calls onto the allowlisted response. */
+function snapshotResponseToolCalls(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.length === 0) throw new OwnerModelContractError("optimizer model callback response toolCalls must be a non-empty array when present");
+	return value.map((entry) => {
+		if (!isRecord(entry) || typeof entry.id !== "string" || !entry.id || typeof entry.name !== "string" || !entry.name || typeof entry.argumentsJson !== "string") throw new OwnerModelContractError("optimizer model callback response toolCalls entries require string id, name, and argumentsJson");
+		return {
+			id: entry.id,
+			name: entry.name,
+			argumentsJson: entry.argumentsJson
+		};
+	});
+}
+function encodeAnthropicResponseBody(args) {
+	const message = encodeAnthropicMessage(args.response, args.callId);
+	const body = new TextEncoder().encode(args.stream ? renderAnthropicSseStream(message) : JSON.stringify(message));
+	if (body.byteLength > args.maxBytes) throw new ProviderResponseTooLargeError();
+	return {
+		contentType: args.stream ? "text/event-stream; charset=utf-8" : "application/json",
+		body
+	};
+}
 function encodeCanonicalModelResponse(args) {
 	const usage = encodeProtocolUsage(args.path, args.response, args.receipt);
 	const finishReason = args.response.finishReason === void 0 ? "stop" : args.response.finishReason;
@@ -969,6 +1514,7 @@ function encodeCanonicalModelResponse(args) {
 	return encoded;
 }
 function endpointFormat(path) {
+	if (path === "/v1/messages") return "anthropic-messages";
 	return path === "/v1/responses" ? "responses" : "chat-completions";
 }
 function encodeProtocolUsage(path, response, receipt) {
@@ -1015,6 +1561,7 @@ function conservativeMaximumUsage(inputTokenUpperBound, outputTokenUpperBound, p
 	};
 }
 function assertModelProxyConfig(args) {
+	assertServedModelPolicy(args.servedModelPolicy, "external optimizer model proxy: servedModelPolicy");
 	for (const [label, value] of [
 		["model", args.model],
 		["phase", args.phase],
@@ -1350,4 +1897,4 @@ function summarizeProcessOutput(capture, max = 4e3) {
 //#endregion
 export { SEARCH_LEDGER_FILE_CONTEXT as C, SearchLedgerIntegrityError as E, inMemoryCampaignStorage as S, SearchLedgerError as T, resolveExternalOptimizerCallbackLimits as _, closeServer as a, createRunCostLedger as b, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as c, assertJsonValue as d, assertNoCredentialValues as f, removeCredentialEnvironment as g, isRecord as h, startExternalOptimizerModelProxy as i, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as l, isExternalTextCandidate as m, closeExternalOptimizerResources as n, listenLocal as o, isCandidateText as p, runWithCleanup as r, sendJson as s, runExternalOptimizerProcess as t, assertExternalOptimizerModelBudget as u, resolveExternalOptimizerProcessLimits as v, SearchLedgerConflictError as w, fsCampaignStorage as x, safePathComponent as y };
 
-//# sourceMappingURL=external-optimizer-subprocess-DU1KM8yV.js.map
+//# sourceMappingURL=external-optimizer-subprocess-Dn90UqN2.js.map