agent-accelerator 0.5.0 → 0.5.2

package/src/providers/openai-compat.ts

@@ -18,9 +18,8 @@
  *   (groq, ollama, …) fail unknown body properties, so anything unsupported
  *   is warn+drop, never sent.
  * - `text`, `image_url`, and `input_audio` parts are sent; `video`/`file`
- *   parts fail fast with a one-line error naming the remedy (files point at
- *   `convertDocumentToMarkdown`). The old transport let these through to
- *   confusing provider 400s.
+ *   parts fail fast with a one-line error naming the remedy. The old transport
+ *   let these through to confusing provider 400s.
  * - Prior-turn reasoning is NOT resent (chat history is messages + tool calls
  *   only), except echoed Gemini thought signatures (see below).
  * - Gemini models served through OpenAI-compatible endpoints keep working:
@@ -81,7 +80,7 @@ import {
 } from "./shared.ts";
 import { getModelFromCatalog, createGenericModelSpec, modelSupportsStructuredOutput } from "../models/catalog.ts";
 import {
-  applyCacheForCustom,
+  resolveCache,
   mapToolChoiceToOpenAI,
   emitProviderWarning,
   noteProviderTurn,
@@ -91,6 +90,7 @@ import {
   mapGenerationParamsToChat,
   normalizeStructuredOutput,
   augmentSystemPromptWithStructuredOutput,
+  warnIgnoredMediaResolution,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -182,13 +182,6 @@ interface ChatResponse {
   [k: string]: unknown;
 }
 
-/** Headers that must never leak onto native REST requests. */
-const INTERNAL_HEADERS = new Set([
-  "x-thought-signature-map",
-  "x-cached-content-id",
-  "x-multimodal-user-content",
-]);
-
 // ---------------------------------------------------------------------------
 // Request building (canonical -> Chat Completions)
 // ---------------------------------------------------------------------------
@@ -345,7 +338,7 @@ function assertNoVideoOrFileParts(
   const message =
     kind === "video"
       ? `[${prefix}/${modelId}] unsupported video input (generic OpenAI-compatible endpoints carry text/image/audio only). Use a video-capable model (e.g. google/gemini-*) or drop the video part.`
-      : `[${prefix}/${modelId}] unsupported file input (generic OpenAI-compatible endpoints carry text/image/audio only). Convert the document to Markdown with the convert_document_to_markdown tool (or Agent bypassInputFileModality) and send it as text instead.`;
+      : `[${prefix}/${modelId}] unsupported file input (generic OpenAI-compatible endpoints carry text/image/audio only). Use a file-capable model (e.g. google/gemini-*) or convert the document to text before sending it.`;
   const err = new Error(message);
   err.name = "AgentAccelProviderError";
   Object.defineProperties(err, {
@@ -710,7 +703,9 @@ export class OpenAICompatibleChatProvider implements Provider {
         fallback: "standard routing (no service_tier payload is sent)",
       });
     }
-    applyCacheForCustom(this.prefix, options?.cache, `${this.prefix}/${modelId}`);
+    // Strict endpoints reject unknown body fields: implicit caching only.
+    resolveCache(this.prefix, options?.cache, ["implicit"], `${this.prefix}/${modelId}`);
+    warnIgnoredMediaResolution(this.prefix, context.messages, `${this.prefix}/${modelId}`);
 
     // Structured outputs: native `response_format` when supported, else
     // emulated via system prompt (strict endpoints would 400 on json_schema
@@ -796,13 +791,9 @@ export class OpenAICompatibleChatProvider implements Provider {
   ): RequestInit {
     const headers: Record<string, string> = buildSessionHeaders(
       this.prefix,
-      options?.cache,
       options?.headers,
       sessionId
     );
-    for (const [k, v] of Object.entries(headers)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete headers[k];
-    }
     // Strict-endpoint opt-out (pi sendSessionAffinityHeaders pattern):
     // `COMPAT_NO_SESSION_HEADERS=1` or per-call `sendSessionHeaders:false`
     // drops affinity headers that trigger CORS preflights / strict 400s.
@@ -891,18 +882,15 @@ export class OpenAICompatibleChatProvider implements Provider {
     const baseUrl = this.baseUrl(options);
     const apiKey = this.requireApiKey(baseUrl, options);
     const url = `${baseUrl}/chat/completions`;
-    const sessionId = options?.sessionId || options?.cache?.sessionId;
+    const sessionId = options?.sessionId;
     const tools = options?.tools as StandardToolDeclaration[] | undefined;
     const body = await this.buildBody(clean, context, options, tools, false);
 
     const auditRaw: Record<string, string> = {
-      ...buildSessionHeaders(this.prefix, options?.cache, options?.headers, sessionId),
+      ...buildSessionHeaders(this.prefix, options?.headers, sessionId),
       "Content-Type": "application/json",
       ...(apiKey ? { Authorization: "[REDACTED]" } : {}),
     };
-    for (const k of Object.keys(auditRaw)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete auditRaw[k];
-    }
     const rawRequest = {
       url,
       method: "POST",
@@ -986,18 +974,15 @@ export class OpenAICompatibleChatProvider implements Provider {
         const baseUrl = this.baseUrl(options);
         const apiKey = this.requireApiKey(baseUrl, options);
         const url = `${baseUrl}/chat/completions`;
-        const sessionId = options?.sessionId || options?.cache?.sessionId;
+        const sessionId = options?.sessionId;
         const tools = options?.tools as StandardToolDeclaration[] | undefined;
         const body = await this.buildBody(clean, context, options, tools, true);
 
         const streamAuditRaw: Record<string, string> = {
-          ...buildSessionHeaders(prefix, options?.cache, options?.headers, sessionId),
+          ...buildSessionHeaders(prefix, options?.headers, sessionId),
           "Content-Type": "application/json",
           ...(apiKey ? { Authorization: "[REDACTED]" } : {}),
         };
-        for (const k of Object.keys(streamAuditRaw)) {
-          if (INTERNAL_HEADERS.has(k.toLowerCase())) delete streamAuditRaw[k];
-        }
         const rawRequest = {
           url,
           method: "POST",

package/src/providers/openai.ts

@@ -75,7 +75,7 @@ import { getModelFromCatalog, getModelsForProvider, modelSupportsStructuredOutpu
 import {
   mapThinkingLevelToOpenAI,
   mapServiceTierToOpenAI,
-  applyCacheForOpenAI,
+  resolveCache,
   mapToolChoiceToOpenAI,
   noteProviderTurn,
   parseStreamedToolArguments,
@@ -85,6 +85,7 @@ import {
   normalizeStructuredOutput,
   augmentSystemPromptWithStructuredOutput,
   emitProviderWarning,
+  warnIgnoredMediaResolution,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -156,19 +157,6 @@ interface ResponsesObject {
 
 const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 
-/** Q-18: Responses transport never echoes thought signatures (no wire field).
- * Local helper documents the namespacing decision per provider file. */
-function withProviderSignature(_sig: string | undefined): { thoughtSignature?: undefined } {
-  return {};
-}
-
-/** Internal headers that must never leak onto native REST requests. */
-const INTERNAL_HEADERS = new Set([
-  "x-thought-signature-map",
-  "x-cached-content-id",
-  "x-multimodal-user-content",
-]);
-
 // ---------------------------------------------------------------------------
 // Request building (canonical -> Responses)
 // ---------------------------------------------------------------------------
@@ -535,7 +523,9 @@ export class OpenAIResponsesProvider implements Provider {
   ): Promise<ResponsesRequestBody> {
     const { effort } = mapThinkingLevelToOpenAI(options?.thinking?.level);
     const serviceTier = mapServiceTierToOpenAI(options?.serviceTier);
-    applyCacheForOpenAI(options?.cache, `openai/${modelId}`);
+    // `12h` maps to `prompt_cache_retention: "24h"`; everything else stays on implicit prompt_cache_key affinity.
+    const cache = resolveCache("openai", options?.cache, ["implicit", "12h"], `openai/${modelId}`);
+    warnIgnoredMediaResolution("openai", context.messages, `openai/${modelId}`);
 
     // Structured outputs: native `text.format` when supported, else emulated
     // via instructions (catalog `structured_output: false` would 400).
@@ -598,10 +588,8 @@ export class OpenAIResponsesProvider implements Provider {
       const cacheKey = clampCacheKey(sessionId);
       if (cacheKey) body.prompt_cache_key = cacheKey;
     }
-    // Long retention: `prompt_cache_retention: "24h"` when the catalog
-    // supports it (pi api/openai-responses.ts:97 rule). Other explicit modes
-    // stay warn+drop via applyCacheForOpenAI above.
-    if (options?.cache?.retention === "long") {
+    // Long retention: `prompt_cache_retention: "24h"` when the catalog supports it.
+    if (cache === "12h") {
       let supportsLong = true;
       try {
         const spec = getModelFromCatalog("openai", modelId);
@@ -614,8 +602,8 @@ export class OpenAIResponsesProvider implements Provider {
       } else {
         emitProviderWarning({
           provider: "openai",
-          capability: "cache retention",
-          requested: `long (openai/${modelId})`,
+          capability: "cache",
+          requested: `12h (openai/${modelId})`,
           reason: "the catalog reports no long-cache support for this model.",
           fallback: "default caching with prompt_cache_key affinity (no retention payload is sent)",
         });
@@ -635,13 +623,9 @@ export class OpenAIResponsesProvider implements Provider {
   ): RequestInit {
     const headers: Record<string, string> = buildSessionHeaders(
       "openai",
-      options?.cache,
       options?.headers,
       sessionId
     );
-    for (const [k, v] of Object.entries(headers)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete headers[k];
-    }
     // Case-insensitive merge so a lowercase `authorization` custom header
     // never coexists with the canonical bearer. Proxy flows
     // (`apiKey === "unused"`) preserve custom auth instead of overwriting.
@@ -723,7 +707,7 @@ export class OpenAIResponsesProvider implements Provider {
     assertNoVideoPartsOnResponses(context, "openai", clean);
     const baseUrl = resolveBaseUrl(options);
     const url = `${baseUrl}/responses`;
-    const sessionId = options?.sessionId || options?.cache?.sessionId;
+    const sessionId = options?.sessionId;
     const tools = options?.tools as StandardToolDeclaration[] | undefined;
     const body = await this.buildBody(clean, context, options, sessionId, tools, false);
 
@@ -731,13 +715,10 @@ export class OpenAIResponsesProvider implements Provider {
     // redacted. Previously only Content-Type + custom headers were stored,
     // hiding the x-session-id affinity actually sent.
     const auditHeadersRaw: Record<string, string> = {
-      ...buildSessionHeaders("openai", options?.cache, options?.headers, sessionId),
+      ...buildSessionHeaders("openai", options?.headers, sessionId),
       "Content-Type": "application/json",
       Authorization: "[REDACTED]",
     };
-    for (const k of Object.keys(auditHeadersRaw)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete auditHeadersRaw[k];
-    }
     const auditHeaders = redactedHeaders(auditHeadersRaw);
     const rawRequest = {
       url,
@@ -825,18 +806,15 @@ export class OpenAIResponsesProvider implements Provider {
     assertNoVideoPartsOnResponses(context, "openai", clean);
         const baseUrl = resolveBaseUrl(options);
         const url = `${baseUrl}/responses`;
-        const sessionId = options?.sessionId || options?.cache?.sessionId;
+        const sessionId = options?.sessionId;
         const tools = options?.tools as StandardToolDeclaration[] | undefined;
         const body = await this.buildBody(clean, context, options, sessionId, tools, true);
 
         const streamAuditRaw: Record<string, string> = {
-          ...buildSessionHeaders("openai", options?.cache, options?.headers, sessionId),
+          ...buildSessionHeaders("openai", options?.headers, sessionId),
           "Content-Type": "application/json",
           Authorization: "[REDACTED]",
         };
-        for (const k of Object.keys(streamAuditRaw)) {
-          if (INTERNAL_HEADERS.has(k.toLowerCase())) delete streamAuditRaw[k];
-        }
         const rawRequest = {
           url,
           method: "POST",

package/src/providers/openrouter.ts

@@ -67,7 +67,7 @@ import { getModelFromCatalog, getModelsForProvider, modelSupportsStructuredOutpu
 import {
   mapThinkingLevelToOpenRouterChat,
   mapServiceTierToOpenRouter,
-  applyCacheForOpenRouter,
+  resolveCache,
   mapToolChoiceToOpenRouterChat,
   noteProviderTurn,
   parseStreamedToolArguments,
@@ -77,6 +77,7 @@ import {
   normalizeStructuredOutput,
   augmentSystemPromptWithStructuredOutput,
   emitProviderWarning,
+  warnIgnoredMediaResolution,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -115,6 +116,7 @@ interface ChatRequestBody {
   service_tier?: string;
   session_id?: string;
   plugins?: Array<{ id: string }>;
+  cache_control?: { type: "ephemeral"; ttl: "5m" | "1h" };
   response_format?: { type: "json_schema"; json_schema: { name: string; schema: Record<string, unknown>; strict: boolean; description?: string } };
   stream?: boolean;
   [k: string]: unknown;
@@ -180,19 +182,6 @@ interface ChatResponse {
 
 const DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
 
-/** Q-18: Chat transport never echoes thought signatures (no wire field).
- * Local helper documents the namespacing decision per provider file. */
-function withProviderSignature(_sig: string | undefined): { thoughtSignature?: undefined } {
-  return {};
-}
-
-/** Internal headers that must never leak onto native REST requests. */
-const INTERNAL_HEADERS = new Set([
-  "x-thought-signature-map",
-  "x-cached-content-id",
-  "x-multimodal-user-content",
-]);
-
 // ---------------------------------------------------------------------------
 // Request building (canonical -> Chat Completions)
 // ---------------------------------------------------------------------------
@@ -586,7 +575,9 @@ export class OpenRouterChatCompletionsProvider implements Provider {
   ): Promise<ChatRequestBody> {
     const { effort } = mapThinkingLevelToOpenRouterChat(options?.thinking?.level);
     const serviceTier = mapServiceTierToOpenRouter(options?.serviceTier);
-    applyCacheForOpenRouter(options?.cache, `openrouter/${modelId}`);
+    // Anthropic models take a top-level `cache_control` TTL; every other route caches implicitly (docs: prompt-caching.md).
+    const cache = resolveCache("openrouter", options?.cache, modelId.startsWith("anthropic/") ? ["implicit", "5m", "1h"] : ["implicit"], `openrouter/${modelId}`);
+    warnIgnoredMediaResolution("openrouter", context.messages, `openrouter/${modelId}`);
 
     // Structured outputs: native `response_format` when supported, else
     // emulated via system-prompt instruction + client validation (catalog
@@ -628,6 +619,7 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     if (toolChoice !== undefined) body.tool_choice = toolChoice;
     if (effort) body.reasoning = { effort };
     if (serviceTier) body.service_tier = serviceTier;
+    if (cache === "5m" || cache === "1h") body.cache_control = { type: "ephemeral", ttl: cache };
     // Documented Chat Completions generation controls (only those the caller set).
     Object.assign(body, mapGenerationParamsToChat(options));
     // Structured outputs: Chat Completions `response_format{type:json_schema,json_schema}`.
@@ -665,13 +657,9 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     // (HTTP-Referer / X-Title / x-session-id / x-client-request-id).
     const headers: Record<string, string> = buildSessionHeaders(
       "openrouter",
-      options?.cache,
       options?.headers,
       sessionId
     );
-    for (const [k, v] of Object.entries(headers)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete headers[k];
-    }
     setHeaderCaseInsensitive(headers, "Content-Type", "application/json");
     if (apiKey !== "unused") setHeaderCaseInsensitive(headers, "Authorization", `Bearer ${apiKey}`);
     return { method: "POST", headers, body: JSON.stringify(body), signal };
@@ -747,20 +735,17 @@ export class OpenRouterChatCompletionsProvider implements Provider {
     assertModalitiesSupported(context, "openrouter", clean);
     const baseUrl = resolveBaseUrl(options);
     const url = `${baseUrl}/chat/completions`;
-    const sessionId = options?.sessionId || options?.cache?.sessionId;
+    const sessionId = options?.sessionId;
     const tools = options?.tools as StandardToolDeclaration[] | undefined;
     const body = await this.buildBody(clean, context, options, sessionId, tools, false);
 
     // Audit trail: record the actual wire headers (attribution + session
     // affinity included), redacted.
     const auditRaw: Record<string, string> = {
-      ...buildSessionHeaders("openrouter", options?.cache, options?.headers, sessionId),
+      ...buildSessionHeaders("openrouter", options?.headers, sessionId),
       "Content-Type": "application/json",
       Authorization: "[REDACTED]",
     };
-    for (const k of Object.keys(auditRaw)) {
-      if (INTERNAL_HEADERS.has(k.toLowerCase())) delete auditRaw[k];
-    }
     const rawRequest = {
       url,
       method: "POST",
@@ -846,18 +831,15 @@ export class OpenRouterChatCompletionsProvider implements Provider {
         assertModalitiesSupported(context, "openrouter", clean);
         const baseUrl = resolveBaseUrl(options);
         const url = `${baseUrl}/chat/completions`;
-        const sessionId = options?.sessionId || options?.cache?.sessionId;
+        const sessionId = options?.sessionId;
         const tools = options?.tools as StandardToolDeclaration[] | undefined;
         const body = await this.buildBody(clean, context, options, sessionId, tools, true);
 
         const streamAuditRaw: Record<string, string> = {
-          ...buildSessionHeaders("openrouter", options?.cache, options?.headers, sessionId),
+          ...buildSessionHeaders("openrouter", options?.headers, sessionId),
           "Content-Type": "application/json",
           Authorization: "[REDACTED]",
         };
-        for (const k of Object.keys(streamAuditRaw)) {
-          if (INTERNAL_HEADERS.has(k.toLowerCase())) delete streamAuditRaw[k];
-        }
         const rawRequest = {
           url,
           method: "POST",

package/src/providers.ts

@@ -9,8 +9,9 @@
  * Rule: OpenAI, OpenRouter, and future providers must be addable here without
  * redesigning this abstraction — only new per-provider mappers/adapters.
  */
-import type { CacheConfig, ServiceTier, ThinkingLevel } from "./types/core.ts";
+import type { CacheOption, ServiceTier, ThinkingLevel } from "./types/core.ts";
 import type { StructuredOutputSpec } from "./types/model.ts";
+import type { Message } from "./types/message.ts";
 import { zodToJsonSchema } from "./tools/schema.ts";
 import { ValidationError } from "./types/errors.ts";
 import { TRUNCATED_ARGS_KEY } from "./types/tool.ts";
@@ -30,14 +31,14 @@ export type ProviderCapabilityStatus =
  * There is no pre-existing logger in `src/` (only CLI logs in
  * `update-models.ts`), so this `console.warn` line IS the mechanism — do not
  * introduce a second one. Used when a requested capability cannot be applied
- * as-is (e.g. Google explicit cache retention) so it never silently
+ * as-is (e.g. an unsupported `cache` TTL) so it never silently
  * disappears.
  *
  * Warnings are deduped per provider+capability+requested: agent loops call
  * mappers once per turn, and repeating the same warning every turn is noise.
  * A repeated identical request logs once per process.
  *
- * @example `emitProviderWarning({ provider: "google", capability: "cache retention", requested: "high", reason: "...", fallback: "..." })`
+ * @example `emitProviderWarning({ provider: "google", capability: "cache", requested: "12h", reason: "...", fallback: "..." })`
  */
 const emittedWarnings = new Set<string>();
 
@@ -229,68 +230,37 @@ export function mapServiceTierToOpenRouter(tier: ServiceTier | undefined): "flex
   return undefined;
 }
 
-/**
- * Applies canonical cache config for OpenRouter. Session affinity flows via
- * top-level body `session_id` (sent by the adapter) plus the `x-session-id`
- * header fallback; there is no retention body primitive, so explicit
- * retention/cachedContentId are UNSUPPORTED: warn and drop.
- */
-export function applyCacheForOpenRouter(
-  cache: CacheConfig | undefined,
+/** Returns the `cache` value a provider will honour; an unsupported one warns once and falls back to the provider default (`undefined`). In: `ProviderRequestOptions.cache` from each adapter's buildBody, out: the adapter's wire mapping. */
+export function resolveCache(
+  provider: string,
+  cache: CacheOption | undefined,
+  supported: readonly CacheOption[],
   modelRef: string
-): void {
-  if (!cache) return;
-  if (cache.retention && cache.retention !== "implicit") {
-    emitProviderWarning({
-      provider: "openrouter",
-      capability: "cache retention",
-      requested: `${cache.retention} (${modelRef})`,
-      reason: "OpenRouter documents no retention control on the stable Chat Completions endpoint.",
-      fallback: "default gateway caching with headers-only session affinity (no retention payload is sent)",
-    });
-  }
-  if (cache.cachedContentId) {
-    emitProviderWarning({
-      provider: "openrouter",
-      capability: "explicit cached content",
-      requested: cache.cachedContentId,
-      reason: "cached content references do not exist on the Responses API.",
-      fallback: "full-history sends instead (cachedContentId is ignored)",
-    });
-  }
+): CacheOption | undefined {
+  if (cache === undefined || supported.includes(cache)) return cache;
+  emitProviderWarning({
+    provider,
+    capability: "cache",
+    requested: `${cache} (${modelRef})`,
+    reason: `supported values here are: ${supported.map((v) => `"${v}"`).join(", ")}.`,
+    fallback: "the provider default (implicit caching)",
+  });
+  return undefined;
 }
 
-/**
- * Applies canonical cache config for custom OpenAI-compatible endpoints.
- * Affinity is headers-only (`x-session-id`): unknown body properties make
- * strict endpoints (groq, ollama, …) fail, so nothing cache-related is ever
- * placed in the body. Explicit retention/cachedContentId are UNSUPPORTED:
- * warn and drop.
- */
-export function applyCacheForCustom(
-  prefix: string,
-  cache: CacheConfig | undefined,
-  modelRef: string
-): void {
-  if (!cache) return;
-  if (cache.retention && cache.retention !== "implicit") {
-    emitProviderWarning({
-      provider: prefix,
-      capability: "cache retention",
-      requested: `${cache.retention} (${modelRef})`,
-      reason: "custom OpenAI-compatible endpoints define no retention control, and strict endpoints reject unknown body properties.",
-      fallback: "default caching with headers-only session affinity (no retention payload is sent)",
-    });
-  }
-  if (cache.cachedContentId) {
-    emitProviderWarning({
-      provider: prefix,
-      capability: "explicit cached content",
-      requested: cache.cachedContentId,
-      reason: "cached content references do not exist on OpenAI-compatible endpoints.",
-      fallback: "full-history sends instead (cachedContentId is ignored)",
-    });
-  }
+/** Warns once per provider/model that per-media `resolution` is ignored (no such control on that wire); in: an adapter's request messages, out: telemetry bus only. */
+export function warnIgnoredMediaResolution(provider: string, messages: Message[], modelRef: string): void {
+  const used = messages.some(
+    (m) => Array.isArray(m.content) && m.content.some((p) => (p.type === "image" || p.type === "video") && p.resolution)
+  );
+  if (!used) return;
+  emitProviderWarning({
+    provider,
+    capability: "media resolution",
+    requested: modelRef,
+    reason: "this provider has no per-media detail control (Google only).",
+    fallback: "the provider's default detail",
+  });
 }
 
 /** OpenRouter Chat Completions `tool_choice` wire values. */
@@ -368,38 +338,6 @@ export function mapServiceTierToOpenAI(tier: ServiceTier | undefined): "flex" |
   return undefined;
 }
 
-/**
- * Applies canonical cache config for OpenAI. Session affinity flows via
- * `prompt_cache_key` (handled by the adapter); `long` retention maps to
- * `prompt_cache_retention: "24h"` when the catalog supports it (handled by
- * the adapter, pi `api/openai-responses.ts:97` rule). Other explicit
- * retention modes and `cachedContentId` are UNSUPPORTED: warn and drop.
- */
-export function applyCacheForOpenAI(
-  cache: CacheConfig | undefined,
-  modelRef: string
-): void {
-  if (!cache) return;
-  if (cache.retention && cache.retention !== "implicit" && cache.retention !== "long") {
-    emitProviderWarning({
-      provider: "openai",
-      capability: "cache retention",
-      requested: `${cache.retention} (${modelRef})`,
-      reason: "the native Responses adapter uses prompt_cache_key affinity only; explicit retention modes are out of scope.",
-      fallback: "default caching with prompt_cache_key affinity (no retention payload is sent)",
-    });
-  }
-  if (cache.cachedContentId) {
-    emitProviderWarning({
-      provider: "openai",
-      capability: "explicit cached content",
-      requested: cache.cachedContentId,
-      reason: "cached content references do not exist on the Responses API.",
-      fallback: "full-history sends instead (cachedContentId is ignored)",
-    });
-  }
-}
-
 /** OpenAI Responses `tool_choice` wire values (most-important subset). */
 export type OpenAIToolChoice = "auto" | "none" | "required" | { type: "function"; name: string };
 
@@ -419,36 +357,6 @@ export function mapToolChoiceToOpenAI(
   return undefined;
 }
 
-/**
- * Applies canonical cache config for Google. The Interactions API supports
- * implicit/automatic caching ONLY — there is no cache payload to send.
- * Explicit retention/cachedContentId are UNSUPPORTED: warn and drop.
- */
-export function applyCacheForGoogle(
-  cache: CacheConfig | undefined,
-  modelRef: string
-): void {
-  if (!cache) return;
-  if (cache.retention && cache.retention !== "implicit") {
-    emitProviderWarning({
-      provider: "google",
-      capability: "cache retention",
-      requested: `${cache.retention} (${modelRef})`,
-      reason: "the Interactions API does not support user-defined explicit cache retention.",
-      fallback: "Google automatic/implicit caching (no cache payload is sent)",
-    });
-  }
-  if (cache.cachedContentId) {
-    emitProviderWarning({
-      provider: "google",
-      capability: "explicit cached content",
-      requested: cache.cachedContentId,
-      reason: "cachedContents resources do not exist on the Interactions API.",
-      fallback: "stateful interaction chaining / stateless history instead (cachedContentId is ignored)",
-    });
-  }
-}
-
 /** Normalized tool-choice mode shared by provider adapters. */
 export type CanonicalToolChoiceMode = "auto" | "any" | "none";