@tangle-network/agent-eval 0.148.0 → 0.150.0

package/dist/{external-optimizer-subprocess-DU1KM8yV.js → external-optimizer-subprocess-BepyNwtj.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-CxyJ8Oft.js";
 import { createRequire } from "node:module";
 import { randomBytes } from "node:crypto";
 import { isAbsolute, join, resolve } from "node:path";
@@ -247,6 +247,255 @@ 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. Anything without a full-fidelity mapping onto that contract is
+* refused with a loud Anthropic error envelope. The only silent strips are
+* `metadata` and `cache_control`: the CLI always sends both, neither has a
+* canonical slot, and dropping them changes no message content.
+*
+* Tool use is refused because the canonical contract carries text-only
+* messages. Metering CLI tool calls requires a tool extension of
+* `ExternalOptimizerChatRequest` and the execution-owner result.
+*/
+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"
+]);
+const REFUSED_REQUEST_FIELDS = {
+	tools: "tools require a tool-call extension of the canonical execution-owner contract",
+	tool_choice: "tool_choice requires a tool-call extension of the canonical execution-owner contract",
+	thinking: "thinking has no canonical mapping; the injected CLI environment disables it",
+	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");
+	for (const key of Object.keys(parsed)) {
+		if (REQUEST_FIELDS.has(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));
+	return {
+		request: {
+			model: expectedModel,
+			messages,
+			maxTokens,
+			...parsed.temperature !== void 0 ? { temperature: parsed.temperature } : {}
+		},
+		maxOutputTokens: maxTokens,
+		stream: parsed.stream === true
+	};
+}
+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) {
+	if (!Array.isArray(value) || value.length === 0) throw refuse("request requires a non-empty messages array");
+	return value.map((entry) => {
+		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'`);
+		const content = typeof entry.content === "string" ? entry.content : Array.isArray(entry.content) && entry.content.length > 0 ? joinTextBlocks(entry.content, `${entry.role} message`) : refuseValue(`${entry.role} message content must be a string or a non-empty block array`);
+		return {
+			role: entry.role,
+			content
+		};
+	});
+}
+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;
+		}
+		if (block.type === "tool_use" || block.type === "tool_result") throw refuse(`${label} ${String(block.type)} blocks require a tool-call extension of the canonical execution-owner contract`);
+		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"
+};
+/**
+* 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.
+*/
+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;
+	return {
+		id: `msg_${callId}`,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: response.content.length > 0 ? [{
+			type: "text",
+			text: response.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
+		}
+	};
+}
+/**
+* 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.
+*/
+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) || block.type !== "text") continue;
+		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
+			}
+		});
+	}
+	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);
+}
+function refuseValue(message) {
+	throw refuse(message);
+}
+//#endregion
 //#region src/campaign/external-optimizer-http.ts
 function listenLocal(server) {
 	return new Promise((resolvePromise, reject) => {
@@ -289,6 +538,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 +578,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 +588,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 +597,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 +646,10 @@ async function startExternalOptimizerModelProxy(args) {
 		apiKey: token,
 		requestAttempts: () => requestCount,
 		successfulCompletions: () => successfulCompletionCount,
+		wireUsage: () => ({
+			openai: { ...wireCounts.openai },
+			anthropic: { ...wireCounts.anthropic }
+		}),
 		assertExecutionComplete,
 		failures: () => [...failures],
 		close
@@ -409,35 +674,50 @@ 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"
+			} : 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 +732,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 +752,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 +776,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 +810,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 +838,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 +851,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 +872,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 +883,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 +891,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 +923,14 @@ 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,
+			request: freezeJsonSnapshot(translated.request, "optimizer model canonical request")
+		};
+	}
 	let value;
 	try {
 		value = JSON.parse(Buffer.from(body).toString("utf8"));
@@ -878,10 +1180,13 @@ 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");
@@ -925,6 +1230,15 @@ function snapshotChatResponse(value, expectedModel) {
 		raw
 	});
 }
+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 +1283,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 +1330,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 +1666,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-BepyNwtj.js.map