@gajae-code/ai 0.18.11 → 0.19.0

package/src/models.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 import { registerProviderSafetyStopModel } from "./adapter-internals/provider-safety-stop";
-import { getOpenAIModelCost } from "./model-pricing";
+import { getAnthropicCacheWriteOneHourRate, getAnthropicModelCost, getOpenAIModelCost } from "./model-pricing";
 import { isRetiredModelKey } from "./model-retirements";
 import { applyGeneratedModelPolicies, enrichModelThinking } from "./model-thinking";
 // `with { type: "file" }` is embedded by `bun build --compile` and resolves to
@@ -105,11 +105,18 @@ export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
 
 export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
 	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
-	const pricing = getOpenAIModelCost(model, inputTokens) ?? model.cost;
+	const pricing = getAnthropicModelCost(model, inputTokens) ?? getOpenAIModelCost(model, inputTokens) ?? model.cost;
 	usage.cost.input = (pricing.input / 1000000) * usage.input;
 	usage.cost.output = (pricing.output / 1000000) * usage.output;
 	usage.cost.cacheRead = (pricing.cacheRead / 1000000) * usage.cacheRead;
-	usage.cost.cacheWrite = (pricing.cacheWrite / 1000000) * usage.cacheWrite;
+	const oneHourRate = getAnthropicCacheWriteOneHourRate(model, inputTokens);
+	// Bill the response's 1-hour cache-write tokens at the 1-hour rate; everything else
+	// (5-minute writes and any unattributed remainder) uses the model's cacheWrite rate.
+	const oneHourTokens =
+		oneHourRate === undefined ? 0 : Math.min(Math.max(usage.cttl?.ephemeral1h ?? 0, 0), usage.cacheWrite);
+	usage.cost.cacheWrite =
+		(pricing.cacheWrite / 1000000) * (usage.cacheWrite - oneHourTokens) +
+		((oneHourRate ?? 0) / 1000000) * oneHourTokens;
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 	return usage.cost;
 }

package/src/openai-completions-compat.d.ts

@@ -27,13 +27,14 @@ export declare function isDirectXaiReasoningEffortModel(model: {
     api?: string;
     baseUrl?: string;
 }, resolvedBaseUrl?: string): boolean;
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "supportsUltrafastTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     toolStrictMode: ResolvedToolStrictMode;
     supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
     supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+    supportsUltrafastTier?: OpenAICompat["supportsUltrafastTier"];
     /** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
     toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };

package/src/openai-completions-compat.ts

@@ -146,6 +146,7 @@ export type ResolvedOpenAICompat = Required<
 		| "toolChoiceSupport"
 		| "supportsResponsesSessionAffinity"
 		| "supportsServiceTier"
+		| "supportsUltrafastTier"
 		| "reservedToolNames"
 	>
 > & {
@@ -155,6 +156,7 @@ export type ResolvedOpenAICompat = Required<
 	toolStrictMode: ResolvedToolStrictMode;
 	supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
 	supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+	supportsUltrafastTier?: OpenAICompat["supportsUltrafastTier"];
 	/** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
 	toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };
@@ -349,6 +351,8 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		supportsDeveloperRole: !isNonStandard,
 		sendSessionHeaders: false,
 		supportsResponsesSessionAffinity: false,
+		supportsServiceTier: false,
+		supportsUltrafastTier: false,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
 		supportsReasoningEffort:
 			hasAuditedReasoningEffortTransport &&
@@ -422,6 +426,7 @@ export function resolveOpenAICompat(
 				? model.compat.supportsResponsesSessionAffinity
 				: undefined) ?? detected.supportsResponsesSessionAffinity,
 		supportsServiceTier: model.compat.supportsServiceTier ?? detected.supportsServiceTier,
+		supportsUltrafastTier: model.compat.supportsUltrafastTier ?? detected.supportsUltrafastTier,
 		supportsMultipleSystemMessages:
 			model.compat.supportsMultipleSystemMessages ?? detected.supportsMultipleSystemMessages,
 		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,

package/src/provider-models/google.ts

@@ -1,5 +1,5 @@
 import type { ModelManagerOptions } from "../model-manager";
-import { fetchAntigravityDiscoveryModels } from "../utils/discovery/antigravity";
+import { fetchAntigravityDiscoveryModels, getDefaultAntigravityUserAgent } from "../utils/discovery/antigravity";
 import { fetchGeminiModels } from "../utils/discovery/gemini";
 
 export interface GoogleModelManagerConfig {
@@ -14,11 +14,13 @@ export interface GoogleVertexModelManagerConfig {
 export interface GoogleAntigravityModelManagerConfig {
 	oauthToken?: string;
 	endpoint?: string;
+	project?: string;
 }
 
 export interface GoogleGeminiCliModelManagerConfig {
 	oauthToken?: string;
 	endpoint?: string;
+	project?: string;
 }
 
 const CLOUD_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
@@ -48,14 +50,18 @@ export function googleAntigravityModelManagerOptions(
 	config?: GoogleAntigravityModelManagerConfig,
 ): ModelManagerOptions<"google-gemini-cli"> {
 	const token = config?.oauthToken;
+	const ua = getDefaultAntigravityUserAgent();
 	return {
 		providerId: "google-antigravity",
+		discoveryUserAgent: ua,
 		...(token
 			? {
 					fetchDynamicModels: () =>
 						fetchAntigravityDiscoveryModels({
 							token,
 							endpoint: config?.endpoint,
+							project: config?.project,
+							userAgent: ua,
 						}),
 				}
 			: undefined),
@@ -67,15 +73,19 @@ export function googleGeminiCliModelManagerOptions(
 ): ModelManagerOptions<"google-gemini-cli"> {
 	const token = config?.oauthToken;
 	const endpoint = config?.endpoint ?? CLOUD_CODE_ASSIST_ENDPOINT;
+	const ua = getDefaultAntigravityUserAgent();
 	return {
 		providerId: "google-gemini-cli",
+		discoveryUserAgent: ua,
 		...(token
 			? {
 					fetchDynamicModels: async () => {
 						const models = await fetchAntigravityDiscoveryModels({
 							token,
 							endpoint,
+							project: config?.project,
 							targetProvider: "google-gemini-cli",
+							userAgent: ua,
 						});
 						if (models === null) {
 							return null;

package/src/provider-models/openai-compat.ts

@@ -1316,6 +1316,31 @@ export function kiloModelManagerOptions(config?: KiloModelManagerConfig): ModelM
 				provider: "kilo",
 				baseUrl,
 				apiKey,
+				// Kilo serves the OpenRouter catalog shape: nested limits/modalities and
+				// per-token USD string prices (GJC costs are per million tokens).
+				mapModel: (entry, defaults) => {
+					const topProvider = isRecord(entry.top_provider) ? entry.top_provider : undefined;
+					const architecture = isRecord(entry.architecture) ? entry.architecture : undefined;
+					const pricing = isRecord(entry.pricing) ? entry.pricing : undefined;
+					const params = Array.isArray(entry.supported_parameters) ? entry.supported_parameters : [];
+					const perMillion = (value: unknown): number => {
+						const perToken = toNumber(value);
+						return perToken !== undefined && perToken >= 0 ? perToken * 1_000_000 : 0;
+					};
+					return {
+						...defaults,
+						reasoning: params.includes("reasoning"),
+						input: toInputCapabilities(architecture?.input_modalities),
+						cost: {
+							input: perMillion(pricing?.prompt),
+							output: perMillion(pricing?.completion),
+							cacheRead: perMillion(pricing?.input_cache_read),
+							cacheWrite: perMillion(pricing?.input_cache_write),
+						},
+						contextWindow: toPositiveNumber(entry.context_length, defaults.contextWindow),
+						maxTokens: toPositiveNumber(topProvider?.max_completion_tokens, defaults.maxTokens),
+					};
+				},
 			}),
 	};
 }
@@ -2125,6 +2150,7 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 								...(api === "openai-completions"
 									? {
 											compat: {
+												...(reference.compat ?? {}),
 												supportsStore: false,
 												supportsDeveloperRole: false,
 												supportsReasoningEffort: false,

package/src/providers/amazon-bedrock.d.ts

@@ -8,7 +8,7 @@
  */
 import { parseBedrockClaudeGeneration } from "../bedrock-claude-cache-policy";
 import type { Effort } from "../model-thinking";
-import type { Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
+import type { AssistantMessage, CacheRetention, Model, StreamFunction, StreamOptions, ThinkingBudgets, Tool, ToolChoice } from "../types";
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 export interface BedrockOptions extends StreamOptions {
     region?: string;
@@ -51,7 +51,18 @@ interface WireToolConfig {
     tools: WireToolSpec[];
     toolChoice?: WireToolChoice;
 }
+interface MetadataEvent {
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadInputTokens?: number;
+        cacheWriteInputTokens?: number;
+        totalTokens?: number;
+    };
+}
 export declare const streamBedrock: StreamFunction<"bedrock-converse-stream">;
+/** Exported for unit tests of the usage-to-cost path. */
+export declare function handleMetadata(event: MetadataEvent, model: Model<"bedrock-converse-stream">, output: AssistantMessage, cacheRetention: CacheRetention): void;
 /**
  * Check if the model supports prompt caching.
  * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, and every later Claude
@@ -71,5 +82,9 @@ export declare function stripBedrockForcedToolChoiceForRetry<T extends {
     toolConfig?: {
         toolChoice?: unknown;
     };
-}>(body: T): T;
+    additionalModelRequestFields?: Record<string, unknown>;
+}>(body: T, thinking?: {
+    forced: Record<string, unknown> | undefined;
+    restored: Record<string, unknown>;
+}): T;
 export declare function convertToolConfig(tools: Tool[] | undefined, toolChoice: BedrockOptions["toolChoice"]): WireToolConfig | undefined;

package/src/providers/amazon-bedrock.ts

@@ -10,10 +10,12 @@
 import { $credentialEnv, $env, $flag, extractHttpStatusFromError, fetchWithRetry } from "@gajae-code/utils";
 import { assertAwsRegionLabel } from "../adapter-internals/aws-region";
 import { parseBedrockClaudeGeneration, supportsBedrockClaudePromptCaching } from "../bedrock-claude-cache-policy";
+import { getAnthropicCacheWriteOneHourRate } from "../model-pricing";
 import type { Effort } from "../model-thinking";
 import {
 	mapEffortToAnthropicAdaptiveEffort,
 	requireSupportedEffort,
+	requiresAnthropicThinkingDisableWhenOff,
 	supportsAnthropicAdaptiveThinkingDisplay as supportsAdaptiveThinkingDisplay,
 } from "../model-thinking";
 import { calculateCost } from "../models";
@@ -52,6 +54,7 @@ import { decodeEventStream } from "./aws-eventstream";
 import type { AwsCredentials } from "./aws-sigv4";
 import { signRequest } from "./aws-sigv4";
 import { transformMessages } from "./transform-messages";
+import { NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
 
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 
@@ -212,12 +215,30 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			const resolvedToolChoice = resolveToolChoice(model, options.toolChoice);
 			const toolConfig = convertToolConfig(context.tools, resolvedToolChoice.resolvedChoice);
 			let additionalModelRequestFields = buildAdditionalModelRequestFields(model, options);
+			// Selected reasoning fields before forced-tool normalization, restored if the forced
+			// tool choice is later dropped on retry (Haiku 5+ only; see below).
+			let unforcedModelRequestFields: Record<string, unknown> | undefined;
 
 			// Bedrock rejects thinking + forced tool_choice ("any" or specific tool).
 			// When the resolved tool_choice forces tool use, disable thinking to avoid API errors.
 			if (toolConfig?.toolChoice && additionalModelRequestFields) {
 				const tc = toolConfig.toolChoice;
-				if (tc.any || tc.tool) additionalModelRequestFields = undefined;
+				if ((tc.any || tc.tool) && requiresAnthropicThinkingDisableWhenOff(model.id)) {
+					// Haiku 5+ enables adaptive thinking when the field is omitted, which a forced
+					// tool choice rejects, and applies the effort to tool-call arguments too: send an
+					// explicit `disabled` and keep the selected effort (capped at `high` while
+					// thinking is disabled).
+					const effort = (additionalModelRequestFields.output_config as { effort?: string } | undefined)?.effort;
+					unforcedModelRequestFields = additionalModelRequestFields;
+					additionalModelRequestFields = {
+						thinking: { type: "disabled" },
+						...(effort
+							? { output_config: { effort: effort === "xhigh" || effort === "max" ? "high" : effort } }
+							: {}),
+					};
+				} else if (tc.any || tc.tool) {
+					additionalModelRequestFields = undefined;
+				}
 			}
 
 			let commandInput: ConverseStreamRequest = {
@@ -306,7 +327,12 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					reason,
 					registryKey: resolvedToolChoice.registryKey,
 				});
-				stripBedrockForcedToolChoiceForRetry(commandInput);
+				stripBedrockForcedToolChoiceForRetry(
+					commandInput,
+					unforcedModelRequestFields
+						? { forced: additionalModelRequestFields, restored: unforcedModelRequestFields }
+						: undefined,
+				);
 				const retryBodyText = JSON.stringify(commandInput);
 				const retryBody = new TextEncoder().encode(retryBodyText);
 				if (rawRequestDump) rawRequestDump.body = commandInput;
@@ -428,7 +454,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 							break;
 						}
 						case "metadata": {
-							handleMetadata(payload as MetadataEvent, model, output);
+							handleMetadata(payload as MetadataEvent, model, output, cacheRetention);
 							break;
 						}
 						default:
@@ -579,13 +605,28 @@ function handleContentBlockDelta(
 	}
 }
 
-function handleMetadata(event: MetadataEvent, model: Model<"bedrock-converse-stream">, output: AssistantMessage): void {
+/** Exported for unit tests of the usage-to-cost path. */
+export function handleMetadata(
+	event: MetadataEvent,
+	model: Model<"bedrock-converse-stream">,
+	output: AssistantMessage,
+	cacheRetention: CacheRetention,
+): void {
 	if (event.usage) {
 		output.usage.input = event.usage.inputTokens || 0;
 		output.usage.output = event.usage.outputTokens || 0;
 		output.usage.cacheRead = event.usage.cacheReadInputTokens || 0;
 		output.usage.cacheWrite = event.usage.cacheWriteInputTokens || 0;
 		output.usage.totalTokens = event.usage.totalTokens || output.usage.input + output.usage.output;
+		// Converse reports aggregate cache writes only. Where 1-hour writes have their own rate
+		// (Haiku 5.5), the request's `ttl: "1h"` cache points mean every write was 1-hour.
+		if (
+			cacheRetention === "long" &&
+			output.usage.cacheWrite > 0 &&
+			getAnthropicCacheWriteOneHourRate(model, 0) !== undefined
+		) {
+			output.usage.cttl = { ephemeral1h: output.usage.cacheWrite };
+		}
 		calculateCost(model, output.usage);
 	}
 }
@@ -673,12 +714,24 @@ function buildSystemPrompt(
 	return blocks;
 }
 
+function convertToolResultContent(
+	content: ToolResultMessage["content"],
+	supportsImages: boolean,
+): Array<TextBlockWire | ImageBlockWire> {
+	return content.map(c => {
+		if (c.type !== "image") return { text: c.text.toWellFormed() };
+		if (!supportsImages) return { text: NON_VISION_IMAGE_PLACEHOLDER };
+		return { image: createImageBlock(c.mimeType, c.data) };
+	});
+}
+
 function convertMessages(
 	context: Context,
 	model: Model<"bedrock-converse-stream">,
 	cacheRetention: CacheRetention,
 ): WireMessage[] {
 	const result: WireMessage[] = [];
+	const supportsImages = model.input.includes("image");
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
 
 	for (let i = 0; i < transformedMessages.length; i++) {
@@ -702,7 +755,11 @@ function convertMessages(
 								break;
 							}
 							case "image":
-								contentBlocks.push({ image: createImageBlock(c.mimeType, c.data) });
+								contentBlocks.push(
+									supportsImages
+										? { image: createImageBlock(c.mimeType, c.data) }
+										: { text: NON_VISION_IMAGE_PLACEHOLDER },
+								);
 								break;
 							default:
 								throw new Error("Unknown user content type");
@@ -772,11 +829,7 @@ function convertMessages(
 				toolResults.push({
 					toolResult: {
 						toolUseId: normalizeToolCallId(m.toolCallId),
-						content: m.content.map(c =>
-							c.type === "image"
-								? { image: createImageBlock(c.mimeType, c.data) }
-								: { text: c.text.toWellFormed() },
-						),
+						content: convertToolResultContent(m.content, supportsImages),
 						status: m.isError ? "error" : "success",
 					},
 				});
@@ -787,11 +840,7 @@ function convertMessages(
 					toolResults.push({
 						toolResult: {
 							toolUseId: normalizeToolCallId(nextMsg.toolCallId),
-							content: nextMsg.content.map(c =>
-								c.type === "image"
-									? { image: createImageBlock(c.mimeType, c.data) }
-									: { text: c.text.toWellFormed() },
-							),
+							content: convertToolResultContent(nextMsg.content, supportsImages),
 							status: nextMsg.isError ? "error" : "success",
 						},
 					});
@@ -820,10 +869,18 @@ function convertMessages(
 	return result;
 }
 
-export function stripBedrockForcedToolChoiceForRetry<T extends { toolConfig?: { toolChoice?: unknown } }>(body: T): T {
+export function stripBedrockForcedToolChoiceForRetry<
+	T extends { toolConfig?: { toolChoice?: unknown }; additionalModelRequestFields?: Record<string, unknown> },
+>(body: T, thinking?: { forced: Record<string, unknown> | undefined; restored: Record<string, unknown> }): T {
 	if (body.toolConfig) {
 		body.toolConfig = { ...body.toolConfig, toolChoice: undefined };
 	}
+	// The forced request replaced the selected thinking fields with a disabled block; with the
+	// forced constraint gone, put the selected reasoning back. A payload the caller replaced via
+	// onPayload (not the object this provider sent) is left untouched.
+	if (thinking && body.additionalModelRequestFields === thinking.forced) {
+		body.additionalModelRequestFields = thinking.restored;
+	}
 	return body;
 }
 
@@ -879,6 +936,9 @@ function buildAdditionalModelRequestFields(
 	options: BedrockOptions,
 ): Record<string, unknown> | undefined {
 	const reasoning = options.reasoning;
+	if (requiresAnthropicThinkingDisableWhenOff(model.id) && (!reasoning || !model.reasoning)) {
+		return { thinking: { type: "disabled" } };
+	}
 	if (!reasoning || !model.reasoning) return undefined;
 
 	const mode = model.thinking?.mode;

package/src/providers/anthropic.d.ts

@@ -51,6 +51,16 @@ export declare function isAnthropicThinkingBlockMutationError(error: unknown): b
  * than only the latest one.
  */
 export declare function isAnthropicThinkingSignatureInvalidError(error: unknown): boolean;
+/**
+ * 400 shape where Anthropic cannot decode one of the request's images:
+ * `{"type":"invalid_request_error","message":"Could not process image"}`.
+ * Observed for a truncated JPEG (no end-of-image marker) that local resizing
+ * also failed to decode and therefore forwarded unchanged. The body names no
+ * image, and the image stays in history, so without omission every later
+ * request of the session draws the same rejection.
+ */
+export declare function isAnthropicImageUnprocessableError(error: unknown): boolean;
+export declare const ANTHROPIC_OMITTED_IMAGE_PLACEHOLDER = "[Image omitted: Anthropic could not process this image. The file may be corrupt or truncated; re-export or convert it before attaching it again.]";
 /**
  * CLIProxyAPI replaces Anthropic's rejection body wholesale instead of forwarding
  * it: the client only ever sees
@@ -107,6 +117,14 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
+/**
+ * How many breakpoints we are still willing to generate after a gateway has
+ * rejected a previous attempt. `explicit` mode normally emits two (a reusable
+ * prefix anchor on the last assistant turn plus a refresh point on the current
+ * user turn), so stepping down to one still caches the prefix, and only the
+ * final step gives caching up entirely.
+ */
+type GeneratedCacheBudget = 2 | 1 | 0;
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
@@ -218,6 +236,8 @@ export type AnthropicClientOptionsResult = {
     fetchOptions?: AnthropicSdkClientOptions["fetchOptions"];
 };
 export declare function resolveGlmZcodeAnthropicBaseUrl(): string;
+/** Compresses request bodies with gzip for first-party Anthropic endpoints only. */
+export declare function wrapAnthropicFetchForGzip(baseFetch: FetchImpl): FetchImpl;
 export declare function isProviderRetryableError(error: unknown, provider?: string): boolean;
 export type AnthropicUsageLike = {
     cache_creation?: {
@@ -251,6 +271,11 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+type AnthropicCacheParams = MessageCreateParamsStreaming & {
+    cache_control?: AnthropicCacheControl;
+};
+type AnthropicCacheMode = "automatic" | "explicit" | "none";
+export declare function applyPromptCaching(params: AnthropicCacheParams, cacheMode: AnthropicCacheMode, cacheControl?: AnthropicCacheControl, budget?: GeneratedCacheBudget): void;
 export declare function normalizeCacheControlTtlOrdering(params: MessageCreateParamsStreaming): void;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, options?: {
     repairLatestAssistantThinking?: boolean;