@full-self-browsing/lattice 1.4.0 → 1.5.0

package/dist/scaffolds-ekPIlBeU.js

@@ -0,0 +1,3139 @@
+import { r as defaultCapabilityForProvider } from "./catalog-CAfYwB_-.js";
+import { c as getCapabilityProfile, i as synthesizeNegotiatedCapabilitiesFromRegistry, l as stripOpenRouterVariant, n as mapProfileToNegotiatedCapabilities, o as getRecommendedSanitizers, t as NegotiationAuthError } from "./negotiate-ClD88hkc.js";
+import { i as standardSchemaToJsonSchema, o as parseToolUseEnvelope } from "./validate-c7EL5uuH.js";
+import { n as validateToolCallRequests } from "./tool-call-validation-BFoXkwbf.js";
+import canonicalize from "canonicalize";
+//#region src/providers/multimodal.ts
+function packagedPlanForArtifact(request, artifactId) {
+	return request.providerPackaging?.artifacts.find((item) => item.artifactId === artifactId) ?? request.plan?.providerPackaging?.artifacts.find((item) => item.artifactId === artifactId);
+}
+function metadataString(artifact, keys) {
+	const metadata = artifact.metadata;
+	if (metadata === void 0) return;
+	for (const key of keys) {
+		const value = metadata[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function artifactHttpUrl(artifact) {
+	if (isHttpUrl(artifact.value)) return artifact.value;
+	const url = metadataString(artifact, ["url"]);
+	return isHttpUrl(url) ? url : void 0;
+}
+function anthropicFileId(artifact) {
+	return metadataString(artifact, [
+		"anthropicFileId",
+		"providerFileId",
+		"fileId"
+	]);
+}
+function geminiFileUri(artifact) {
+	return metadataString(artifact, [
+		"geminiFileUri",
+		"providerFileUri",
+		"fileUri"
+	]);
+}
+function mediaTypeForArtifact(artifact, fallback) {
+	if (artifact.mediaType !== void 0) return artifact.mediaType;
+	if (typeof artifact.value === "string") {
+		const dataUrl = parseDataUrl(artifact.value);
+		if (dataUrl?.mediaType !== void 0) return dataUrl.mediaType;
+	}
+	return fallback;
+}
+async function artifactBase64Data(artifact) {
+	const metadataData = metadataString(artifact, ["base64Data"]);
+	if (metadataData !== void 0) return metadataData;
+	const value = artifact.value;
+	if (typeof value === "string") {
+		const dataUrl = parseDataUrl(value);
+		if (dataUrl !== void 0) return dataUrl.data;
+		if (artifact.metadata?.encoding === "base64") return value;
+	}
+	if (isBlobLike(value)) return bufferToBase64(await value.arrayBuffer());
+	if (value instanceof ArrayBuffer) return bufferToBase64(value);
+	if (ArrayBuffer.isView(value)) return Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString("base64");
+}
+function parseDataUrl(value) {
+	const match = /^data:([^;,]+)?;base64,(.*)$/su.exec(value);
+	if (match === null) return;
+	const mediaType = match[1];
+	const data = match[2] ?? "";
+	return {
+		...mediaType !== void 0 && mediaType.length > 0 ? { mediaType } : {},
+		data
+	};
+}
+function bufferToBase64(value) {
+	return Buffer.from(value).toString("base64");
+}
+function isHttpUrl(value) {
+	if (typeof value !== "string") return false;
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function isBlobLike(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+//#endregion
+//#region src/providers/no-public-url.ts
+/**
+* Thrown when a run with `policy.noPublicUrl: true` is about to dispatch a
+* request whose serialized body still contains a public http(s) URL derived
+* from `request.artifacts` (value or string metadata entry).
+*
+* This is the single shared egress error class for all three adapter families
+* (OpenAI-compatible, Anthropic, Gemini).  Callers may `instanceof`-check it.
+*/
+var NoPublicUrlEgressError = class extends Error {
+	constructor(providerId, artifactId, offendingUrl) {
+		super(`noPublicUrl policy violated: provider '${providerId}' artifact '${artifactId}' would leak public URL '${offendingUrl}'`);
+		this.providerId = providerId;
+		this.artifactId = artifactId;
+		this.offendingUrl = offendingUrl;
+		this.name = "NoPublicUrlEgressError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Shared egress assertion called immediately before every run-request `fetch`.
+*
+* When `policy.noPublicUrl` is not `true` this function is a zero-cost no-op.
+*
+* When the policy IS active it builds a forbidden-URL set from ARTIFACT-DERIVED
+* sources only:
+*   - `artifact.value` (if it is a string and `isHttpUrl(value)` is true)
+*   - Every `string` value inside `artifact.metadata` (if `isHttpUrl(v)` is true)
+*
+* URLs in `policy.gateway.metadata` are NOT artifact-derived and are therefore
+* NOT in scope.  They are naturally excluded because they never appear in
+* `request.artifacts`.
+*
+* A URL is considered "leaked" only if the string is present in `serializedBody`.
+* If packaging already replaced the URL with a `data:` URL, `serializedBody`
+* will not contain the original http(s) URL and this function will not throw.
+* `data:` URLs are never forbidden because `isHttpUrl` rejects the `data:` scheme.
+*
+* @throws {NoPublicUrlEgressError} if any forbidden URL appears in `serializedBody`
+*/
+function assertNoPublicUrlEgress(request, providerId, serializedBody) {
+	if (request.policy?.noPublicUrl !== true) return;
+	const forbidden = [];
+	for (const artifact of request.artifacts) {
+		const artifactId = artifact.id ?? "";
+		if (typeof artifact.value === "string" && isHttpUrl(artifact.value)) forbidden.push({
+			url: artifact.value,
+			id: artifactId
+		});
+		const metadata = artifact.metadata ?? {};
+		for (const v of Object.values(metadata)) if (typeof v === "string" && isHttpUrl(v)) forbidden.push({
+			url: v,
+			id: artifactId
+		});
+	}
+	for (const entry of forbidden) if (serializedBody.includes(entry.url)) throw new NoPublicUrlEgressError(providerId, entry.id, entry.url);
+}
+//#endregion
+//#region src/tracing/tracing.ts
+function createRunEvent(kind, input) {
+	return {
+		kind,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...input
+	};
+}
+//#endregion
+//#region src/sanitizers/sanitizers.ts
+async function applyOutputSanitizers(rawOutputs, sanitizeOutput, context) {
+	if (sanitizeOutput === void 0) return rawOutputs;
+	const sanitizers = Array.isArray(sanitizeOutput) ? sanitizeOutput : [sanitizeOutput];
+	const sanitizedEntries = await Promise.all(Object.entries(rawOutputs).map(async ([outputName, value]) => {
+		if (typeof value !== "string") return [outputName, value];
+		let sanitized = value;
+		const sanitizerContext = {
+			...context,
+			outputName
+		};
+		for (const sanitizer of sanitizers) sanitized = await sanitizer(sanitized, sanitizerContext);
+		return [outputName, sanitized];
+	}));
+	return Object.fromEntries(sanitizedEntries);
+}
+function stripReasoningTags() {
+	return (text) => {
+		let next = text;
+		next = next.replace(/^\s*(?:reasoning|analysis|scratchpad)\s*:\s*(?:.|\n)*?(?:\n\s*(?:final|answer)\s*:\s*)/iu, "");
+		next = stripDelimitedBlock(next, "think");
+		next = stripDelimitedBlock(next, "reasoning");
+		next = stripDelimitedBlock(next, "scratchpad");
+		return next === text ? text : next.trim();
+	};
+}
+function stripChatTemplateArtifacts() {
+	return (text) => {
+		let next = text;
+		next = next.replace(/<\|im_start\|>\s*(?:system|user|assistant)?\s*/giu, "");
+		next = next.replace(/\s*<\|im_end\|>/giu, "");
+		next = next.replace(/\[\/?INST\]/giu, "");
+		next = next.replace(/<<SYS>>|<<\/SYS>>/giu, "");
+		next = next.replace(/^\s*(?:system|user|assistant)\s*:\s*/iu, "");
+		return next === text ? text : next.trim();
+	};
+}
+function unwrapInternalEnvelope(schemaOrPath) {
+	const options = parseEnvelopeOptions(schemaOrPath);
+	return async (text) => {
+		const parsed = parseJsonObject$3(text);
+		if (parsed === void 0) return text;
+		if (options.schema !== void 0) {
+			if (!(await validateSchema(options.schema, parsed)).ok) return text;
+		}
+		const value = options.kind === "path" ? getPathValue(parsed, options.path) : findOnlyStringField(parsed);
+		return typeof value === "string" ? value : text;
+	};
+}
+function stripDelimitedBlock(text, tag) {
+	const pattern = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, "giu");
+	return text.replace(pattern, "");
+}
+function parseEnvelopeOptions(schemaOrPath) {
+	if (typeof schemaOrPath === "string") return {
+		kind: "path",
+		path: splitPath(schemaOrPath)
+	};
+	if (isStandardSchema(schemaOrPath)) return {
+		kind: "schema",
+		schema: schemaOrPath
+	};
+	const path = schemaOrPath.path ?? schemaOrPath.field;
+	if (path !== void 0) return {
+		kind: "path",
+		path: splitPath(path),
+		...schemaOrPath.schema !== void 0 ? { schema: schemaOrPath.schema } : {}
+	};
+	if (schemaOrPath.schema !== void 0) return {
+		kind: "schema",
+		schema: schemaOrPath.schema
+	};
+	return {
+		kind: "path",
+		path: []
+	};
+}
+function splitPath(path) {
+	return path.split(".").map((part) => part.trim()).filter(Boolean);
+}
+function parseJsonObject$3(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return;
+	return parsed;
+}
+function getPathValue(value, path) {
+	if (path.length === 0) return void 0;
+	let current = value;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
+		if (!Object.prototype.hasOwnProperty.call(current, segment)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function findOnlyStringField(value) {
+	const stringValues = Object.values(value).filter((field) => typeof field === "string");
+	return stringValues.length === 1 ? stringValues[0] : void 0;
+}
+async function validateSchema(schema, value) {
+	const result = schema["~standard"].validate(value);
+	return "issues" in (result instanceof Promise ? await result : result) ? { ok: false } : { ok: true };
+}
+function isStandardSchema(value) {
+	return typeof value === "object" && value !== null && "~standard" in value && typeof value["~standard"]?.validate === "function";
+}
+//#endregion
+//#region src/providers/sse.ts
+async function* readSseEvents(response) {
+	if (response.body === null) {
+		yield* parseFrames(await response.text(), true).events;
+		return;
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const parsed = parseFrames(buffer, false);
+			buffer = parsed.remaining;
+			yield* parsed.events;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	buffer += decoder.decode();
+	yield* parseFrames(buffer, true).events;
+}
+function parseFrames(input, flush) {
+	const events = [];
+	let remaining = input;
+	while (true) {
+		const match = /\r?\n\r?\n/u.exec(remaining);
+		if (match?.index === void 0) break;
+		const frame = remaining.slice(0, match.index);
+		remaining = remaining.slice(match.index + match[0].length);
+		const event = parseFrame(frame);
+		if (event !== void 0) events.push(event);
+	}
+	if (flush && remaining.trim().length > 0) {
+		const event = parseFrame(remaining);
+		if (event !== void 0) events.push(event);
+		remaining = "";
+	}
+	return {
+		events,
+		remaining
+	};
+}
+function parseFrame(frame) {
+	const data = [];
+	let event;
+	for (const line of frame.split(/\r?\n/u)) {
+		if (line.length === 0 || line.startsWith(":")) continue;
+		const separator = line.indexOf(":");
+		const field = separator === -1 ? line : line.slice(0, separator);
+		const rawValue = separator === -1 ? "" : line.slice(separator + 1);
+		const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+		if (field === "event") event = value;
+		else if (field === "data") data.push(value);
+	}
+	if (data.length === 0) return;
+	return {
+		...event !== void 0 ? { event } : {},
+		data: data.join("\n")
+	};
+}
+//#endregion
+//#region src/providers/adapters.ts
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isGatewayMetadataValue(value) {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) return true;
+	if (Array.isArray(value)) return value.every(isGatewayMetadataValue);
+	if (isRecord$3(value)) return Object.values(value).every(isGatewayMetadataValue);
+	return false;
+}
+function isSecretMetadataKey(key) {
+	return /api[-_]?key|authorization|headers?|secret|token|password/iu.test(key);
+}
+function isSecretMetadataValue(value) {
+	if (typeof value === "string") return /^sk-[\w-]+/u.test(value);
+	if (Array.isArray(value)) return value.some(isSecretMetadataValue);
+	if (typeof value === "object" && value !== null) return Object.entries(value).some(([key, nested]) => isSecretMetadataKey(key) || isSecretMetadataValue(nested));
+	return false;
+}
+function sanitizeGatewayMetadata(metadata) {
+	if (metadata === void 0) return;
+	const sanitized = Object.fromEntries(Object.entries(metadata).filter(([key, value]) => !isSecretMetadataKey(key) && !isSecretMetadataValue(value)));
+	return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+function normalizeGatewayPolicy(value) {
+	if (!isRecord$3(value)) return {};
+	const routeTags = Array.isArray(value.routeTags) ? value.routeTags.filter((tag) => typeof tag === "string") : void 0;
+	const providerPreferences = Array.isArray(value.providerPreferences) ? value.providerPreferences.filter((provider) => typeof provider === "string") : void 0;
+	const gatewayMetadata = {};
+	if (isRecord$3(value.metadata)) {
+		for (const [key, metadataValue] of Object.entries(value.metadata)) if (isGatewayMetadataValue(metadataValue)) gatewayMetadata[key] = metadataValue;
+	}
+	const metadata = Object.keys(gatewayMetadata).length > 0 ? sanitizeGatewayMetadata(gatewayMetadata) : void 0;
+	const allowFallbacks = typeof value.allowFallbacks === "boolean" ? value.allowFallbacks : void 0;
+	return {
+		...routeTags !== void 0 ? { routeTags } : {},
+		...providerPreferences !== void 0 ? { providerPreferences } : {},
+		...metadata !== void 0 ? { metadata } : {},
+		...allowFallbacks !== void 0 ? { allowFallbacks } : {}
+	};
+}
+function readGatewayPolicy(policy) {
+	if (!isRecord$3(policy) || !isRecord$3(policy.gateway)) return;
+	return normalizeGatewayPolicy(policy.gateway);
+}
+function mergeGatewayPolicy(providerGateway, requestGateway) {
+	if (providerGateway === void 0 && requestGateway === void 0) return;
+	const providerMetadata = sanitizeGatewayMetadata(providerGateway?.metadata);
+	const requestMetadata = sanitizeGatewayMetadata(requestGateway?.metadata);
+	const metadata = {
+		...providerMetadata ?? {},
+		...requestMetadata ?? {}
+	};
+	return {
+		routeTags: [...providerGateway?.routeTags ?? [], ...requestGateway?.routeTags ?? []],
+		providerPreferences: [...providerGateway?.providerPreferences ?? [], ...requestGateway?.providerPreferences ?? []],
+		...Object.keys(metadata).length > 0 ? { metadata } : {},
+		...requestGateway?.allowFallbacks !== void 0 ? { allowFallbacks: requestGateway.allowFallbacks } : providerGateway?.allowFallbacks !== void 0 ? { allowFallbacks: providerGateway.allowFallbacks } : {}
+	};
+}
+function gatewayPolicyToMetadata(policy) {
+	if (policy === void 0) return;
+	const metadata = { ...sanitizeGatewayMetadata(policy.metadata) ?? {} };
+	const latticeGateway = {};
+	if (policy.routeTags !== void 0 && policy.routeTags.length > 0) latticeGateway.route_tags = [...policy.routeTags];
+	if (policy.providerPreferences !== void 0 && policy.providerPreferences.length > 0) latticeGateway.provider_preferences = [...policy.providerPreferences];
+	if (policy.allowFallbacks !== void 0) latticeGateway.allow_fallbacks = policy.allowFallbacks;
+	if (Object.keys(latticeGateway).length > 0) metadata.lattice_gateway = latticeGateway;
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function sanitizedGatewayPolicyForPlan(policy) {
+	if (policy === void 0) return;
+	const metadata = sanitizeGatewayMetadata(policy.metadata);
+	return {
+		...policy.routeTags !== void 0 && policy.routeTags.length > 0 ? { routeTags: [...policy.routeTags] } : {},
+		...policy.providerPreferences !== void 0 && policy.providerPreferences.length > 0 ? { providerPreferences: [...policy.providerPreferences] } : {},
+		...metadata !== void 0 ? { metadata } : {},
+		...policy.allowFallbacks !== void 0 ? { allowFallbacks: policy.allowFallbacks } : {}
+	};
+}
+function observedModelFromResponse(body) {
+	if (!isRecord$3(body)) return;
+	const model = body.model;
+	return typeof model === "string" ? model : void 0;
+}
+function createOpenAICompatibleRequestBody(input) {
+	const nativeTools = openAIToolDefinitions(input.request.nativeTools);
+	const nativeToolChoice = openAIToolChoice(input.request.nativeToolChoice);
+	const responseFormat = openAIResponseFormat(input.request.nativeStructuredOutput);
+	return {
+		model: input.model,
+		...input.metadata !== void 0 ? { metadata: input.metadata } : {},
+		messages: [{
+			role: "user",
+			content: [
+				{
+					type: "text",
+					text: input.request.task
+				},
+				{
+					type: "text",
+					text: JSON.stringify({ contextPack: input.request.contextPack === void 0 ? void 0 : {
+						id: input.request.contextPack.id,
+						tokenBudget: input.request.contextPack.tokenBudget,
+						estimatedTokens: input.request.contextPack.estimatedTokens,
+						included: input.request.contextPack.included,
+						summarized: input.request.contextPack.summarized,
+						archived: input.request.contextPack.archived,
+						omitted: input.request.contextPack.omitted,
+						warnings: input.request.contextPack.warnings
+					} })
+				},
+				...input.request.artifacts.map((inputArtifact) => {
+					const resolvedTransport = input.request.providerPackaging?.artifacts.find((item) => item.artifactId === inputArtifact.id)?.transport ?? input.request.plan?.providerPackaging?.artifacts.find((item) => item.artifactId === inputArtifact.id)?.transport;
+					return {
+						type: "text",
+						text: JSON.stringify({
+							artifactId: inputArtifact.id,
+							kind: inputArtifact.kind,
+							mediaType: inputArtifact.mediaType,
+							privacy: inputArtifact.privacy,
+							transport: resolvedTransport,
+							value: typeof inputArtifact.value === "string" && inputArtifact.kind !== "url" && !(isHttpUrl(inputArtifact.value) && resolvedTransport !== "url") ? inputArtifact.value : void 0,
+							url: inputArtifact.kind === "url" && typeof inputArtifact.value === "string" && resolvedTransport === "url" ? inputArtifact.value : void 0
+						})
+					};
+				})
+			]
+		}],
+		...input.stream === true ? {
+			stream: true,
+			stream_options: { include_usage: true }
+		} : {},
+		...nativeTools.length > 0 ? { tools: nativeTools } : {},
+		...nativeToolChoice !== void 0 ? { tool_choice: nativeToolChoice } : {},
+		...responseFormat !== void 0 ? { response_format: responseFormat } : {}
+	};
+}
+function openAIToolDefinitions(tools) {
+	return (tools ?? []).map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			...tool.description !== void 0 ? { description: tool.description } : {},
+			parameters: standardSchemaToJsonSchema(tool.inputSchema)
+		}
+	}));
+}
+function openAIToolChoice(choice) {
+	if (choice === void 0) return;
+	if (choice === "auto" || choice === "none" || choice === "required") return choice;
+	return {
+		type: "function",
+		function: { name: choice.name }
+	};
+}
+function openAIResponseFormat(request) {
+	if (request === void 0) return;
+	return {
+		type: "json_schema",
+		json_schema: {
+			name: request.name ?? request.output,
+			schema: standardSchemaToJsonSchema(request.schema),
+			strict: request.strict ?? true
+		}
+	};
+}
+/**
+* Phase 34 — D-04 / QUIRK-02 — OpenAI-compatible provider factory.
+*
+* This factory is the prototypical "intentional no remote /models endpoint"
+* adapter per D-04. The consumer points this adapter at any OpenAI-shaped
+* endpoint (vLLM, TGI, Ollama, custom), and the factory returns conservative
+* defaults for the quirks block because the server could be anything.
+*
+* The `negotiateCapabilities` method performs NO fetch; it returns
+* synthesizeNegotiatedCapabilitiesFromRegistry with source: "registry"
+* (the intentional-no-endpoint signal, as distinct from "registry-fallback"
+* which signals a transient failure). Plan 34-05 (LM Studio) reuses this
+* same pattern.
+*
+* D-04 citation: "consumer adapters without a /models endpoint skip the
+* fetch layer entirely and delegate to synthesizeNegotiatedCapabilitiesFromRegistry."
+*/
+function createOpenAICompatibleProvider(options) {
+	const id = options.id ?? "openai-compatible";
+	const fetchImpl = options.fetch ?? fetch;
+	const baseUrl = options.baseUrl.replace(/\/$/u, "");
+	const negotiate = async (modelId) => {
+		return synthesizeNegotiatedCapabilitiesFromRegistry(id, modelId, "registry");
+	};
+	return {
+		id,
+		kind: "provider-adapter",
+		quirks: {
+			supportsToolChoice: false,
+			parallelToolCalls: false,
+			structuredOutputs: false,
+			responseFormatHonored: false,
+			streamingDiverges: true
+		},
+		negotiateCapabilities: negotiate,
+		capabilities: [{
+			...defaultCapabilityForProvider(id),
+			modelId: options.model,
+			fileTransport: [
+				"inline",
+				"json",
+				"url",
+				"base64",
+				"extracted-text",
+				"transcript"
+			],
+			streaming: true
+		}],
+		async execute(request) {
+			const mergedGatewayPolicy = mergeGatewayPolicy(options.gateway, readGatewayPolicy(request.policy));
+			const metadata = gatewayPolicyToMetadata(mergedGatewayPolicy);
+			const bodyStr = JSON.stringify(createOpenAICompatibleRequestBody({
+				model: options.model,
+				request,
+				...metadata !== void 0 ? { metadata } : {}
+			}));
+			assertNoPublicUrlEgress(request, id, bodyStr);
+			const init = {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					...options.apiKey !== void 0 ? { authorization: `Bearer ${options.apiKey}` } : {}
+				},
+				body: bodyStr,
+				...request.signal !== void 0 ? { signal: request.signal } : {}
+			};
+			const response = await fetchImpl(`${baseUrl}/chat/completions`, init);
+			if (!response.ok) throw new Error(`OpenAI-compatible provider failed with ${response.status}.`);
+			const body = await response.json();
+			const observedModel = observedModelFromResponse(body);
+			const choice = firstOpenAIChoice(body);
+			const message = openAIMessageFromChoice(choice);
+			const text = openAIMessageText(message);
+			const structuredOutput = openAIStructuredOutputValue(request.nativeStructuredOutput, message, text);
+			const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest$2({
+				outputs: request.outputs,
+				text,
+				structuredOutputRequest: request.nativeStructuredOutput,
+				structuredOutput
+			}), options.sanitizeOutput, {
+				providerId: id,
+				modelId: options.model
+			});
+			const parsedToolCalls = parseToolUseEnvelope(text);
+			const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, options.validateToolCalls);
+			const nativeToolRequests = openAIToolUseRequestsFromMessage(message);
+			const nativeToolCalls = nativeToolRequests.length === 0 ? void 0 : await validateToolCallRequests(nativeToolRequests, options.validateToolCalls);
+			const hasToolCallResult = promptToolCalls !== void 0 || nativeToolCalls !== void 0;
+			const toolCalls = [...promptToolCalls ?? [], ...nativeToolCalls ?? []];
+			const usage = normalizeUsage(body.usage);
+			const normalizedUsage = normalizeUsageToRunUsage(body.usage, options.pricing);
+			const sanitizedGatewayPolicy = sanitizedGatewayPolicyForPlan(mergedGatewayPolicy);
+			const gateway = id === "litellm" || mergedGatewayPolicy !== void 0 ? {
+				used: true,
+				requestedModel: options.model,
+				...observedModel !== void 0 ? { observedModel } : {},
+				...sanitizedGatewayPolicy !== void 0 ? { policy: sanitizedGatewayPolicy } : {}
+			} : void 0;
+			const finish = openAIFinishMetadata(choice, toolCalls);
+			return {
+				rawOutputs: sanitizedOutputs,
+				...usage !== void 0 ? { usage } : {},
+				normalizedUsage,
+				...hasToolCallResult ? { toolCalls } : {},
+				...gateway !== void 0 ? { gateway } : {},
+				...finish !== void 0 ? { finish } : {},
+				rawResponse: body
+			};
+		},
+		executeStream(request) {
+			return streamOpenAICompatibleResponse({
+				id,
+				model: options.model,
+				baseUrl,
+				fetchImpl,
+				request,
+				...options.apiKey !== void 0 ? { apiKey: options.apiKey } : {},
+				...options.gateway !== void 0 ? { providerGateway: options.gateway } : {},
+				...options.pricing !== void 0 ? { pricing: options.pricing } : {},
+				...options.sanitizeOutput !== void 0 ? { sanitizeOutput: options.sanitizeOutput } : {},
+				...options.validateToolCalls !== void 0 ? { validateToolCalls: options.validateToolCalls } : {}
+			});
+		}
+	};
+}
+async function* streamOpenAICompatibleResponse(input) {
+	const mergedGatewayPolicy = mergeGatewayPolicy(input.providerGateway, readGatewayPolicy(input.request.policy));
+	const metadata = gatewayPolicyToMetadata(mergedGatewayPolicy);
+	const streamBodyStr = JSON.stringify(createOpenAICompatibleRequestBody({
+		model: input.model,
+		request: input.request,
+		...metadata !== void 0 ? { metadata } : {},
+		stream: true
+	}));
+	assertNoPublicUrlEgress(input.request, input.id, streamBodyStr);
+	const response = await input.fetchImpl(`${input.baseUrl}/chat/completions`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			...input.apiKey !== void 0 ? { authorization: `Bearer ${input.apiKey}` } : {}
+		},
+		body: streamBodyStr,
+		...input.request.signal !== void 0 ? { signal: input.request.signal } : {}
+	});
+	if (!response.ok) throw new Error(`OpenAI-compatible provider failed with ${response.status}.`);
+	const textParts = [];
+	const rawChunks = [];
+	const nativeToolCalls = /* @__PURE__ */ new Map();
+	let usagePayload;
+	let observedModel;
+	let finishReason;
+	for await (const event of readSseEvents(response)) {
+		const data = event.data.trim();
+		if (data.length === 0) continue;
+		if (data === "[DONE]") break;
+		const chunk = parseJsonObject$2(data);
+		rawChunks.push(chunk);
+		const chunkObservedModel = observedModelFromResponse(chunk);
+		if (chunkObservedModel !== void 0) observedModel = chunkObservedModel;
+		if (isRecord$3(chunk) && chunk.usage !== void 0) usagePayload = chunk.usage;
+		for (const choice of streamChoices(chunk)) {
+			const choiceFinishReason = stringField(choice, "finish_reason");
+			if (choiceFinishReason !== void 0) finishReason = choiceFinishReason;
+			const delta = isRecord$3(choice.delta) ? choice.delta : {};
+			const content = typeof delta.content === "string" ? delta.content : void 0;
+			if (content !== void 0 && content.length > 0) {
+				textParts.push(content);
+				for (const output of input.request.outputs) yield {
+					kind: "text-delta",
+					output,
+					text: content
+				};
+			}
+			accumulateOpenAIToolCalls(nativeToolCalls, delta.tool_calls);
+		}
+	}
+	const text = textParts.join("");
+	const structuredOutput = input.request.nativeStructuredOutput === void 0 ? void 0 : parseJsonValue$1(text);
+	const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest$2({
+		outputs: input.request.outputs,
+		text,
+		structuredOutputRequest: input.request.nativeStructuredOutput,
+		structuredOutput
+	}), input.sanitizeOutput, {
+		providerId: input.id,
+		modelId: input.model
+	});
+	const parsedToolCalls = parseToolUseEnvelope(text);
+	const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, input.validateToolCalls);
+	const nativeToolRequests = openAIToolUseRequests(nativeToolCalls);
+	const nativeValidatedToolCalls = nativeToolRequests.length === 0 ? void 0 : await validateToolCallRequests(nativeToolRequests, input.validateToolCalls);
+	const toolCalls = [...promptToolCalls ?? [], ...nativeValidatedToolCalls ?? []];
+	const usage = normalizeUsage(usagePayload);
+	const normalizedUsage = normalizeUsageToRunUsage(usagePayload, input.pricing);
+	const sanitizedGatewayPolicy = sanitizedGatewayPolicyForPlan(mergedGatewayPolicy);
+	const gateway = input.id === "litellm" || input.id === "openrouter" || mergedGatewayPolicy !== void 0 ? {
+		used: true,
+		requestedModel: input.model,
+		...observedModel !== void 0 ? { observedModel } : {},
+		...sanitizedGatewayPolicy !== void 0 ? { policy: sanitizedGatewayPolicy } : {}
+	} : void 0;
+	const finish = finishMetadata$2({
+		reason: finishReason,
+		toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+	});
+	yield {
+		kind: "complete",
+		rawOutputs: sanitizedOutputs,
+		...usage !== void 0 ? { usage } : {},
+		normalizedUsage,
+		...toolCalls.length > 0 ? { toolCalls } : {},
+		...gateway !== void 0 ? { gateway } : {},
+		...finish !== void 0 ? { finish } : {},
+		rawResponse: {
+			kind: "openai-compatible-stream",
+			chunks: rawChunks
+		}
+	};
+}
+function firstOpenAIChoice(body) {
+	if (!isRecord$3(body) || !Array.isArray(body.choices)) return;
+	return body.choices.find(isRecord$3);
+}
+function openAIMessageFromChoice(choice) {
+	return choice !== void 0 && isRecord$3(choice.message) ? choice.message : void 0;
+}
+function openAIMessageText(message) {
+	if (message === void 0) return "";
+	if (typeof message.content === "string") return message.content;
+	if (Array.isArray(message.content)) return message.content.flatMap((part) => isRecord$3(part) && typeof part.text === "string" ? [part.text] : []).join("");
+	return "";
+}
+function openAIToolUseRequestsFromMessage(message) {
+	if (message === void 0 || !Array.isArray(message.tool_calls)) return [];
+	const calls = /* @__PURE__ */ new Map();
+	for (const [index, item] of message.tool_calls.entries()) {
+		if (!isRecord$3(item)) continue;
+		const current = { arguments: "" };
+		if (typeof item.id === "string") current.id = item.id;
+		if (isRecord$3(item.function)) {
+			if (typeof item.function.name === "string") current.name = item.function.name;
+			if (typeof item.function.arguments === "string") current.arguments = item.function.arguments;
+		}
+		calls.set(index, current);
+	}
+	return openAIToolUseRequests(calls);
+}
+function openAIStructuredOutputValue(request, message, text) {
+	if (request === void 0) return;
+	if (message !== void 0 && "parsed" in message) return message.parsed;
+	return parseJsonValue$1(text);
+}
+function rawOutputsForRequest$2(input) {
+	const rawOutputs = Object.fromEntries(input.outputs.map((name) => [name, input.text]));
+	if (input.structuredOutputRequest !== void 0 && input.structuredOutput !== void 0) rawOutputs[input.structuredOutputRequest.output] = input.structuredOutput;
+	return rawOutputs;
+}
+function parseJsonValue$1(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+}
+function openAIFinishMetadata(choice, toolCalls) {
+	return finishMetadata$2({
+		reason: stringField(choice, "finish_reason"),
+		toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+	});
+}
+function finishMetadata$2(input) {
+	const toolCallIds = input.toolCallIds.filter((id) => id.length > 0);
+	if (input.reason === void 0 && toolCallIds.length === 0) return;
+	return {
+		...input.reason !== void 0 ? { reason: input.reason } : {},
+		...toolCallIds.length > 0 ? { toolCallIds } : {}
+	};
+}
+function stringField(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+function parseJsonObject$2(data) {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid JSON.";
+		throw new Error(`OpenAI-compatible stream returned invalid JSON: ${message}`);
+	}
+}
+function streamChoices(chunk) {
+	if (!isRecord$3(chunk) || !Array.isArray(chunk.choices)) return [];
+	return chunk.choices.filter(isRecord$3);
+}
+function accumulateOpenAIToolCalls(calls, deltas) {
+	if (!Array.isArray(deltas)) return;
+	for (const delta of deltas) {
+		if (!isRecord$3(delta) || typeof delta.index !== "number") continue;
+		const current = calls.get(delta.index) ?? { arguments: "" };
+		if (typeof delta.id === "string") current.id = delta.id;
+		if (isRecord$3(delta.function)) {
+			if (typeof delta.function.name === "string") current.name = `${current.name ?? ""}${delta.function.name}`;
+			if (typeof delta.function.arguments === "string") current.arguments += delta.function.arguments;
+		}
+		calls.set(delta.index, current);
+	}
+}
+function openAIToolUseRequests(calls) {
+	return [...calls.entries()].sort(([left], [right]) => left - right).flatMap(([index, call]) => {
+		if (call.name === void 0) return [];
+		return [{
+			id: call.id ?? `tool-call-${index}`,
+			name: call.name,
+			args: parseToolArguments(call.arguments)
+		}];
+	});
+}
+function parseToolArguments(value) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return {};
+	try {
+		return JSON.parse(trimmed);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid JSON.";
+		throw new Error(`OpenAI-compatible stream returned invalid tool arguments: ${message}`);
+	}
+}
+/**
+* Phase 7 normalization: maps raw provider usage payloads (OpenAI's
+* `prompt_tokens`/`completion_tokens`, the Responses API's
+* `input_tokens`/`output_tokens`, or camelCase variants) to the shared
+* `Usage` shape. When `pricing` is supplied, `costUsd` is computed from
+* the normalized token counts. Otherwise `costUsd` is `null` so consumers
+* can distinguish "unmeasured" from "zero".
+*/
+function normalizeUsageToRunUsage(rawUsage, pricing) {
+	let promptTokens = 0;
+	let completionTokens = 0;
+	if (typeof rawUsage === "object" && rawUsage !== null) {
+		const record = rawUsage;
+		promptTokens = numberField$2(record, "prompt_tokens") ?? numberField$2(record, "input_tokens") ?? numberField$2(record, "inputTokens") ?? 0;
+		completionTokens = numberField$2(record, "completion_tokens") ?? numberField$2(record, "output_tokens") ?? numberField$2(record, "outputTokens") ?? 0;
+	}
+	let costUsd = null;
+	if (pricing !== void 0 && (pricing.inputPer1kTokens !== void 0 || pricing.outputPer1kTokens !== void 0)) costUsd = (pricing.inputPer1kTokens ?? 0) * promptTokens / 1e3 + (pricing.outputPer1kTokens ?? 0) * completionTokens / 1e3;
+	return {
+		promptTokens,
+		completionTokens,
+		costUsd
+	};
+}
+function normalizeUsage(usage) {
+	if (typeof usage !== "object" || usage === null) return;
+	const record = usage;
+	const inputTokens = numberField$2(record, "prompt_tokens") ?? numberField$2(record, "input_tokens");
+	const outputTokens = numberField$2(record, "completion_tokens") ?? numberField$2(record, "output_tokens");
+	const totalTokens = numberField$2(record, "total_tokens");
+	return {
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...outputTokens !== void 0 ? { outputTokens } : {},
+		...totalTokens !== void 0 ? { totalTokens } : {}
+	};
+}
+function numberField$2(record, key) {
+	const value = record[key];
+	return typeof value === "number" ? value : void 0;
+}
+/**
+* Phase 34 — D-12 — Emits a "capabilities.negotiation.fallback" RunEvent if
+* a sink is provided. The runId uses a synthetic value since negotiation
+* happens outside a run context.
+*
+* T-34-03-01: errorReason is produced by stringifyErr (message only, NOT
+* stack) to prevent apiKey leaking in error strings that include request headers.
+*/
+function emitFallbackEvent$1(sink, payload) {
+	if (sink === void 0) return;
+	sink(createRunEvent("capabilities.negotiation.fallback", {
+		runId: `negotiate-${payload.adapter}-${payload.modelId}`,
+		providerId: payload.adapter,
+		modelId: payload.modelId,
+		metadata: {
+			adapter: payload.adapter,
+			modelId: payload.modelId,
+			errorReason: payload.errorReason,
+			fallbackSource: payload.fallbackSource
+		}
+	}));
+}
+/**
+* Stringify an error for event metadata. Returns only the message (NOT the
+* stack) to prevent apiKey or sensitive header values from leaking into
+* event payloads via fetch errors that may embed the request init.
+* T-34-03-01 mitigation.
+*/
+function stringifyErr$3(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Phase 34 — QUIRK-02 / NEG-01 / NEG-02 — Merge an OpenAI /v1/models
+* sparse response with the Phase 33 registry.
+*
+* OpenAI's /models response is famously SPARSE per RESEARCH §Q2:
+* `{ id, object, created, owned_by }` only. No capabilities block.
+* The /models call confirms the model EXISTS in the user's org, but
+* tells us nothing about its capabilities. We source supports.* from
+* the Phase 33 registry instead.
+*
+* Source semantics per D-09:
+*   - "live" when the model id is found in the /models response
+*     (the id was verified to exist — useful signal for org membership)
+*   - "registry-fallback" when the model is NOT in the /models response
+*     (model not in org, or stale; emit fallback event)
+*
+* Anti-pattern warning (RESEARCH §Anti-patterns): DO NOT assume OpenAI
+* /v1/models returns capability flags. It doesn't. Only id/object/created/
+* owned_by are returned. Source supports.* ONLY from the registry.
+*/
+function mergeOpenAIModelsWithRegistry(modelId, body, emitFallback) {
+	const data = body?.data;
+	if ((Array.isArray(data) ? data.find((m) => typeof m === "object" && m !== null && m.id === modelId) : void 0) === void 0) {
+		emitFallback();
+		return synthesizeNegotiatedCapabilitiesFromRegistry("openai", modelId, "registry-fallback");
+	}
+	const registryProfile = getCapabilityProfile(`openai:${modelId}`);
+	if (registryProfile !== void 0) return mapProfileToNegotiatedCapabilities(registryProfile, "live");
+	return {
+		modelId,
+		contextWindow: 0,
+		supports: {
+			nativeToolCalling: false,
+			structuredOutputs: false,
+			parallelToolCalls: false,
+			extendedThinking: false,
+			streaming: true
+		},
+		knownFailureModes: [],
+		recommendedSanitizers: [],
+		source: "live"
+	};
+}
+/**
+* Phase 34 — QUIRK-02 / NEG-01 / NEG-02 — OpenAI provider factory.
+*
+* Extends the base OpenAI-compat factory with:
+*   1. `quirks: OpenAIQuirks` — verified per RESEARCH §Q6 OpenAI vocabulary.
+*   2. `negotiateCapabilities(modelId)` — queries OpenAI /v1/models GET with
+*      Authorization: Bearer header; SPARSE response; intersects with Phase 33
+*      registry for supports.* (per RESEARCH §Anti-patterns — don't assume
+*      OpenAI /v1/models returns capability flags, it doesn't).
+*
+* The negotiate() pattern mirrors Plan 34-02 (Anthropic thick reference):
+*   - Per-instance TTL cache (modelsCacheTtlMs, default 300_000ms)
+*   - Single-flight inflight coalescing with .finally cleanup (Pitfall 4)
+*   - Retry with [0, 200, 1000]ms backoff (modelsRetryCount, default 2)
+*   - 401/403 throws NegotiationAuthError (D-10: no retry, no fallback, no event)
+*   - 5xx/network/timeout falls back to registry with source: "registry-fallback"
+*   - emitFallbackEvent fires the "capabilities.negotiation.fallback" RunEvent
+*
+* SECURITY (T-34-03-07): inflight Map MUST use .finally cleanup to prevent
+* leak on rejection. Verifiable: grep `.finally` in this file.
+*/
+function createOpenAIProvider(options) {
+	const id = options.id ?? "openai";
+	const fetchImpl = options.fetch ?? fetch;
+	const baseUrl = (options.baseUrl ?? "https://api.openai.com").replace(/\/$/u, "");
+	const ttlMs = options.modelsCacheTtlMs ?? 3e5;
+	const retryCount = options.modelsRetryCount ?? 2;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	async function fetchAndNegotiate(modelId) {
+		const url = `${baseUrl}/v1/models`;
+		const headers = {
+			"accept": "application/json",
+			...options.apiKey !== void 0 ? { authorization: `Bearer ${options.apiKey}` } : {}
+		};
+		const attempts = retryCount + 1;
+		const backoffMs = [
+			0,
+			200,
+			1e3
+		];
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) {
+			if (i > 0) {
+				const delay = backoffMs[Math.min(i, backoffMs.length - 1)] ?? 1e3;
+				await new Promise((r) => setTimeout(r, delay));
+			}
+			try {
+				const resp = await fetchImpl(url, {
+					method: "GET",
+					headers,
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (resp.status === 401 || resp.status === 403) throw new NegotiationAuthError("openai", modelId, resp.status, `OpenAI /v1/models returned ${resp.status}: check apiKey config.`);
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				return mergeOpenAIModelsWithRegistry(modelId, await resp.json(), () => {
+					emitFallbackEvent$1(options.runEventSink, {
+						adapter: "openai",
+						modelId,
+						errorReason: "model not found in /v1/models response",
+						fallbackSource: "registry-fallback"
+					});
+				});
+			} catch (err) {
+				if (err instanceof NegotiationAuthError) throw err;
+				lastErr = err;
+			}
+		}
+		emitFallbackEvent$1(options.runEventSink, {
+			adapter: "openai",
+			modelId,
+			errorReason: stringifyErr$3(lastErr),
+			fallbackSource: "registry-fallback"
+		});
+		return synthesizeNegotiatedCapabilitiesFromRegistry("openai", modelId, "registry-fallback");
+	}
+	async function negotiate(modelId) {
+		const cached = cache.get(modelId);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.result;
+		const existing = inflight.get(modelId);
+		if (existing !== void 0) return existing;
+		const fetchPromise = (async () => {
+			try {
+				const result = await fetchAndNegotiate(modelId);
+				if (ttlMs > 0) cache.set(modelId, {
+					result,
+					expiresAt: Date.now() + ttlMs
+				});
+				return result;
+			} finally {
+				inflight.delete(modelId);
+			}
+		})();
+		inflight.set(modelId, fetchPromise);
+		return fetchPromise;
+	}
+	return {
+		...createOpenAICompatibleProvider({
+			...options,
+			id,
+			baseUrl
+		}),
+		quirks: {
+			supportsToolChoice: true,
+			parallelToolCalls: true,
+			structuredOutputs: true,
+			responseFormatHonored: true,
+			streamingDiverges: false,
+			strictModeSupported: true,
+			structuredOutputsTier2: true
+		},
+		negotiateCapabilities: negotiate
+	};
+}
+function createAISdkProvider(options) {
+	const id = options.id ?? "ai-sdk";
+	return {
+		id,
+		kind: "provider-adapter",
+		capabilities: [{
+			...defaultCapabilityForProvider(id),
+			modelId: options.model,
+			toolUse: true,
+			streaming: true
+		}],
+		execute: async (request) => {
+			const response = await options.generate({
+				task: request.task,
+				outputNames: request.outputs
+			});
+			const normalizedUsage = {
+				promptTokens: response.usage?.inputTokens ?? 0,
+				completionTokens: response.usage?.outputTokens ?? 0,
+				costUsd: null
+			};
+			return {
+				...response,
+				normalizedUsage
+			};
+		}
+	};
+}
+//#endregion
+//#region src/providers/anthropic.ts
+const DEFAULT_BASE_URL$1 = "https://api.anthropic.com";
+const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 2e3;
+const DEFAULT_MODELS_CACHE_TTL_MS = 3e5;
+const DEFAULT_MODELS_RETRY_COUNT = 2;
+/** D-11: Backoff schedule for transient /v1/models failures -- immediate, 200ms, 1s. */
+const MODELS_BACKOFF_MS = [
+	0,
+	200,
+	1e3
+];
+async function createAnthropicMessagesBody(input) {
+	const system = input.request.cacheSystemPrefix !== void 0 ? [{
+		type: "text",
+		text: input.request.cacheSystemPrefix,
+		cache_control: { type: "ephemeral" }
+	}] : "";
+	const content = await createAnthropicUserContent(input.request);
+	const nativeTools = anthropicToolDefinitions(input.request.nativeTools);
+	const structuredTool = anthropicStructuredOutputTool(input.request.nativeStructuredOutput);
+	const tools = [...nativeTools, ...structuredTool !== void 0 ? [structuredTool] : []];
+	const toolChoice = structuredTool !== void 0 ? {
+		type: "tool",
+		name: structuredTool.name
+	} : anthropicToolChoice(input.request.nativeToolChoice);
+	return {
+		body: {
+			model: input.model,
+			system,
+			messages: [{
+				role: "user",
+				content: content.blocks.length === 0 ? input.request.task : [...content.blocks, {
+					type: "text",
+					text: input.request.task
+				}]
+			}],
+			max_tokens: DEFAULT_MAX_TOKENS,
+			...input.stream === true ? { stream: true } : {},
+			...tools.length > 0 ? { tools } : {},
+			...toolChoice !== void 0 ? { tool_choice: toolChoice } : {}
+		},
+		usesFilesApi: content.usesFilesApi
+	};
+}
+function anthropicToolDefinitions(tools) {
+	return (tools ?? []).map((tool) => ({
+		name: tool.name,
+		...tool.description !== void 0 ? { description: tool.description } : {},
+		input_schema: standardSchemaToJsonSchema(tool.inputSchema)
+	}));
+}
+function anthropicToolChoice(choice) {
+	if (choice === void 0) return;
+	if (choice === "required") return { type: "any" };
+	if (choice === "auto" || choice === "none") return { type: choice };
+	return {
+		type: "tool",
+		name: choice.name
+	};
+}
+function anthropicStructuredOutputTool(request) {
+	if (request === void 0) return;
+	return {
+		name: anthropicStructuredOutputToolName(request),
+		description: `Return structured output for ${request.output}.`,
+		input_schema: standardSchemaToJsonSchema(request.schema)
+	};
+}
+async function createAnthropicUserContent(request) {
+	const blocks = [];
+	let usesFilesApi = false;
+	for (const inputArtifact of request.artifacts) {
+		if (inputArtifact.kind !== "image") continue;
+		const packaged = packagedPlanForArtifact(request, inputArtifact.id);
+		if (packaged === void 0) continue;
+		if (packaged.transport === "file-id") {
+			const fileId = anthropicFileId(inputArtifact);
+			if (fileId === void 0) continue;
+			blocks.push({
+				type: "image",
+				source: {
+					type: "file",
+					file_id: fileId
+				}
+			});
+			usesFilesApi = true;
+			continue;
+		}
+		if (packaged.transport === "url") {
+			const url = artifactHttpUrl(inputArtifact);
+			if (url === void 0) continue;
+			blocks.push({
+				type: "image",
+				source: {
+					type: "url",
+					url
+				}
+			});
+			continue;
+		}
+		if (packaged.transport === "base64" || packaged.transport === "inline") {
+			const data = await artifactBase64Data(inputArtifact);
+			if (data === void 0) continue;
+			blocks.push({
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: mediaTypeForArtifact(inputArtifact, "image/jpeg"),
+					data
+				}
+			});
+		}
+	}
+	return {
+		blocks,
+		usesFilesApi
+	};
+}
+function createAnthropicProvider(options) {
+	const id = options.id ?? "anthropic";
+	const fetchImpl = options.fetch ?? fetch;
+	const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL$1).replace(/\/$/u, "");
+	const anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
+	const ttlMs = options.modelsCacheTtlMs ?? DEFAULT_MODELS_CACHE_TTL_MS;
+	const retryCount = options.modelsRetryCount ?? DEFAULT_MODELS_RETRY_COUNT;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	/**
+	* D-12: Emits the `capabilities.negotiation.fallback` RunEvent via the
+	* consumer-supplied sink. If no sink is provided, this is a no-op.
+	*
+	* SECURITY (T-34-02-01): errorReason is derived from `err.message` ONLY --
+	* not `err.stack`, `err.toString()`, or any serialization that could include
+	* request headers (which carry the apiKey). `stringifyErr` enforces this.
+	*
+	* JSDoc synthetic runId: negotiate() runs outside of a Lattice run context
+	* (no ai.run() in scope). The runId `"negotiate-${id}-${modelId}"` is a
+	* synthetic value that scopes the event to this adapter instance + modelId.
+	* Consumers filtering on runId should treat "negotiate-" prefix as a signal
+	* that this event originated from capability negotiation, not a user-facing run.
+	*/
+	function emitFallbackEvent(payload) {
+		if (options.runEventSink === void 0) return;
+		const event = createRunEvent("capabilities.negotiation.fallback", {
+			runId: `negotiate-${id}-${payload.modelId}`,
+			providerId: id,
+			modelId: payload.modelId,
+			metadata: {
+				adapter: payload.adapter,
+				modelId: payload.modelId,
+				errorReason: payload.errorReason,
+				fallbackSource: payload.fallbackSource
+			}
+		});
+		options.runEventSink(event);
+	}
+	/**
+	* Pure error message extractor. Returns `err.message` for Error instances,
+	* `String(err)` for everything else. Deliberately does NOT include stack,
+	* headers, or other fields (T-34-02-01 mitigation).
+	*/
+	function stringifyErr(err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+	/**
+	* Merges a live /v1/models response body with the Phase 33 static registry
+	* profile for the given modelId. Called on HTTP 200 responses only.
+	*
+	* LENIENT PARSING (Pitfall 1): every field access uses optional chaining.
+	* Missing `capabilities.thinking` or other sub-fields default to false rather
+	* than throwing. This ensures forward-compatibility with future API shape changes.
+	*
+	* contextWindow policy: Anthropic's max_input_tokens is set to 0 in the fixture
+	* for models where it is unreliable. When 0, falls through to the registry profile's
+	* contextWindow (if present) or 0 as a final default (RESEARCH §Q1).
+	*/
+	function mergeAnthropicModelsWithRegistry(modelId, body) {
+		const found = body?.data?.find?.((m) => {
+			if (typeof m !== "object" || m === null) return false;
+			return m["id"] === modelId;
+		});
+		if (found === void 0) {
+			emitFallbackEvent({
+				adapter: "anthropic",
+				modelId,
+				errorReason: "model not found in /v1/models response",
+				fallbackSource: "registry-fallback"
+			});
+			return synthesizeNegotiatedCapabilitiesFromRegistry("anthropic", modelId, "registry-fallback");
+		}
+		const caps = found["capabilities"] ?? {};
+		const structuredOutputsSupported = caps["structured_outputs"]?.["supported"] === true;
+		const thinkingSupported = caps["thinking"]?.["supported"] === true;
+		const maxInputTokensRaw = found["max_input_tokens"];
+		const maxInputTokens = typeof maxInputTokensRaw === "number" && maxInputTokensRaw > 0 ? maxInputTokensRaw : void 0;
+		const registryProfile = getCapabilityProfile(`anthropic:${modelId}`);
+		const contextWindow = maxInputTokens ?? registryProfile?.contextWindow ?? 0;
+		const knownFailureModes = registryProfile?.knownFailureModes ?? [];
+		return {
+			modelId,
+			contextWindow,
+			supports: {
+				nativeToolCalling: true,
+				structuredOutputs: structuredOutputsSupported,
+				parallelToolCalls: true,
+				extendedThinking: thinkingSupported,
+				streaming: true
+			},
+			knownFailureModes,
+			recommendedSanitizers: getRecommendedSanitizers(knownFailureModes),
+			source: "live"
+		};
+	}
+	/**
+	* D-09 / D-10 / D-11: Core /v1/models fetch with retry-backoff, auth-error-throw,
+	* and transient-fallback. Called only once per modelId (inflight coalescing prevents
+	* concurrent duplicate fetches).
+	*
+	* URL shape: `${baseUrl}/v1/models?limit=1000` to page all models in one request.
+	* Headers per RESEARCH §Q1: x-api-key, anthropic-version, accept.
+	*/
+	async function fetchAndNegotiate(modelId) {
+		const url = `${baseUrl}/v1/models?limit=1000`;
+		const headers = {
+			"x-api-key": options.apiKey,
+			"anthropic-version": anthropicVersion,
+			"accept": "application/json"
+		};
+		const attempts = retryCount + 1;
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) {
+			const delayMs = MODELS_BACKOFF_MS[i] ?? MODELS_BACKOFF_MS[MODELS_BACKOFF_MS.length - 1];
+			if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+			try {
+				const resp = await fetchImpl(url, {
+					method: "GET",
+					headers,
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (resp.status === 401 || resp.status === 403) throw new NegotiationAuthError("anthropic", modelId, resp.status, `Anthropic /v1/models returned ${resp.status}: check apiKey config.`);
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				return mergeAnthropicModelsWithRegistry(modelId, await resp.json());
+			} catch (err) {
+				if (err instanceof NegotiationAuthError) throw err;
+				lastErr = err;
+			}
+		}
+		emitFallbackEvent({
+			adapter: "anthropic",
+			modelId,
+			errorReason: stringifyErr(lastErr),
+			fallbackSource: "registry-fallback"
+		});
+		return synthesizeNegotiatedCapabilitiesFromRegistry("anthropic", modelId, "registry-fallback");
+	}
+	/**
+	* D-07: Lazy expiry cache check + D-Q7: inflight coalescing.
+	*
+	* Cache check: stale entries are evicted lazily on read (no background setInterval
+	* -- library must not pin the Node event loop).
+	*
+	* Inflight coalescing: concurrent calls for the same modelId share one fetch
+	* Promise. Pitfall 4 mitigation: `.finally` block ALWAYS clears the inflight
+	* Map entry, even on rejection. This ensures that a rejected Promise doesn't
+	* "poison" the Map -- the next caller after all concurrent calls settle will
+	* trigger a fresh fetch attempt.
+	*/
+	async function negotiateCapabilities(modelId) {
+		const cached = cache.get(modelId);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.result;
+		const existing = inflight.get(modelId);
+		if (existing !== void 0) return existing;
+		const fetchPromise = (async () => {
+			try {
+				const result = await fetchAndNegotiate(modelId);
+				if (ttlMs > 0) cache.set(modelId, {
+					result,
+					expiresAt: ttlMs === Infinity ? Infinity : Date.now() + ttlMs
+				});
+				return result;
+			} finally {
+				inflight.delete(modelId);
+			}
+		})();
+		inflight.set(modelId, fetchPromise);
+		return fetchPromise;
+	}
+	return {
+		id,
+		kind: "provider-adapter",
+		capabilities: [{
+			...defaultCapabilityForProvider(id),
+			modelId: options.model,
+			fileTransport: [
+				"inline",
+				"json",
+				"url",
+				"base64",
+				"file-id",
+				"extracted-text",
+				"transcript"
+			],
+			streaming: true
+		}],
+		quirks: {
+			supportsToolChoice: true,
+			parallelToolCalls: true,
+			structuredOutputs: true,
+			responseFormatHonored: true,
+			streamingDiverges: false,
+			promptCachingSupported: true,
+			extendedThinkingSupported: true,
+			toolUseInputSchemaStrict: true
+		},
+		negotiateCapabilities,
+		async execute(request) {
+			const messagesBody = await createAnthropicMessagesBody({
+				model: options.model,
+				request
+			});
+			const bodyStr = JSON.stringify(messagesBody.body);
+			assertNoPublicUrlEgress(request, id, bodyStr);
+			const init = {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"x-api-key": options.apiKey,
+					"anthropic-version": anthropicVersion,
+					...messagesBody.usesFilesApi ? { "anthropic-beta": "files-api-2025-04-14" } : {}
+				},
+				body: bodyStr,
+				...request.signal !== void 0 ? { signal: request.signal } : {}
+			};
+			const response = await fetchImpl(`${baseUrl}/v1/messages`, init);
+			if (!response.ok) throw new Error(`Anthropic provider failed with ${response.status}.`);
+			const body = await response.json();
+			const text = anthropicTextFromContent(body.content);
+			const structuredOutput = anthropicStructuredOutputFromContent(body.content, request.nativeStructuredOutput);
+			const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest$1({
+				outputs: request.outputs,
+				text,
+				structuredOutputRequest: request.nativeStructuredOutput,
+				structuredOutput
+			}), options.sanitizeOutput, {
+				providerId: id,
+				modelId: options.model
+			});
+			const parsedToolCalls = parseToolUseEnvelope(text);
+			const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, options.validateToolCalls);
+			const nativeToolRequests = anthropicToolUseRequestsFromContent(body.content, request.nativeStructuredOutput);
+			const nativeToolCalls = nativeToolRequests.length === 0 ? void 0 : await validateToolCallRequests(nativeToolRequests, options.validateToolCalls);
+			const hasToolCallResult = promptToolCalls !== void 0 || nativeToolCalls !== void 0;
+			const toolCalls = [...promptToolCalls ?? [], ...nativeToolCalls ?? []];
+			const usage = normalizeAnthropicUsage(body.usage);
+			const normalizedUsage = normalizeAnthropicUsageToRunUsage(body.usage, options.pricing);
+			const finish = finishMetadata$1({
+				reason: typeof body.stop_reason === "string" ? body.stop_reason : void 0,
+				toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+			});
+			return {
+				rawOutputs: sanitizedOutputs,
+				...usage !== void 0 ? { usage } : {},
+				normalizedUsage,
+				...hasToolCallResult ? { toolCalls } : {},
+				...finish !== void 0 ? { finish } : {},
+				rawResponse: body
+			};
+		},
+		executeStream(request) {
+			return streamAnthropicResponse({
+				id,
+				model: options.model,
+				baseUrl,
+				apiKey: options.apiKey,
+				anthropicVersion,
+				fetchImpl,
+				request,
+				...options.pricing !== void 0 ? { pricing: options.pricing } : {},
+				...options.sanitizeOutput !== void 0 ? { sanitizeOutput: options.sanitizeOutput } : {},
+				...options.validateToolCalls !== void 0 ? { validateToolCalls: options.validateToolCalls } : {}
+			});
+		}
+	};
+}
+async function* streamAnthropicResponse(input) {
+	const messagesBody = await createAnthropicMessagesBody({
+		model: input.model,
+		request: input.request,
+		stream: true
+	});
+	const streamBodyStr = JSON.stringify(messagesBody.body);
+	assertNoPublicUrlEgress(input.request, input.id, streamBodyStr);
+	const response = await input.fetchImpl(`${input.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"x-api-key": input.apiKey,
+			"anthropic-version": input.anthropicVersion,
+			...messagesBody.usesFilesApi ? { "anthropic-beta": "files-api-2025-04-14" } : {}
+		},
+		body: streamBodyStr,
+		...input.request.signal !== void 0 ? { signal: input.request.signal } : {}
+	});
+	if (!response.ok) throw new Error(`Anthropic provider failed with ${response.status}.`);
+	const textParts = [];
+	const rawChunks = [];
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const nativeToolRequests = [];
+	let usagePayload;
+	let finishReason;
+	for await (const event of readSseEvents(response)) {
+		const data = event.data.trim();
+		if (data.length === 0) continue;
+		if (data === "[DONE]") break;
+		const chunk = parseJsonObject$1(data, "Anthropic");
+		rawChunks.push(event.event === void 0 ? chunk : {
+			event: event.event,
+			data: chunk
+		});
+		usagePayload = mergeAnthropicUsage(usagePayload, usageFromAnthropicChunk(chunk));
+		finishReason = anthropicStopReason(chunk) ?? finishReason;
+		const eventType = eventTypeFromAnthropicChunk(chunk) ?? event.event;
+		if (eventType === "content_block_start") {
+			startAnthropicToolBlock(toolBlocks, chunk);
+			continue;
+		}
+		if (eventType === "content_block_delta") {
+			const text = anthropicTextDelta(chunk);
+			if (text !== void 0 && text.length > 0) {
+				textParts.push(text);
+				for (const output of input.request.outputs) yield {
+					kind: "text-delta",
+					output,
+					text
+				};
+			}
+			appendAnthropicToolInput(toolBlocks, chunk);
+			continue;
+		}
+		if (eventType === "content_block_stop") {
+			const request = completeAnthropicToolBlock(toolBlocks, chunk);
+			if (request !== void 0) nativeToolRequests.push(request);
+		}
+	}
+	const text = textParts.join("");
+	const structuredToolName = anthropicStructuredOutputToolName(input.request.nativeStructuredOutput);
+	const providerToolRequests = structuredToolName === void 0 ? nativeToolRequests : nativeToolRequests.filter((request) => request.name !== structuredToolName);
+	const structuredOutput = structuredToolName === void 0 ? void 0 : nativeToolRequests.find((request) => request.name === structuredToolName)?.args;
+	const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest$1({
+		outputs: input.request.outputs,
+		text,
+		structuredOutputRequest: input.request.nativeStructuredOutput,
+		structuredOutput
+	}), input.sanitizeOutput, {
+		providerId: input.id,
+		modelId: input.model
+	});
+	const parsedToolCalls = parseToolUseEnvelope(text);
+	const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, input.validateToolCalls);
+	const nativeToolCalls = providerToolRequests.length === 0 ? void 0 : await validateToolCallRequests(providerToolRequests, input.validateToolCalls);
+	const toolCalls = [...promptToolCalls ?? [], ...nativeToolCalls ?? []];
+	const usage = normalizeAnthropicUsage(usagePayload);
+	const normalizedUsage = normalizeAnthropicUsageToRunUsage(usagePayload, input.pricing);
+	const finish = finishMetadata$1({
+		reason: finishReason,
+		toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+	});
+	yield {
+		kind: "complete",
+		rawOutputs: sanitizedOutputs,
+		...usage !== void 0 ? { usage } : {},
+		normalizedUsage,
+		...toolCalls.length > 0 ? { toolCalls } : {},
+		...finish !== void 0 ? { finish } : {},
+		rawResponse: {
+			kind: "anthropic-stream",
+			chunks: rawChunks
+		}
+	};
+}
+function parseJsonObject$1(data, providerName) {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid JSON.";
+		throw new Error(`${providerName} stream returned invalid JSON: ${message}`);
+	}
+}
+function eventTypeFromAnthropicChunk(chunk) {
+	return isRecord$2(chunk) && typeof chunk.type === "string" ? chunk.type : void 0;
+}
+function anthropicStopReason(chunk) {
+	if (!isRecord$2(chunk)) return;
+	if (typeof chunk.stop_reason === "string") return chunk.stop_reason;
+	if (isRecord$2(chunk.delta) && typeof chunk.delta.stop_reason === "string") return chunk.delta.stop_reason;
+}
+function usageFromAnthropicChunk(chunk) {
+	if (!isRecord$2(chunk)) return;
+	if (isRecord$2(chunk.usage)) return chunk.usage;
+	if (isRecord$2(chunk.message) && isRecord$2(chunk.message.usage)) return chunk.message.usage;
+}
+function mergeAnthropicUsage(current, next) {
+	if (!isRecord$2(next)) return current;
+	return {
+		...current ?? {},
+		...next
+	};
+}
+function anthropicIndex(chunk) {
+	return isRecord$2(chunk) && typeof chunk.index === "number" ? chunk.index : void 0;
+}
+function startAnthropicToolBlock(blocks, chunk) {
+	const index = anthropicIndex(chunk);
+	const contentBlock = isRecord$2(chunk) && isRecord$2(chunk.content_block) ? chunk.content_block : void 0;
+	if (index === void 0 || contentBlock === void 0 || contentBlock.type !== "tool_use" || typeof contentBlock.id !== "string" || typeof contentBlock.name !== "string") return;
+	blocks.set(index, {
+		id: contentBlock.id,
+		name: contentBlock.name,
+		jsonParts: []
+	});
+}
+function anthropicTextDelta(chunk) {
+	if (!isRecord$2(chunk) || !isRecord$2(chunk.delta)) return;
+	return chunk.delta.type === "text_delta" && typeof chunk.delta.text === "string" ? chunk.delta.text : void 0;
+}
+function appendAnthropicToolInput(blocks, chunk) {
+	const index = anthropicIndex(chunk);
+	if (index === void 0 || !isRecord$2(chunk) || !isRecord$2(chunk.delta)) return;
+	if (chunk.delta.type !== "input_json_delta" || typeof chunk.delta.partial_json !== "string") return;
+	blocks.get(index)?.jsonParts.push(chunk.delta.partial_json);
+}
+function completeAnthropicToolBlock(blocks, chunk) {
+	const index = anthropicIndex(chunk);
+	if (index === void 0) return;
+	const block = blocks.get(index);
+	if (block === void 0) return;
+	blocks.delete(index);
+	return {
+		id: block.id,
+		name: block.name,
+		args: parseAnthropicToolInput(block)
+	};
+}
+function parseAnthropicToolInput(block) {
+	const value = block.jsonParts.join("").trim();
+	if (value.length === 0) return {};
+	try {
+		return JSON.parse(value);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid JSON.";
+		throw new Error(`Anthropic stream returned invalid tool input JSON: ${message}`);
+	}
+}
+function anthropicTextFromContent(content) {
+	if (!Array.isArray(content)) return "";
+	return content.flatMap((block) => isRecord$2(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+}
+function anthropicToolUseRequestsFromContent(content, structuredOutput) {
+	if (!Array.isArray(content)) return [];
+	const structuredToolName = anthropicStructuredOutputToolName(structuredOutput);
+	return content.flatMap((block, index) => {
+		if (!isRecord$2(block) || block.type !== "tool_use" || typeof block.name !== "string" || block.name === structuredToolName) return [];
+		return [{
+			id: typeof block.id === "string" ? block.id : `anthropic-tool-use-${index}`,
+			name: block.name,
+			args: block.input ?? {}
+		}];
+	});
+}
+function anthropicStructuredOutputFromContent(content, request) {
+	const toolName = anthropicStructuredOutputToolName(request);
+	if (toolName === void 0 || !Array.isArray(content)) return;
+	const block = content.find((item) => isRecord$2(item) && item.type === "tool_use" && item.name === toolName && "input" in item);
+	return isRecord$2(block) ? block.input : void 0;
+}
+function anthropicStructuredOutputToolName(request) {
+	if (request === void 0) return;
+	return sanitizeToolName(request.name ?? `lattice_${request.output}`);
+}
+function sanitizeToolName(name) {
+	const sanitized = name.replace(/[^A-Za-z0-9_-]/gu, "_").slice(0, 64);
+	return sanitized.length > 0 ? sanitized : "lattice_output";
+}
+function rawOutputsForRequest$1(input) {
+	const rawOutputs = Object.fromEntries(input.outputs.map((name) => [name, input.text]));
+	if (input.structuredOutputRequest !== void 0 && input.structuredOutput !== void 0) rawOutputs[input.structuredOutputRequest.output] = input.structuredOutput;
+	return rawOutputs;
+}
+function finishMetadata$1(input) {
+	const toolCallIds = input.toolCallIds.filter((id) => id.length > 0);
+	if (input.reason === void 0 && toolCallIds.length === 0) return;
+	return {
+		...input.reason !== void 0 ? { reason: input.reason } : {},
+		...toolCallIds.length > 0 ? { toolCallIds } : {}
+	};
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Anthropic uses `input_tokens` / `output_tokens` (not OpenAI's
+* `prompt_tokens` / `completion_tokens`). This helper maps to Lattice's
+* `Usage` shape and applies pricing when supplied (Phase 7 pattern).
+*/
+function normalizeAnthropicUsageToRunUsage(rawUsage, pricing) {
+	let promptTokens = 0;
+	let completionTokens = 0;
+	if (typeof rawUsage === "object" && rawUsage !== null) {
+		const record = rawUsage;
+		promptTokens = numberField$1(record, "input_tokens") ?? numberField$1(record, "inputTokens") ?? 0;
+		completionTokens = numberField$1(record, "output_tokens") ?? numberField$1(record, "outputTokens") ?? 0;
+	}
+	let costUsd = null;
+	if (pricing !== void 0 && (pricing.inputPer1kTokens !== void 0 || pricing.outputPer1kTokens !== void 0)) costUsd = (pricing.inputPer1kTokens ?? 0) * promptTokens / 1e3 + (pricing.outputPer1kTokens ?? 0) * completionTokens / 1e3;
+	return {
+		promptTokens,
+		completionTokens,
+		costUsd
+	};
+}
+function normalizeAnthropicUsage(usage) {
+	if (typeof usage !== "object" || usage === null) return;
+	const record = usage;
+	const inputTokens = numberField$1(record, "input_tokens");
+	const outputTokens = numberField$1(record, "output_tokens");
+	const totalTokens = inputTokens !== void 0 && outputTokens !== void 0 ? inputTokens + outputTokens : void 0;
+	return {
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...outputTokens !== void 0 ? { outputTokens } : {},
+		...totalTokens !== void 0 ? { totalTokens } : {}
+	};
+}
+function numberField$1(record, key) {
+	const value = record[key];
+	return typeof value === "number" ? value : void 0;
+}
+//#endregion
+//#region src/providers/fake.ts
+const DEFAULT_FAKE_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	costUsd: null
+};
+function createFakeProvider(options = {}) {
+	const id = options.id ?? "fake";
+	const modelId = options.modelId ?? `${id}:deterministic`;
+	const defaultCapability = {
+		...defaultCapabilityForProvider(id),
+		modelId,
+		inputModalities: [
+			"text",
+			"json",
+			"image",
+			"audio",
+			"document",
+			"file",
+			"url",
+			"tool"
+		],
+		outputModalities: ["text", "json"],
+		toolUse: true
+	};
+	return {
+		id,
+		kind: "provider-adapter",
+		capabilities: options.capabilities ?? [defaultCapability],
+		async execute(request) {
+			const baseResponse = typeof options.response === "function" ? await options.response(request) : options.response;
+			if (baseResponse !== void 0) return baseResponse.normalizedUsage !== void 0 ? baseResponse : {
+				...baseResponse,
+				normalizedUsage: { ...DEFAULT_FAKE_USAGE }
+			};
+			return {
+				rawOutputs: Object.fromEntries(request.outputs.map((name) => [name, defaultOutputForName(name)])),
+				...options.artifacts !== void 0 ? { artifactRefs: options.artifacts } : {},
+				normalizedUsage: { ...DEFAULT_FAKE_USAGE }
+			};
+		}
+	};
+}
+function defaultOutputForName(name) {
+	if (/action|json|data|decision/u.test(name)) return {
+		kind: "clarify",
+		reason: "fake provider default structured response"
+	};
+	if (/citations|evidence/u.test(name)) return [];
+	if (/generated|artifacts/u.test(name)) return [];
+	return `Fake response for ${name}.`;
+}
+//#endregion
+//#region src/providers/gemini.ts
+const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+const DEFAULT_MAX_OUTPUT_TOKENS = 2e3;
+const DEFAULT_TEMPERATURE = .7;
+const DEFAULT_TOP_P = .9;
+/**
+* 4 HARM_CATEGORY entries at BLOCK_NONE (FSB convention mirrored from
+* `extension/ai/universal-provider.js:255-272`). If Google restricts
+* BLOCK_NONE in the future, that is a re-spec concern, not a Phase 4
+* design defect (CONTEXT.md Specific Ideas note).
+*/
+const SAFETY_SETTINGS = [
+	{
+		category: "HARM_CATEGORY_HARASSMENT",
+		threshold: "BLOCK_NONE"
+	},
+	{
+		category: "HARM_CATEGORY_HATE_SPEECH",
+		threshold: "BLOCK_NONE"
+	},
+	{
+		category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+		threshold: "BLOCK_NONE"
+	},
+	{
+		category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+		threshold: "BLOCK_NONE"
+	}
+];
+/**
+* Phase 34 — D-03 — Gemini quirks block. Values verified against
+* Gemini API documentation and gemini.ts:50-55 (safety settings) behavior.
+*
+* CITED: https://ai.google.dev/api/generate-content#v1beta.GenerationConfig
+*   - responseSchemaSupported: gemini-1.5-pro+ and gemini-2.x
+*   - safetySettingsConfigurable: verified in gemini.ts:50-55
+*   - systemInstructionSupported: gemini-1.5+ systemInstruction field
+*/
+const GEMINI_QUIRKS = {
+	supportsToolChoice: true,
+	parallelToolCalls: true,
+	structuredOutputs: true,
+	responseFormatHonored: true,
+	streamingDiverges: false,
+	responseSchemaSupported: true,
+	safetySettingsConfigurable: true,
+	systemInstructionSupported: true
+};
+async function createGeminiGenerateContentBody(request) {
+	const parts = await createGeminiUserParts(request);
+	const functionDeclarations = geminiFunctionDeclarations(request.nativeTools);
+	const toolConfig = geminiToolConfig(request.nativeToolChoice);
+	const structuredOutputConfig = geminiStructuredOutputConfig(request.nativeStructuredOutput);
+	return {
+		contents: [{
+			role: "user",
+			parts
+		}],
+		generationConfig: {
+			temperature: DEFAULT_TEMPERATURE,
+			topP: DEFAULT_TOP_P,
+			maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS,
+			...structuredOutputConfig !== void 0 ? structuredOutputConfig : {}
+		},
+		safetySettings: SAFETY_SETTINGS,
+		...functionDeclarations.length > 0 ? { tools: [{ functionDeclarations }] } : {},
+		...toolConfig !== void 0 ? { toolConfig } : {}
+	};
+}
+function geminiFunctionDeclarations(tools) {
+	return (tools ?? []).map((tool) => ({
+		name: tool.name,
+		...tool.description !== void 0 ? { description: tool.description } : {},
+		parameters: standardSchemaToJsonSchema(tool.inputSchema)
+	}));
+}
+function geminiToolConfig(choice) {
+	if (choice === void 0) return;
+	if (choice === "auto") return { functionCallingConfig: { mode: "AUTO" } };
+	if (choice === "none") return { functionCallingConfig: { mode: "NONE" } };
+	if (choice === "required") return { functionCallingConfig: { mode: "ANY" } };
+	return { functionCallingConfig: {
+		mode: "ANY",
+		allowedFunctionNames: [choice.name]
+	} };
+}
+function geminiStructuredOutputConfig(request) {
+	if (request === void 0) return;
+	return {
+		responseMimeType: "application/json",
+		responseSchema: standardSchemaToJsonSchema(request.schema)
+	};
+}
+async function createGeminiUserParts(request) {
+	const parts = [{ text: request.task }];
+	for (const inputArtifact of request.artifacts) {
+		if (!isGeminiMediaArtifact(inputArtifact.kind)) continue;
+		const packaged = packagedPlanForArtifact(request, inputArtifact.id);
+		if (packaged === void 0) continue;
+		if (packaged.transport === "file-id") {
+			const fileUri = geminiFileUri(inputArtifact);
+			if (fileUri === void 0) continue;
+			parts.push({ fileData: {
+				mimeType: mediaTypeForArtifact(inputArtifact, fallbackGeminiMimeType(inputArtifact.kind)),
+				fileUri
+			} });
+			continue;
+		}
+		if (packaged.transport === "url") {
+			const fileUri = artifactHttpUrl(inputArtifact);
+			if (fileUri === void 0) continue;
+			parts.push({ fileData: {
+				mimeType: mediaTypeForArtifact(inputArtifact, fallbackGeminiMimeType(inputArtifact.kind)),
+				fileUri
+			} });
+			continue;
+		}
+		if (packaged.transport === "base64" || packaged.transport === "inline") {
+			const data = await artifactBase64Data(inputArtifact);
+			if (data === void 0) continue;
+			parts.push({ inlineData: {
+				mimeType: mediaTypeForArtifact(inputArtifact, fallbackGeminiMimeType(inputArtifact.kind)),
+				data
+			} });
+		}
+	}
+	return parts;
+}
+function isGeminiMediaArtifact(kind) {
+	return kind === "image" || kind === "audio" || kind === "video";
+}
+function fallbackGeminiMimeType(kind) {
+	switch (kind) {
+		case "image": return "image/jpeg";
+		case "audio": return "audio/mpeg";
+		case "video": return "video/mp4";
+	}
+}
+function geminiGenerateContentUrl(input) {
+	const method = input.stream === true ? "streamGenerateContent" : "generateContent";
+	const params = new URLSearchParams({ key: input.apiKey });
+	if (input.stream === true) params.set("alt", "sse");
+	const encodedModel = encodeURIComponent(input.model);
+	return `${input.baseUrl}/v1beta/models/${encodedModel}:${method}?${params.toString()}`;
+}
+/**
+* Phase 34 — D-03 / D-05..D-12 — Extended Gemini provider factory.
+*
+* Returns a `ProviderAdapter` narrowed to expose:
+*   - `quirks: GeminiQuirks` — static adapter capability flags
+*   - `negotiateCapabilities(modelId)` — live /v1beta/models fetch with medium-thick
+*     derivation (inputTokenLimit + thinking + supportedGenerationMethods from upstream)
+*     intersected with Phase 33 registry; TTL cache + inflight coalescing + retry +
+*     auth-throw + transient-fallback + event.
+*
+* NOTE on auth strategy (T-34-04-01): negotiate() uses x-goog-api-key HEADER
+* (preferred per RESEARCH §Q3 -- avoids leaking the key in server-side logs that
+* capture URL query strings). The existing execute() path uses ?key= query string
+* and is NOT changed by Phase 34 (out-of-scope migration).
+*/
+function createGeminiProvider(options) {
+	const id = options.id ?? "gemini";
+	const fetchImpl = options.fetch ?? fetch;
+	const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/u, "");
+	const ttlMs = options.modelsCacheTtlMs ?? 3e5;
+	const retryCount = options.modelsRetryCount ?? 2;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	/**
+	* D-07 lazy expiry + Q7 inflight coalescing + Pitfall 4 .finally cleanup.
+	* Public surface: `adapter.negotiateCapabilities(modelId)`.
+	*/
+	async function negotiate(modelId) {
+		const cached = cache.get(modelId);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.result;
+		const existing = inflight.get(modelId);
+		if (existing !== void 0) return existing;
+		const fetchPromise = (async () => {
+			try {
+				const result = await fetchAndNegotiate(modelId);
+				if (ttlMs > 0) cache.set(modelId, {
+					result,
+					expiresAt: Date.now() + ttlMs
+				});
+				return result;
+			} finally {
+				inflight.delete(modelId);
+			}
+		})();
+		inflight.set(modelId, fetchPromise);
+		return fetchPromise;
+	}
+	/**
+	* Phase 34 — D-09..D-11 — Fetches /v1beta/models and merges with registry.
+	*
+	* URL: ${baseUrl}/v1beta/models (NOT /v1/models -- Gemini uses /v1beta/ prefix)
+	* Auth: x-goog-api-key HEADER (preferred per RESEARCH §Q3 -- NOT ?key= query-string;
+	*   avoids leaking the key in server-side log captures of request URLs).
+	* Retry: [0ms, 200ms, 1000ms] backoff on transient errors (D-11).
+	* Auth error (401/403): throws NegotiationAuthError (D-10, no fallback).
+	* Transient error (5xx/network): falls back to registry with "registry-fallback" (D-09).
+	*/
+	async function fetchAndNegotiate(modelId) {
+		const url = `${baseUrl}/v1beta/models`;
+		const headers = {
+			"x-goog-api-key": options.apiKey,
+			"accept": "application/json"
+		};
+		const attempts = retryCount + 1;
+		const backoffSchedule = [
+			0,
+			200,
+			1e3
+		];
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) {
+			const delay = backoffSchedule[i] ?? 1e3;
+			if (delay > 0) await new Promise((r) => setTimeout(r, delay));
+			try {
+				const resp = await fetchImpl(url, {
+					method: "GET",
+					headers,
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (resp.status === 401 || resp.status === 403) throw new NegotiationAuthError("gemini", modelId, resp.status, `Gemini /v1beta/models returned ${resp.status}: check apiKey config.`);
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				return mergeGeminiModelsWithRegistry(modelId, await resp.json());
+			} catch (err) {
+				if (err instanceof NegotiationAuthError) throw err;
+				lastErr = err;
+			}
+		}
+		emitFallbackEvent({
+			adapter: "gemini",
+			modelId,
+			errorReason: stringifyErr$2(lastErr),
+			fallbackSource: "registry-fallback"
+		});
+		return synthesizeNegotiatedCapabilitiesFromRegistry("gemini", modelId, "registry-fallback");
+	}
+	/**
+	* MEDIUM-THICK derivation: consumes upstream truth from Gemini /v1beta/models
+	* where available (inputTokenLimit -> contextWindow, thinking -> extendedThinking,
+	* supportedGenerationMethods -> streaming + nativeToolCalling) and falls back
+	* to registry for the rest (knownFailureModes, recommendedSanitizers).
+	*
+	* Lenient parsing per Pitfall 1: all field accesses use optional chaining.
+	* Missing `thinking` field does not crash -- defaults to false.
+	*/
+	function mergeGeminiModelsWithRegistry(modelId, body) {
+		const models = body?.models;
+		const found = Array.isArray(models) ? models.find((m) => {
+			const rec = m;
+			return rec?.name === `models/${modelId}` || rec?.baseModelId === modelId || rec?.name === modelId;
+		}) : void 0;
+		if (found === void 0) {
+			emitFallbackEvent({
+				adapter: "gemini",
+				modelId,
+				errorReason: "model not found in /v1beta/models response",
+				fallbackSource: "registry-fallback"
+			});
+			return synthesizeNegotiatedCapabilitiesFromRegistry("gemini", modelId, "registry-fallback");
+		}
+		const foundRec = found;
+		const registryProfile = getCapabilityProfile(`gemini:${modelId}`);
+		const contextWindow = typeof foundRec.inputTokenLimit === "number" && foundRec.inputTokenLimit > 0 ? foundRec.inputTokenLimit : registryProfile?.contextWindow ?? 0;
+		const extendedThinking = foundRec.thinking === true;
+		const methods = Array.isArray(foundRec.supportedGenerationMethods) ? foundRec.supportedGenerationMethods.map(String) : [];
+		const streaming = methods.includes("streamGenerateContent");
+		const nativeToolCalling = methods.includes("generateContent") || methods.length > 0;
+		const structuredOutputs = true;
+		const parallelToolCalls = true;
+		const knownFailureModes = registryProfile?.knownFailureModes ?? [];
+		const recommendedSanitizers = getRecommendedSanitizers(knownFailureModes);
+		return {
+			modelId,
+			contextWindow,
+			supports: {
+				nativeToolCalling,
+				structuredOutputs,
+				parallelToolCalls,
+				extendedThinking,
+				streaming
+			},
+			knownFailureModes,
+			recommendedSanitizers,
+			source: "live"
+		};
+	}
+	/**
+	* D-12: Emit capabilities.negotiation.fallback RunEvent via the optional sink.
+	* SECURITY (T-34-04-02): stringifyErr extracts err.message only -- NOT err.stack
+	* or JSON.stringify(headers), so the apiKey cannot leak into the event payload.
+	* Synthetic runId pattern: negotiate happens outside a run; documented here.
+	*/
+	function emitFallbackEvent(payload) {
+		if (options.runEventSink === void 0) return;
+		const event = createRunEvent("capabilities.negotiation.fallback", {
+			runId: `negotiate-gemini-${payload.modelId}`,
+			providerId: id,
+			modelId: payload.modelId,
+			metadata: {
+				adapter: payload.adapter,
+				modelId: payload.modelId,
+				errorReason: payload.errorReason,
+				fallbackSource: payload.fallbackSource
+			}
+		});
+		options.runEventSink(event);
+	}
+	return {
+		id,
+		kind: "provider-adapter",
+		capabilities: [{
+			...defaultCapabilityForProvider(id),
+			modelId: options.model,
+			fileTransport: [
+				"inline",
+				"json",
+				"url",
+				"base64",
+				"file-id",
+				"extracted-text",
+				"transcript"
+			],
+			streaming: true
+		}],
+		quirks: GEMINI_QUIRKS,
+		negotiateCapabilities: negotiate,
+		async execute(request) {
+			const requestBody = await createGeminiGenerateContentBody(request);
+			const bodyStr = JSON.stringify(requestBody);
+			assertNoPublicUrlEgress(request, id, bodyStr);
+			const init = {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: bodyStr,
+				...request.signal !== void 0 ? { signal: request.signal } : {}
+			};
+			const response = await fetchImpl(geminiGenerateContentUrl({
+				baseUrl,
+				model: options.model,
+				apiKey: options.apiKey
+			}), init);
+			if (!response.ok) throw new Error(`Gemini provider failed with ${response.status}.`);
+			const body = await response.json();
+			if (!Array.isArray(body.candidates) || body.candidates.length === 0) throw new Error("Gemini provider returned no candidates.");
+			const text = geminiTextFromBody(body);
+			const structuredOutput = request.nativeStructuredOutput === void 0 ? void 0 : parseJsonValue(text);
+			const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest({
+				outputs: request.outputs,
+				text,
+				structuredOutputRequest: request.nativeStructuredOutput,
+				structuredOutput
+			}), options.sanitizeOutput, {
+				providerId: id,
+				modelId: options.model
+			});
+			const parsedToolCalls = parseToolUseEnvelope(text);
+			const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, options.validateToolCalls);
+			const nativeToolRequests = geminiParts(body).flatMap(({ part, candidateIndex, partIndex }) => {
+				const request = geminiFunctionCallRequest(part, candidateIndex, partIndex);
+				return request === void 0 ? [] : [request];
+			});
+			const nativeToolCalls = nativeToolRequests.length === 0 ? void 0 : await validateToolCallRequests(nativeToolRequests, options.validateToolCalls);
+			const hasToolCallResult = promptToolCalls !== void 0 || nativeToolCalls !== void 0;
+			const toolCalls = [...promptToolCalls ?? [], ...nativeToolCalls ?? []];
+			const usage = normalizeGeminiUsage(body.usageMetadata);
+			const normalizedUsage = normalizeGeminiUsageToRunUsage(body.usageMetadata, options.pricing);
+			const finish = finishMetadata({
+				reason: geminiFinishReason(body),
+				toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+			});
+			return {
+				rawOutputs: sanitizedOutputs,
+				...usage !== void 0 ? { usage } : {},
+				normalizedUsage,
+				...hasToolCallResult ? { toolCalls } : {},
+				...finish !== void 0 ? { finish } : {},
+				rawResponse: body
+			};
+		},
+		executeStream(request) {
+			return streamGeminiResponse({
+				id,
+				model: options.model,
+				baseUrl,
+				apiKey: options.apiKey,
+				fetchImpl,
+				request,
+				...options.pricing !== void 0 ? { pricing: options.pricing } : {},
+				...options.sanitizeOutput !== void 0 ? { sanitizeOutput: options.sanitizeOutput } : {},
+				...options.validateToolCalls !== void 0 ? { validateToolCalls: options.validateToolCalls } : {}
+			});
+		}
+	};
+}
+async function* streamGeminiResponse(input) {
+	const requestBody = await createGeminiGenerateContentBody(input.request);
+	const streamBodyStr = JSON.stringify(requestBody);
+	assertNoPublicUrlEgress(input.request, input.id, streamBodyStr);
+	const response = await input.fetchImpl(geminiGenerateContentUrl({
+		baseUrl: input.baseUrl,
+		model: input.model,
+		apiKey: input.apiKey,
+		stream: true
+	}), {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: streamBodyStr,
+		...input.request.signal !== void 0 ? { signal: input.request.signal } : {}
+	});
+	if (!response.ok) throw new Error(`Gemini provider failed with ${response.status}.`);
+	const textParts = [];
+	const rawChunks = [];
+	const nativeToolRequests = [];
+	let usagePayload;
+	let finishReason;
+	for await (const event of readSseEvents(response)) {
+		const data = event.data.trim();
+		if (data.length === 0) continue;
+		if (data === "[DONE]") break;
+		const chunk = parseJsonObject(data, "Gemini");
+		rawChunks.push(chunk);
+		const usage = geminiUsageMetadata(chunk);
+		if (usage !== void 0) usagePayload = usage;
+		finishReason = geminiFinishReason(chunk) ?? finishReason;
+		for (const { part, candidateIndex, partIndex } of geminiParts(chunk)) {
+			if (typeof part.text === "string" && part.text.length > 0) {
+				textParts.push(part.text);
+				for (const output of input.request.outputs) yield {
+					kind: "text-delta",
+					output,
+					text: part.text
+				};
+			}
+			const toolRequest = geminiFunctionCallRequest(part, candidateIndex, partIndex);
+			if (toolRequest !== void 0) nativeToolRequests.push(toolRequest);
+		}
+	}
+	const text = textParts.join("");
+	const structuredOutput = input.request.nativeStructuredOutput === void 0 ? void 0 : parseJsonValue(text);
+	const sanitizedOutputs = await applyOutputSanitizers(rawOutputsForRequest({
+		outputs: input.request.outputs,
+		text,
+		structuredOutputRequest: input.request.nativeStructuredOutput,
+		structuredOutput
+	}), input.sanitizeOutput, {
+		providerId: input.id,
+		modelId: input.model
+	});
+	const parsedToolCalls = parseToolUseEnvelope(text);
+	const promptToolCalls = parsedToolCalls === null ? void 0 : await validateToolCallRequests(parsedToolCalls, input.validateToolCalls);
+	const nativeToolCalls = nativeToolRequests.length === 0 ? void 0 : await validateToolCallRequests(nativeToolRequests, input.validateToolCalls);
+	const toolCalls = [...promptToolCalls ?? [], ...nativeToolCalls ?? []];
+	const usage = normalizeGeminiUsage(usagePayload);
+	const normalizedUsage = normalizeGeminiUsageToRunUsage(usagePayload, input.pricing);
+	const finish = finishMetadata({
+		reason: finishReason,
+		toolCallIds: toolCalls.map((toolCall) => toolCall.id)
+	});
+	yield {
+		kind: "complete",
+		rawOutputs: sanitizedOutputs,
+		...usage !== void 0 ? { usage } : {},
+		normalizedUsage,
+		...toolCalls.length > 0 ? { toolCalls } : {},
+		...finish !== void 0 ? { finish } : {},
+		rawResponse: {
+			kind: "gemini-stream",
+			chunks: rawChunks
+		}
+	};
+}
+function parseJsonObject(data, providerName) {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Invalid JSON.";
+		throw new Error(`${providerName} stream returned invalid JSON: ${message}`);
+	}
+}
+function geminiUsageMetadata(chunk) {
+	return isRecord$1(chunk) ? chunk.usageMetadata : void 0;
+}
+function geminiFinishReason(chunk) {
+	if (!isRecord$1(chunk) || !Array.isArray(chunk.candidates)) return;
+	for (const candidate of chunk.candidates) if (isRecord$1(candidate) && typeof candidate.finishReason === "string") return candidate.finishReason;
+}
+function geminiTextFromBody(body) {
+	return geminiParts(body).flatMap(({ part }) => typeof part.text === "string" ? [part.text] : []).join("");
+}
+function geminiParts(chunk) {
+	if (!isRecord$1(chunk) || !Array.isArray(chunk.candidates)) return [];
+	return chunk.candidates.flatMap((candidate, candidateIndex) => {
+		if (!isRecord$1(candidate) || !isRecord$1(candidate.content)) return [];
+		const parts = candidate.content.parts;
+		if (!Array.isArray(parts)) return [];
+		return parts.flatMap((part, partIndex) => isRecord$1(part) ? [{
+			part,
+			candidateIndex,
+			partIndex
+		}] : []);
+	});
+}
+function geminiFunctionCallRequest(part, candidateIndex, partIndex) {
+	if (!isRecord$1(part.functionCall)) return;
+	const name = part.functionCall.name;
+	if (typeof name !== "string") return;
+	return {
+		id: `gemini-function-call-${candidateIndex}-${partIndex}`,
+		name,
+		args: part.functionCall.args ?? {}
+	};
+}
+function parseJsonValue(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return;
+	}
+}
+function rawOutputsForRequest(input) {
+	const rawOutputs = Object.fromEntries(input.outputs.map((name) => [name, input.text]));
+	if (input.structuredOutputRequest !== void 0 && input.structuredOutput !== void 0) rawOutputs[input.structuredOutputRequest.output] = input.structuredOutput;
+	return rawOutputs;
+}
+function finishMetadata(input) {
+	const toolCallIds = input.toolCallIds.filter((id) => id.length > 0);
+	if (input.reason === void 0 && toolCallIds.length === 0) return;
+	return {
+		...input.reason !== void 0 ? { reason: input.reason } : {},
+		...toolCallIds.length > 0 ? { toolCallIds } : {}
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Gemini uses `usageMetadata.promptTokenCount` / `candidatesTokenCount` /
+* `totalTokenCount` (NOT OpenAI's `prompt_tokens` / `completion_tokens`).
+* This helper maps to Lattice's `Usage` shape and applies pricing when supplied.
+*/
+function normalizeGeminiUsageToRunUsage(rawUsage, pricing) {
+	let promptTokens = 0;
+	let completionTokens = 0;
+	if (typeof rawUsage === "object" && rawUsage !== null) {
+		const record = rawUsage;
+		promptTokens = numberField(record, "promptTokenCount") ?? 0;
+		completionTokens = numberField(record, "candidatesTokenCount") ?? 0;
+	}
+	let costUsd = null;
+	if (pricing !== void 0 && (pricing.inputPer1kTokens !== void 0 || pricing.outputPer1kTokens !== void 0)) costUsd = (pricing.inputPer1kTokens ?? 0) * promptTokens / 1e3 + (pricing.outputPer1kTokens ?? 0) * completionTokens / 1e3;
+	return {
+		promptTokens,
+		completionTokens,
+		costUsd
+	};
+}
+function normalizeGeminiUsage(usage) {
+	if (typeof usage !== "object" || usage === null) return;
+	const record = usage;
+	const inputTokens = numberField(record, "promptTokenCount");
+	const outputTokens = numberField(record, "candidatesTokenCount");
+	const totalTokens = numberField(record, "totalTokenCount");
+	return {
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...outputTokens !== void 0 ? { outputTokens } : {},
+		...totalTokens !== void 0 ? { totalTokens } : {}
+	};
+}
+function numberField(record, key) {
+	const value = record[key];
+	return typeof value === "number" ? value : void 0;
+}
+/**
+* T-34-04-02: Returns err.message only -- NOT err.stack (which could include
+* headers or the apiKey via a fetch rejection), NOT JSON.stringify(err).
+*/
+function stringifyErr$2(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/providers/litellm.ts
+const DEFAULT_LITELLM_BASE_URL = "http://localhost:4000";
+function createLiteLLMProvider(options) {
+	const resolvedId = options.id ?? "litellm";
+	const resolvedBaseUrl = options.baseUrl ?? DEFAULT_LITELLM_BASE_URL;
+	const gateway = {
+		allowFallbacks: false,
+		...options.gateway
+	};
+	const inner = createOpenAICompatibleProvider({
+		...options,
+		id: resolvedId,
+		baseUrl: resolvedBaseUrl,
+		gateway
+	});
+	const negotiate = async (modelId) => {
+		return synthesizeNegotiatedCapabilitiesFromRegistry("litellm", modelId, "registry");
+	};
+	return {
+		...inner,
+		quirks: {
+			supportsToolChoice: false,
+			parallelToolCalls: false,
+			structuredOutputs: false,
+			responseFormatHonored: false,
+			streamingDiverges: true,
+			gatewayMetadataSupported: true,
+			gatewayFallbacksSupported: true,
+			openAIErrorMapping: true
+		},
+		negotiateCapabilities: negotiate
+	};
+}
+//#endregion
+//#region src/providers/lm-studio.ts
+const DEFAULT_LM_STUDIO_BASE_URL = "http://localhost:1234/v1";
+/**
+* Phase 34 — D-04 / QUIRK-02 — LM Studio provider factory.
+*
+* LM Studio is the prototypical "intentional no remote /models endpoint"
+* adapter per D-04 (alongside OpenAI-compat). The factory returns conservative
+* defaults for the quirks block because LM Studio runs LOCAL quantized models
+* whose capabilities vary wildly by chat template + model file.
+*
+* The `negotiateCapabilities` method performs NO fetch; it returns
+* `synthesizeNegotiatedCapabilitiesFromRegistry` with source: "registry"
+* (the intentional-no-endpoint signal, distinct from "registry-fallback"
+* which signals a transient failure). Mirrors Plan 34-03 Task 2 (OpenAI-compat
+* registry-only pattern) verbatim.
+*
+* D-04 citation: "consumer adapters without a /models endpoint skip the
+* fetch layer entirely and delegate to synthesizeNegotiatedCapabilitiesFromRegistry."
+*
+* Open Question 5 (RESEARCH §): no event emitted for source: "registry" because
+* this is the intentional happy path for LM Studio -- emitting a "fallback" event
+* would produce false-positive noise for consumers monitoring the event stream.
+*/
+function createLmStudioProvider(options) {
+	const resolvedId = options.id ?? "lm-studio";
+	const resolvedBaseUrl = options.baseUrl ?? DEFAULT_LM_STUDIO_BASE_URL;
+	const negotiate = async (modelId) => {
+		return synthesizeNegotiatedCapabilitiesFromRegistry("lm-studio", modelId, "registry");
+	};
+	return {
+		...createOpenAICompatibleProvider({
+			...options,
+			id: resolvedId,
+			baseUrl: resolvedBaseUrl
+		}),
+		quirks: {
+			supportsToolChoice: false,
+			parallelToolCalls: false,
+			structuredOutputs: false,
+			responseFormatHonored: false,
+			streamingDiverges: true,
+			customChatTemplateRiskFlag: true,
+			noAuthRequired: true
+		},
+		negotiateCapabilities: negotiate
+	};
+}
+//#endregion
+//#region src/providers/openrouter.ts
+const DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+function normalizeFallbackModels(models) {
+	if (models === void 0) return void 0;
+	const normalized = models.map((model) => model.trim()).filter((model) => model.length > 0);
+	return normalized.length > 0 ? normalized : void 0;
+}
+function observedModelFromRawResponse(rawResponse) {
+	if (typeof rawResponse !== "object" || rawResponse === null || Array.isArray(rawResponse)) return;
+	const model = rawResponse.model;
+	return typeof model === "string" ? model : void 0;
+}
+/**
+* Phase 34 — D-03 — OpenRouter quirks block. Values verified against
+* OpenRouter API documentation and observed behavior.
+*
+* CITED: https://openrouter.ai/docs/provider-routing
+*   - providerRoutingArraySupported: provider.order/only/ignore arrays for explicit routing
+* CITED: https://openrouter.ai/docs pricing / sort options
+*   - floorPricingHints: max_price, sort: "throughput" | "price" hints for cost-aware routing
+* CITED: https://openrouter.ai/docs allow_fallbacks
+*   - allowFallbacks: provider.allow_fallbacks boolean controls upstream-provider fallback behavior
+*/
+const OPENROUTER_QUIRKS = {
+	supportsToolChoice: true,
+	parallelToolCalls: true,
+	structuredOutputs: true,
+	responseFormatHonored: true,
+	streamingDiverges: false,
+	providerRoutingArraySupported: true,
+	floorPricingHints: true,
+	allowFallbacks: true
+};
+/**
+* Phase 34 — D-03 / D-05..D-12 — Extended OpenRouter provider factory.
+*
+* Returns a `ProviderAdapter` narrowed to expose:
+*   - `quirks: OpenRouterQuirks` — static adapter capability flags (8 booleans)
+*   - `negotiateCapabilities(modelId)` — live /api/v1/models fetch with rich /models
+*     intersection (supported_parameters -> nativeToolCalling + structuredOutputs,
+*     top_provider.context_length -> contextWindow) intersected with Phase 33 registry
+*     for knownFailureModes + recommendedSanitizers.
+*
+* CRITICAL for ANCHOR CASE STUDY (session_1780792387779):
+*   negotiate("openai/gpt-oss-120b:free") MUST resolve to:
+*     - result.knownFailureModes.includes("internal_envelope_leak") -> TRUE
+*     - result.recommendedSanitizers.includes("unwrapInternalEnvelope") -> TRUE
+*     - result.source === "live" -> TRUE
+*   This proves: live-fetch -> id suffix-strip via stripOpenRouterVariant
+*   -> registry intersection -> getRecommendedSanitizers derivation.
+*
+* Anti-pattern (RESEARCH §Anti-pattern, lines 534-535):
+*   The /api/v1/models endpoint is UNAUTHENTICATED (public discovery surface verified
+*   Phase 33). Do NOT send Authorization Bearer to this endpoint -- it is NOT required
+*   and would add unnecessary API key exposure surface in transit logs.
+*/
+function createOpenRouterProvider(options) {
+	const baseUrl = (options.baseUrl ?? DEFAULT_OPENROUTER_BASE_URL).replace(/\/$/u, "");
+	const fetchImpl = options.fetch ?? fetch;
+	const fallbackModels = normalizeFallbackModels(options.fallbackModels);
+	const ttlMs = options.modelsCacheTtlMs ?? 3e5;
+	const retryCount = options.modelsRetryCount ?? 2;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	/**
+	* D-07 lazy expiry + Q7 inflight coalescing + Pitfall 4 .finally cleanup.
+	* Public surface: `adapter.negotiateCapabilities(modelId)`.
+	*/
+	async function negotiate(modelId) {
+		const cached = cache.get(modelId);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.result;
+		const existing = inflight.get(modelId);
+		if (existing !== void 0) return existing;
+		const fetchPromise = (async () => {
+			try {
+				const result = await fetchAndNegotiate(modelId);
+				if (ttlMs > 0) cache.set(modelId, {
+					result,
+					expiresAt: Date.now() + ttlMs
+				});
+				return result;
+			} finally {
+				inflight.delete(modelId);
+			}
+		})();
+		inflight.set(modelId, fetchPromise);
+		return fetchPromise;
+	}
+	/**
+	* Phase 34 — D-09..D-11 — Fetches /api/v1/models and merges with registry.
+	*
+	* URL: ${baseUrl}/api/v1/models (NOTE: /api/v1/models -- different prefix from
+	*   OpenAI's /v1/models; OpenRouter's discovery endpoint is under /api/v1/)
+	* Auth: NONE -- OpenRouter /api/v1/models is a public unauthenticated endpoint.
+	*   Per RESEARCH §Anti-pattern (lines 534-535): do NOT send Authorization Bearer
+	*   to this endpoint. This is a known anti-pattern; do not "fix" it.
+	* Retry: [0ms, 200ms, 1000ms] backoff on transient errors (D-11).
+	* Auth error (401/403): throws NegotiationAuthError (D-10, no fallback) -- defensive,
+	*   even though the endpoint is unauthenticated today, OpenRouter may add auth later.
+	* Transient error (5xx/network): falls back to registry with "registry-fallback" (D-09).
+	*/
+	async function fetchAndNegotiate(modelId) {
+		const url = `${baseUrl}/api/v1/models`;
+		const headers = { "accept": "application/json" };
+		const attempts = retryCount + 1;
+		const backoffSchedule = [
+			0,
+			200,
+			1e3
+		];
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) {
+			const delay = backoffSchedule[i] ?? 1e3;
+			if (delay > 0) await new Promise((r) => setTimeout(r, delay));
+			try {
+				const resp = await fetchImpl(url, {
+					method: "GET",
+					headers,
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (resp.status === 401 || resp.status === 403) throw new NegotiationAuthError("openrouter", modelId, resp.status, `OpenRouter /api/v1/models returned ${resp.status}.`);
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				return mergeOpenRouterModelsWithRegistry(modelId, await resp.json());
+			} catch (err) {
+				if (err instanceof NegotiationAuthError) throw err;
+				lastErr = err;
+			}
+		}
+		emitFallbackEvent({
+			adapter: "openrouter",
+			modelId,
+			errorReason: stringifyErr$1(lastErr),
+			fallbackSource: "registry-fallback"
+		});
+		return synthesizeNegotiatedCapabilitiesFromRegistry("openrouter", modelId, "registry-fallback");
+	}
+	/**
+	* RICH /models intersection: consumes OpenRouter's /api/v1/models structured data
+	* to populate NegotiatedCapabilities.supports.* from upstream (THICK derivation where
+	* available), then intersects with Phase 33 registry for knownFailureModes +
+	* recommendedSanitizers.
+	*
+	* ANCHOR CASE STUDY (session_1780792387779) flow:
+	*   1. Find "openai/gpt-oss-120b:free" (or strip suffix -> "openai/gpt-oss-120b")
+	*   2. Build canonical key: "openrouter:openai/gpt-oss-120b" (via stripOpenRouterVariant)
+	*   3. getCapabilityProfile("openrouter:openai/gpt-oss-120b") -> Phase 33 profile with
+	*      knownFailureModes: ["internal_envelope_leak", "system_prompt_echo", "malformed_tool_arguments"]
+	*   4. getRecommendedSanitizers(knownFailureModes) -> ["unwrapInternalEnvelope"]
+	*   5. result.recommendedSanitizers.includes("unwrapInternalEnvelope") -> TRUE
+	*
+	* Pitfall 3 / A1 precedence chain (RESEARCH §Q5):
+	*   contextWindow = top_provider.context_length ?? context_length ?? registryProfile.contextWindow
+	*
+	* Lenient parsing per Pitfall 1: all field accesses use optional chaining.
+	*/
+	function mergeOpenRouterModelsWithRegistry(modelId, body) {
+		const rows = body?.data;
+		const found = Array.isArray(rows) ? rows.find((m) => {
+			const rec = m;
+			if (typeof rec?.id !== "string") return false;
+			const rowId = rec.id;
+			if (rowId === modelId || rowId === stripOpenRouterVariant(modelId)) return true;
+			const strippedModelId = stripOpenRouterVariant(modelId);
+			return stripOpenRouterVariant(rowId) === strippedModelId;
+		}) : void 0;
+		const stripped = stripOpenRouterVariant(modelId);
+		const registryProfile = getCapabilityProfile(`openrouter:${stripped}`);
+		if (found === void 0) {
+			emitFallbackEvent({
+				adapter: "openrouter",
+				modelId,
+				errorReason: "model not found in /api/v1/models response",
+				fallbackSource: "registry-fallback"
+			});
+			return {
+				...synthesizeNegotiatedCapabilitiesFromRegistry("openrouter", stripped, "registry-fallback"),
+				modelId
+			};
+		}
+		const foundRec = found;
+		const topProvider = foundRec.top_provider;
+		const contextWindow = typeof topProvider?.context_length === "number" && topProvider.context_length > 0 ? topProvider.context_length : typeof foundRec.context_length === "number" && foundRec.context_length > 0 ? foundRec.context_length : registryProfile?.contextWindow ?? 0;
+		const supportedParams = Array.isArray(foundRec.supported_parameters) ? foundRec.supported_parameters.map(String) : [];
+		const nativeToolCalling = supportedParams.includes("tools");
+		const structuredOutputs = supportedParams.includes("response_format");
+		const parallelToolCalls = supportedParams.includes("tool_choice");
+		const extendedThinking = supportedParams.includes("reasoning") || supportedParams.includes("thinking");
+		const streaming = true;
+		const knownFailureModes = registryProfile?.knownFailureModes ?? [];
+		const recommendedSanitizers = getRecommendedSanitizers(knownFailureModes);
+		return {
+			modelId,
+			contextWindow,
+			supports: {
+				nativeToolCalling,
+				structuredOutputs,
+				parallelToolCalls,
+				extendedThinking,
+				streaming
+			},
+			knownFailureModes,
+			recommendedSanitizers,
+			source: "live"
+		};
+	}
+	/**
+	* D-12: Emit capabilities.negotiation.fallback RunEvent via the optional sink.
+	* SECURITY (T-34-04-02): stringifyErr extracts err.message only -- NOT err.stack
+	* or JSON.stringify(headers), so the apiKey cannot leak into the event payload.
+	* Synthetic runId pattern: negotiate happens outside a run; documented here.
+	*/
+	function emitFallbackEvent(payload) {
+		if (options.runEventSink === void 0) return;
+		const event = createRunEvent("capabilities.negotiation.fallback", {
+			runId: `negotiate-openrouter-${payload.modelId}`,
+			providerId: options.id ?? "openrouter",
+			modelId: payload.modelId,
+			metadata: {
+				adapter: payload.adapter,
+				modelId: payload.modelId,
+				errorReason: payload.errorReason,
+				fallbackSource: payload.fallbackSource
+			}
+		});
+		options.runEventSink(event);
+	}
+	const executeFetch = fallbackModels === void 0 ? fetchImpl : (async (url, init) => {
+		if (typeof init?.body !== "string") return fetchImpl(url, init);
+		const body = JSON.parse(init.body);
+		return fetchImpl(url, {
+			...init,
+			body: JSON.stringify({
+				...body,
+				models: [...fallbackModels]
+			})
+		});
+	});
+	const baseAdapter = createOpenAICompatibleProvider({
+		...options,
+		id: options.id ?? "openrouter",
+		baseUrl,
+		fetch: executeFetch
+	});
+	const baseExecuteStream = baseAdapter.executeStream;
+	return {
+		...baseAdapter,
+		async execute(request) {
+			const response = await baseAdapter.execute(request);
+			const observedModel = response.gateway?.observedModel ?? observedModelFromRawResponse(response.rawResponse);
+			return {
+				...response,
+				gateway: {
+					...response.gateway ?? { used: true },
+					used: true,
+					requestedModel: options.model,
+					...fallbackModels !== void 0 ? { fallbackModels } : {},
+					...observedModel !== void 0 ? { observedModel } : {}
+				}
+			};
+		},
+		...baseExecuteStream !== void 0 ? { executeStream: async (request) => {
+			return withOpenRouterStreamGateway(await baseExecuteStream(request));
+		} } : {},
+		quirks: OPENROUTER_QUIRKS,
+		negotiateCapabilities: negotiate
+	};
+	async function* withOpenRouterStreamGateway(stream) {
+		for await (const chunk of stream) {
+			if (chunk.kind !== "complete") {
+				yield chunk;
+				continue;
+			}
+			const observedModel = chunk.gateway?.observedModel ?? observedModelFromRawResponse(chunk.rawResponse);
+			yield {
+				...chunk,
+				gateway: {
+					...chunk.gateway ?? { used: true },
+					used: true,
+					requestedModel: options.model,
+					...fallbackModels !== void 0 ? { fallbackModels } : {},
+					...observedModel !== void 0 ? { observedModel } : {}
+				}
+			};
+		}
+	}
+}
+/**
+* T-34-04-02: Returns err.message only -- NOT err.stack (which could include
+* headers or the apiKey via a fetch rejection), NOT JSON.stringify(err).
+*/
+function stringifyErr$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+//#region src/providers/xai.ts
+const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
+/**
+* Phase 34 — D-12 — Emit a "capabilities.negotiation.fallback" RunEvent if
+* a sink is provided. Uses a synthetic runId (negotiation is outside a run).
+*
+* T-34-03-01: errorReason uses stringifyErr (message only, not stack) to
+* prevent apiKey leaking via fetch error strings that may embed request headers.
+*/
+function emitFallbackEvent(sink, payload) {
+	if (sink === void 0) return;
+	sink(createRunEvent("capabilities.negotiation.fallback", {
+		runId: `negotiate-${payload.adapter}-${payload.modelId}`,
+		providerId: payload.adapter,
+		modelId: payload.modelId,
+		metadata: {
+			adapter: payload.adapter,
+			modelId: payload.modelId,
+			errorReason: payload.errorReason,
+			fallbackSource: payload.fallbackSource
+		}
+	}));
+}
+/**
+* Stringify an error for event metadata. Returns only the message (NOT the
+* stack) to prevent apiKey or sensitive header values from leaking into event
+* payloads via fetch errors that may embed the request init.
+* T-34-03-01 mitigation.
+*/
+function stringifyErr(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Phase 34 — QUIRK-02 / NEG-01 / NEG-02 — Merge an xAI /v1/models sparse
+* OpenAI-shaped response with the Phase 33 registry.
+*
+* RESEARCH §A1 (INFERRED): xAI's /v1/models shape is undocumented; the
+* endpoint is assumed to return an OpenAI-compatible sparse list based on
+* the shared OpenAI-compat wire format used for chat completions.
+* LENIENT-PARSE is mandatory per Pitfall 1 (RESEARCH §Q4): if xAI changes
+* their response shape, the adapter must not crash.
+*
+* CITED: Pitfall 1 — "When integrating with less-documented endpoints like
+* xAI's /v1/models, lenient parsing prevents runtime crashes when the
+* endpoint returns an unexpected shape."
+*
+* Source semantics per D-09:
+*   - "live" when the model id is found in the response AND body.data is an array
+*   - "registry-fallback" when body.data is not an array (unexpected shape)
+*     OR when the model id is not in the response
+*/
+function mergeXaiModelsWithRegistry(modelId, body, emitFallback) {
+	const rawData = body?.data;
+	if (!Array.isArray(rawData)) {
+		emitFallback();
+		return synthesizeNegotiatedCapabilitiesFromRegistry("xai", modelId, "registry-fallback");
+	}
+	if (rawData.find((m) => typeof m === "object" && m !== null && m.id === modelId) === void 0) {
+		emitFallback();
+		return synthesizeNegotiatedCapabilitiesFromRegistry("xai", modelId, "registry-fallback");
+	}
+	const registryProfile = getCapabilityProfile(`xai:${modelId}`);
+	if (registryProfile !== void 0) return mapProfileToNegotiatedCapabilities(registryProfile, "live");
+	return {
+		modelId,
+		contextWindow: 0,
+		supports: {
+			nativeToolCalling: true,
+			structuredOutputs: true,
+			parallelToolCalls: true,
+			extendedThinking: false,
+			streaming: true
+		},
+		knownFailureModes: [],
+		recommendedSanitizers: [],
+		source: "live"
+	};
+}
+/**
+* Phase 34 — QUIRK-02 / NEG-01 / NEG-02 — xAI provider factory.
+*
+* Extends the base OpenAI-compat execution wrapper with:
+*   1. `quirks: XaiQuirks` — verified per RESEARCH §Q6 xAI vocabulary.
+*   2. `negotiateCapabilities(modelId)` — queries xAI /v1/models GET with
+*      Authorization: Bearer header; LENIENT-PARSE sparse OpenAI-shaped
+*      response; intersects with Phase 33 registry for supports.*.
+*
+* CITED: RESEARCH §Q4 (INFERRED) — xAI /v1/models shape is undocumented;
+* assumed OpenAI-compatible based on the chat completions wire format.
+*
+* CITED: RESEARCH §A1 — Pitfall 1 lenient parse: if xAI publishes a
+* different /models shape, only the parsing logic updates; the contract
+* (source values, NegotiatedCapabilities shape) holds.
+*
+* The negotiate() pattern mirrors Plan 34-02 (Anthropic thick reference):
+*   - Per-instance TTL cache (modelsCacheTtlMs, default 300_000ms)
+*   - Single-flight inflight coalescing with .finally cleanup (Pitfall 4)
+*   - Retry with [0, 200, 1000]ms backoff (modelsRetryCount, default 2)
+*   - 401/403 throws NegotiationAuthError with adapter: "xai" (D-10)
+*   - 5xx/network/timeout falls back to registry + emits fallback event
+*
+* SECURITY (T-34-03-07): inflight Map MUST use .finally cleanup to prevent
+* leak on rejection. Verifiable: grep `.finally` in this file.
+*/
+function createXaiProvider(options) {
+	const resolvedBaseUrl = (options.baseUrl ?? DEFAULT_XAI_BASE_URL).replace(/\/$/u, "");
+	const ttlMs = options.modelsCacheTtlMs ?? 3e5;
+	const retryCount = options.modelsRetryCount ?? 2;
+	const fetchImpl = options.fetch ?? fetch;
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	async function fetchAndNegotiate(modelId) {
+		const url = `${resolvedBaseUrl}/models`;
+		const headers = {
+			"accept": "application/json",
+			...options.apiKey !== void 0 ? { authorization: `Bearer ${options.apiKey}` } : {}
+		};
+		const attempts = retryCount + 1;
+		const backoffMs = [
+			0,
+			200,
+			1e3
+		];
+		let lastErr;
+		for (let i = 0; i < attempts; i += 1) {
+			if (i > 0) {
+				const delay = backoffMs[Math.min(i, backoffMs.length - 1)] ?? 1e3;
+				await new Promise((r) => setTimeout(r, delay));
+			}
+			try {
+				const resp = await fetchImpl(url, {
+					method: "GET",
+					headers,
+					signal: AbortSignal.timeout(3e4)
+				});
+				if (resp.status === 401 || resp.status === 403) throw new NegotiationAuthError("xai", modelId, resp.status, `xAI /v1/models returned ${resp.status}: check apiKey config.`);
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				return mergeXaiModelsWithRegistry(modelId, await resp.json(), () => {
+					emitFallbackEvent(options.runEventSink, {
+						adapter: "xai",
+						modelId,
+						errorReason: "model not found in /v1/models response or unexpected body shape",
+						fallbackSource: "registry-fallback"
+					});
+				});
+			} catch (err) {
+				if (err instanceof NegotiationAuthError) throw err;
+				lastErr = err;
+			}
+		}
+		emitFallbackEvent(options.runEventSink, {
+			adapter: "xai",
+			modelId,
+			errorReason: stringifyErr(lastErr),
+			fallbackSource: "registry-fallback"
+		});
+		return synthesizeNegotiatedCapabilitiesFromRegistry("xai", modelId, "registry-fallback");
+	}
+	async function negotiate(modelId) {
+		const cached = cache.get(modelId);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) return cached.result;
+		const existing = inflight.get(modelId);
+		if (existing !== void 0) return existing;
+		const fetchPromise = (async () => {
+			try {
+				const result = await fetchAndNegotiate(modelId);
+				if (ttlMs > 0) cache.set(modelId, {
+					result,
+					expiresAt: Date.now() + ttlMs
+				});
+				return result;
+			} finally {
+				inflight.delete(modelId);
+			}
+		})();
+		inflight.set(modelId, fetchPromise);
+		return fetchPromise;
+	}
+	const inner = createOpenAICompatibleProvider({
+		...options,
+		id: options.id ?? "xai",
+		baseUrl: resolvedBaseUrl
+	});
+	const innerExecute = inner.execute;
+	const innerExecuteStream = inner.executeStream;
+	const wrappedExecute = innerExecute === void 0 ? void 0 : async (request) => {
+		const response = await innerExecute(request);
+		const reasoningTokens = reasoningTokensFromRawResponse(response.rawResponse);
+		if (typeof reasoningTokens === "number" && response.usage !== void 0) {
+			const inputTokens = response.usage.inputTokens ?? 0;
+			const outputTokens = response.usage.outputTokens ?? 0;
+			return {
+				...response,
+				usage: {
+					...response.usage,
+					totalTokens: inputTokens + outputTokens + reasoningTokens
+				}
+			};
+		}
+		return response;
+	};
+	const wrappedExecuteStream = innerExecuteStream === void 0 ? void 0 : async function* (request) {
+		const stream = await innerExecuteStream(request);
+		for await (const chunk of stream) {
+			if (chunk.kind !== "complete") {
+				yield chunk;
+				continue;
+			}
+			const reasoningTokens = reasoningTokensFromRawResponse(chunk.rawResponse);
+			if (typeof reasoningTokens === "number" && chunk.usage !== void 0) {
+				const inputTokens = chunk.usage.inputTokens ?? 0;
+				const outputTokens = chunk.usage.outputTokens ?? 0;
+				yield {
+					...chunk,
+					usage: {
+						...chunk.usage,
+						totalTokens: inputTokens + outputTokens + reasoningTokens
+					}
+				};
+				continue;
+			}
+			yield chunk;
+		}
+	};
+	return {
+		id: inner.id,
+		kind: inner.kind,
+		quirks: {
+			supportsToolChoice: true,
+			parallelToolCalls: true,
+			structuredOutputs: true,
+			responseFormatHonored: true,
+			streamingDiverges: false,
+			reasoningTokensReported: true,
+			logprobsSupported: false
+		},
+		negotiateCapabilities: negotiate,
+		...inner.capabilities !== void 0 ? { capabilities: inner.capabilities } : {},
+		...wrappedExecute !== void 0 ? { execute: wrappedExecute } : {},
+		...wrappedExecuteStream !== void 0 ? { executeStream: wrappedExecuteStream } : {}
+	};
+}
+function reasoningTokensFromRawResponse(rawResponse) {
+	const direct = reasoningTokensFromUsage(rawResponse?.usage);
+	if (direct !== void 0) return direct;
+	if (!isRecord(rawResponse) || !Array.isArray(rawResponse.chunks)) return;
+	for (let index = rawResponse.chunks.length - 1; index >= 0; index -= 1) {
+		const chunk = rawResponse.chunks[index];
+		const fromChunk = reasoningTokensFromUsage(chunk?.usage);
+		if (fromChunk !== void 0) return fromChunk;
+	}
+}
+function reasoningTokensFromUsage(usage) {
+	if (!isRecord(usage) || !isRecord(usage.completion_tokens_details)) return;
+	const value = usage.completion_tokens_details.reasoning_tokens;
+	return typeof value === "number" ? value : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/providers/streaming.ts
+async function collectStream(stream, options = {}) {
+	const rawOutputs = {};
+	const textParts = /* @__PURE__ */ new Map();
+	const toolCalls = [];
+	let artifactRefs;
+	let usage;
+	let normalizedUsage;
+	let gateway;
+	let finish;
+	let rawResponse;
+	let rawResponseProvided = false;
+	let chunkCount = 0;
+	for await (const chunk of stream) {
+		chunkCount += 1;
+		switch (chunk.kind) {
+			case "text-delta": {
+				const output = chunk.output ?? options.defaultOutput ?? "text";
+				const parts = textParts.get(output);
+				if (parts === void 0) textParts.set(output, [chunk.text]);
+				else parts.push(chunk.text);
+				break;
+			}
+			case "output":
+				rawOutputs[chunk.output] = chunk.value;
+				break;
+			case "usage":
+				if (chunk.usage !== void 0) usage = chunk.usage;
+				if (chunk.normalizedUsage !== void 0) normalizedUsage = chunk.normalizedUsage;
+				break;
+			case "gateway":
+				gateway = chunk.gateway;
+				break;
+			case "tool-call":
+				toolCalls.push(chunk.toolCall);
+				break;
+			case "complete":
+				if (chunk.rawOutputs !== void 0) Object.assign(rawOutputs, chunk.rawOutputs);
+				if (chunk.artifactRefs !== void 0) artifactRefs = chunk.artifactRefs;
+				if (chunk.usage !== void 0) usage = chunk.usage;
+				if (chunk.normalizedUsage !== void 0) normalizedUsage = chunk.normalizedUsage;
+				if (chunk.gateway !== void 0) gateway = chunk.gateway;
+				if (chunk.toolCalls !== void 0) toolCalls.push(...chunk.toolCalls);
+				if (chunk.finish !== void 0) finish = chunk.finish;
+				if ("rawResponse" in chunk) {
+					rawResponse = chunk.rawResponse;
+					rawResponseProvided = true;
+				}
+				break;
+		}
+	}
+	for (const [output, parts] of textParts) if (!(output in rawOutputs)) rawOutputs[output] = parts.join("");
+	return {
+		rawOutputs,
+		...artifactRefs !== void 0 ? { artifactRefs } : {},
+		...usage !== void 0 ? { usage } : {},
+		...normalizedUsage !== void 0 ? { normalizedUsage } : {},
+		...toolCalls.length > 0 ? { toolCalls } : {},
+		...gateway !== void 0 ? { gateway } : {},
+		...finish !== void 0 ? { finish } : {},
+		rawResponse: rawResponseProvided ? rawResponse : {
+			kind: "lattice-stream-summary",
+			chunkCount,
+			outputNames: Object.keys(rawOutputs)
+		}
+	};
+}
+//#endregion
+//#region src/prompts/scaffolds.ts
+const PROMPT_SCAFFOLD_VERSION = "lattice.prompt-scaffold/v1";
+const PROMPT_STRATEGIES = [
+	"frontier",
+	"mid_tier",
+	"open_weight",
+	"reasoning",
+	"local"
+];
+const JSON_SERIALIZATION_ERRORS = {
+	schema: "getStructuredOutputContract: schema must be JSON-serializable for deterministic prompt scaffolds.",
+	tools: "getToolUseContract: tools must be JSON-serializable for deterministic prompt scaffolds."
+};
+const STRATEGY_INSTRUCTIONS = {
+	frontier: {
+		structuredOutput: ["Return only content that satisfies the contract.", "Do not include prose before or after the structured output."],
+		toolUse: ["Use a tool only when the task requires an external action or lookup.", "Return a normal answer when the user request can be completed without a tool."]
+	},
+	mid_tier: {
+		structuredOutput: ["Treat the contract as instructions, not as prose to repeat.", "Return the requested answer in the shape required by the contract."],
+		toolUse: ["The tool definitions are available actions, not answer text.", "Call only a listed tool, and only with arguments that match its definition."]
+	},
+	open_weight: {
+		structuredOutput: [
+			"The contract below is an instruction, not text to output.",
+			"Do not answer with the schema, envelope, or any field name unless that field belongs in the final user-visible JSON.",
+			"Bad: {\"summary\":\"Greeted the user.\"} when the user asked for a natural-language reply.",
+			"Good: Greeted the user."
+		],
+		toolUse: [
+			"The tool list below is action metadata, not text to output.",
+			"Do not copy the tool descriptor into the final answer.",
+			"If no listed tool is needed, answer normally without fabricating a tool call."
+		]
+	},
+	reasoning: {
+		structuredOutput: ["Do not expose hidden reasoning, scratchpad text, or analysis in the final answer.", "Return only the final content that satisfies the contract."],
+		toolUse: ["Keep tool selection separate from hidden reasoning.", "Do not include scratchpad text when explaining whether a tool was used."]
+	},
+	local: {
+		structuredOutput: ["Do not copy the contract, chat template, or wrapper text into the answer.", "Return the requested answer directly in the required shape."],
+		toolUse: ["Do not invent tool names or arguments.", "If the task does not require a listed tool, answer directly."]
+	}
+};
+function canonicalPromptJson(value, payload) {
+	const errorMessage = JSON_SERIALIZATION_ERRORS[payload];
+	let json;
+	try {
+		json = canonicalize(value);
+		if (json === void 0) throw new Error(errorMessage);
+		JSON.parse(json);
+	} catch {
+		throw new Error(errorMessage);
+	}
+	return json;
+}
+function renderPromptScaffold(strategy, purpose, instructions, payloadHeading, payload) {
+	return [
+		`Lattice Prompt Scaffold: ${PROMPT_SCAFFOLD_VERSION}`,
+		`Strategy: ${strategy}`,
+		`Purpose: ${purpose}`,
+		"",
+		...instructions,
+		"",
+		`${payloadHeading}:`,
+		payload
+	].join("\n");
+}
+function getStructuredOutputContract(strategy, schema) {
+	return renderPromptScaffold(strategy, "structured-output", STRATEGY_INSTRUCTIONS[strategy].structuredOutput, "Contract", canonicalPromptJson(schema, "schema"));
+}
+function getToolUseContract(strategy, tools) {
+	return renderPromptScaffold(strategy, "tool-use", STRATEGY_INSTRUCTIONS[strategy].toolUse, "Tools", canonicalPromptJson(tools, "tools"));
+}
+//#endregion
+export { stripReasoningTags as _, collectStream as a, NoPublicUrlEgressError as b, createLmStudioProvider as c, createFakeProvider as d, createAnthropicProvider as f, stripChatTemplateArtifacts as g, createOpenAIProvider as h, getToolUseContract as i, createLiteLLMProvider as l, createOpenAICompatibleProvider as m, PROMPT_STRATEGIES as n, createXaiProvider as o, createAISdkProvider as p, getStructuredOutputContract as r, createOpenRouterProvider as s, PROMPT_SCAFFOLD_VERSION as t, createGeminiProvider as u, unwrapInternalEnvelope as v, mediaTypeForArtifact as x, createRunEvent as y };
+
+//# sourceMappingURL=scaffolds-ekPIlBeU.js.map