@modelprofile.com/flexharness-models 10.13.0 → 10.14.0

package/dist_ts_models/plugins.d.ts

@@ -3,6 +3,6 @@ export { generateText, jsonSchema, RetryError, StreamProviderError, streamText,
 export type { ModelMessage, StreamTextResult, ToolSet } from 'ai';
 import { APICallError } from '@ai-sdk/provider';
 export { APICallError };
-export type { JSONObject, JSONValue, LanguageModelV3, LanguageModelV3Prompt, LanguageModelV4, LanguageModelV4Middleware, LanguageModelV4Prompt, LanguageModelV4StreamPart, SharedV4Headers, } from '@ai-sdk/provider';
+export type { JSONObject, JSONValue, LanguageModelV3, LanguageModelV3Prompt, LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4Middleware, LanguageModelV4Prompt, LanguageModelV4StreamPart, SharedV4Headers, } from '@ai-sdk/provider';
 import { isAbortError, isProviderStreamError } from '@ai-sdk/provider-utils';
 export { isAbortError, isProviderStreamError };

package/dist_ts_models/plugins.js

@@ -7,4 +7,4 @@ export { APICallError };
 // ai-sdk provider utilities
 import { isAbortError, isProviderStreamError } from '@ai-sdk/provider-utils';
 export { isAbortError, isProviderStreamError };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX21vZGVscy9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLElBQUksQ0FBQztBQUVqRyxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxDQUFDO0FBR3ZGLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDO0FBYXhCLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsWUFBWSxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFN0UsT0FBTyxFQUFFLFlBQVksRUFBRSxxQkFBcUIsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX21vZGVscy9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWM7QUFDZCxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxNQUFNLElBQUksQ0FBQztBQUVqRyxPQUFPLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxDQUFDO0FBR3ZGLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEQsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDO0FBY3hCLDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsWUFBWSxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFN0UsT0FBTyxFQUFFLFlBQVksRUFBRSxxQkFBcUIsRUFBRSxDQUFDIn0=

package/dist_ts_models/smartai.cache.d.ts

@@ -5,10 +5,37 @@ export type TSmartAiCacheRetention = 'ephemeral' | '1h' | 'in_memory' | '24h';
 export interface ISmartAiCacheOptions {
     /** Provider-specific message cache marker namespace. Usually inferred from the model. */
     provider?: TSmartAiMessageCacheProvider;
-    /** Stable session/request key for providers that support request-level prompt cache affinity. */
+    /**
+     * The OpenAI `prompt_cache_key`, sent as given. Without it the key is derived from the request's
+     * stable prefix, its instructions and tool definitions, so sessions that share a prefix share
+     * the provider's cache; see `deriveSmartAiPromptCacheKey`.
+     */
     key?: string;
-    /** Short retention is the default; longer retention is opt-in. */
+    /**
+     * Mixed into the derived key: requests of different scopes, such as tenants, never share a key,
+     * which keeps their cache routing and the provider's cache accounting apart.
+     */
+    keyScope?: string;
+    /**
+     * How many keys a derived key is spread over on OpenAI models that route by key (before GPT-5.6),
+     * each session keeping one. OpenAI suggests about 15 requests a minute per key, so size it as the
+     * prefix's peak requests a minute across all processes divided by 15. Defaults to 1.
+     */
+    keyBuckets?: number;
+    /**
+     * Anthropic: `'1h'` writes one-hour breakpoints instead of the five-minute default. OpenAI models
+     * before GPT-5.6: `'in_memory'` or `'24h'` is sent as `prompt_cache_retention`; without it the
+     * provider's default applies (24 hours, or in memory for Zero Data Retention organizations).
+     */
     retention?: TSmartAiCacheRetention;
+    /**
+     * Anthropic: the lifetime of the stable prefix's breakpoints, the tool definitions and system
+     * prompt, apart from the conversation's. `'1h'` (the default) keeps the prefix for sessions that
+     * start minutes apart while the growing conversation keeps five-minute breakpoints; writing it
+     * costs twice the input price instead of 1.25 times, once an hour on steady traffic.
+     * `'ephemeral'` writes it for five minutes. Never shorter than `retention`.
+     */
+    prefixRetention?: 'ephemeral' | '1h';
     /** Configured maximum idle scheduling budget, not a promise of cache retention or a cache hit. */
     warmDurationMs?: number;
 }
@@ -16,12 +43,62 @@ export type TSmartAiCacheSetting = boolean | 'auto' | ISmartAiCacheOptions;
 export declare function mergeSmartAiProviderOptions(defaults?: TSmartAiProviderOptions, overrides?: TSmartAiProviderOptions): TSmartAiProviderOptions | undefined;
 export declare function resolveSmartAiCacheProvider(provider?: string, modelId?: string): TSmartAiMessageCacheProvider | undefined;
 export declare function getSmartAiMessageCacheProviderOptions(provider: TSmartAiMessageCacheProvider, options?: ISmartAiCacheOptions): TSmartAiProviderOptions;
+type TSmartAiCacheableTool = NonNullable<plugins.LanguageModelV4CallOptions['tools']>[number];
 export declare function applySmartAiPromptCaching(prompt: plugins.LanguageModelV4Prompt, options?: ISmartAiCacheOptions): plugins.LanguageModelV4Prompt;
+/**
+ * Places cache markers on a request: its prompt and, for Anthropic, its tool definitions. See
+ * `planCacheMarkers` for where they go.
+ */
+export declare function applySmartAiRequestCaching<TRequest extends {
+    prompt: plugins.LanguageModelV4Prompt;
+    tools?: TSmartAiCacheableTool[];
+}>(request: TRequest, options?: ISmartAiCacheOptions): TRequest;
 export declare function createSmartAiCachingMiddleware(options?: ISmartAiCacheOptions): plugins.LanguageModelV4Middleware;
+/**
+ * OpenAI routes a request to the machine that holds its cached prefix by a hash of the prefix's
+ * first tokens and the `prompt_cache_key`, and a key is meant to carry about 15 requests a minute
+ * across all prefixes using it before traffic overflows to other machines
+ * (https://developers.openai.com/api/docs/guides/prompt-caching, "Prompt cache keys" and
+ * "Cache location", read 2026-10-07). `keyBuckets` is sized by it.
+ */
+export declare const OPENAI_PROMPT_CACHE_KEY_REQUESTS_PER_MINUTE = 15;
+/** A tool definition as a request sends it, for deriving a prompt cache key. */
+export interface ISmartAiPromptCacheTool {
+    type?: string;
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+    strict?: boolean;
+}
+/**
+ * A `prompt_cache_key` for the prefix every turn of a request repeats: its instructions and tool
+ * definitions, in the order they are sent, and the host's scope. Requests with the same prefix get
+ * the same key, so their sessions reach the machine holding it; any change to the prefix changes
+ * the key. A scope of letters, digits, `_` and `-` up to 40 characters stays readable in the key,
+ * any other is hashed. With `buckets`, sessions spread over that many keys, each keeping one, so a
+ * session's growing conversation stays with the machine that caches it.
+ */
+export declare function deriveSmartAiPromptCacheKey(input: {
+    system?: string;
+    tools?: readonly ISmartAiPromptCacheTool[];
+    scope?: string;
+    /** With `buckets` above 1: the session, which keeps its bucket for every request it sends. */
+    affinity?: string;
+    buckets?: number;
+}): string;
+/**
+ * Whether an OpenAI model routes its prompt cache by itself: from GPT-5.6 on the key only separates
+ * cache accounting (https://developers.openai.com/api/docs/guides/prompt-caching, "Summary of model
+ * differences", read 2026-10-07). Earlier and unrecognized models are routed by the key.
+ */
+export declare function openAiRoutesPromptCacheAutomatically(modelId: string | undefined): boolean;
 export declare function getSmartAiCacheProviderOptions(input: {
     provider?: string;
     modelId?: string;
     cache?: TSmartAiCacheSetting;
+    /** The derived `prompt_cache_key` (`deriveSmartAiPromptCacheKey`); a configured `key` takes precedence. */
+    promptCacheKey?: string;
+    /** The key used when neither a configured nor a derived key is given. */
     sessionId?: string;
 }): TSmartAiProviderOptions | undefined;
 export declare function applySmartAiCacheProviderOptions(input: {
@@ -29,6 +106,7 @@ export declare function applySmartAiCacheProviderOptions(input: {
     modelId?: string;
     providerOptions?: TSmartAiProviderOptions;
     cache?: TSmartAiCacheSetting;
+    promptCacheKey?: string;
     sessionId?: string;
 }): TSmartAiProviderOptions | undefined;
 /** Observation at the model dispatch boundary; no field certifies a cache write or hit. */

package/dist_ts_models/smartai.cache.js

@@ -126,37 +126,181 @@ function applyCacheToMessage(message, provider, options) {
     }
     return applyProviderOptionsDefaults(message, providerOptions);
 }
-export function applySmartAiPromptCaching(prompt, options = {}) {
-    const provider = options.provider ?? 'anthropic';
-    const targetIndexes = new Set();
-    const nonSystemIndexes = [];
-    let systemCount = 0;
-    for (let i = 0; i < prompt.length; i++) {
-        const message = prompt[i];
-        if (message.role === 'system') {
-            if (systemCount < 2)
-                targetIndexes.add(i);
-            systemCount++;
+/** Anthropic accepts at most four cache breakpoints per request; the AI SDK ignores any beyond. */
+const MAX_CACHE_MARKERS = 4;
+/** Whether a message, one of its parts, or a tool already carries a caller's cache marker. */
+function hasCacheMarker(item, provider) {
+    if (!item)
+        return false;
+    const [namespace, controls] = Object.entries(getSmartAiMessageCacheProviderOptions(provider))[0];
+    const caller = item.providerOptions?.[namespace];
+    return isObject(caller) && (Object.keys(controls).some((key) => Object.prototype.hasOwnProperty.call(caller, key))
+        || (namespace === 'anthropic' && Object.prototype.hasOwnProperty.call(caller, 'cache_control')));
+}
+function cacheMarkerCount(message, provider) {
+    const own = hasCacheMarker(message, provider) ? 1 : 0;
+    const parts = Array.isArray(message.content)
+        ? message.content.filter((part) => hasCacheMarker(part, provider)).length
+        : 0;
+    return own + parts;
+}
+/**
+ * Where a request's cache markers go, within the provider's limit of four, counting markers a
+ * caller set itself. The first two system messages are the stable ones (later system messages may
+ * carry per-request content); the second, or the only one, ends the stable prefix and also caches
+ * the tool definitions rendered before it. Without a system message the last tool definition ends
+ * the prefix. In order: that end of the prefix, the last message, the message before it (the rolling
+ * breakpoints of a growing conversation), and the first system message.
+ */
+function planCacheMarkers(prompt, tools, provider) {
+    const marked = new Set();
+    const plan = { messages: new Set(), prefixMessages: new Set(), callerMarkers: 0 };
+    // The provider counts every block that carries a marker: a message's own and each marked part.
+    prompt.forEach((message, index) => {
+        const blocks = cacheMarkerCount(message, provider);
+        if (blocks > 0)
+            marked.add(index);
+        plan.callerMarkers += blocks;
+    });
+    const markedTools = (tools ?? []).filter((definition) => hasCacheMarker(definition, provider)).length;
+    const toolMarked = markedTools > 0;
+    plan.callerMarkers += markedTools;
+    let budget = MAX_CACHE_MARKERS - plan.callerMarkers;
+    const system = prompt.flatMap((message, index) => message.role === 'system' ? [index] : []).slice(0, 2);
+    const nonSystem = prompt.flatMap((message, index) => message.role === 'system' ? [] : [index]);
+    const rolling = nonSystem.slice(-2).reverse();
+    // A one-hour prefix marker must precede every five-minute one.
+    const isPrefix = (index) => rolling.every((rollingIndex) => index < rollingIndex) ? true : undefined;
+    const candidates = [];
+    if (system.length > 0) {
+        candidates.push({ message: system[system.length - 1], prefix: isPrefix(system[system.length - 1]) });
+    }
+    else if (provider === 'anthropic' && tools && tools.length > 0 && !toolMarked) {
+        candidates.push({ tool: tools.length - 1 });
+    }
+    for (const index of rolling)
+        candidates.push({ message: index });
+    if (system.length > 1)
+        candidates.push({ message: system[0], prefix: isPrefix(system[0]) });
+    for (const candidate of candidates) {
+        if ('tool' in candidate) {
+            if (budget <= 0)
+                continue;
+            plan.tool = candidate.tool;
+            budget--;
             continue;
         }
-        nonSystemIndexes.push(i);
-    }
-    for (const index of nonSystemIndexes.slice(-2)) {
-        targetIndexes.add(index);
+        if (plan.messages.has(candidate.message))
+            continue;
+        if (!marked.has(candidate.message)) {
+            if (budget <= 0)
+                continue;
+            budget--;
+        }
+        plan.messages.add(candidate.message);
+        if (candidate.prefix)
+            plan.prefixMessages.add(candidate.message);
     }
-    if (targetIndexes.size === 0)
-        return prompt;
-    return prompt.map((message, index) => targetIndexes.has(index) ? applyCacheToMessage(message, provider, options) : message);
+    return plan;
+}
+export function applySmartAiPromptCaching(prompt, options = {}) {
+    return applySmartAiRequestCaching({ prompt }, options).prompt;
+}
+/**
+ * Places cache markers on a request: its prompt and, for Anthropic, its tool definitions. See
+ * `planCacheMarkers` for where they go.
+ */
+export function applySmartAiRequestCaching(request, options = {}) {
+    const provider = options.provider ?? 'anthropic';
+    const plan = planCacheMarkers(request.prompt, request.tools, provider);
+    // A one-hour breakpoint must precede five-minute ones: the prefix never lives shorter than the
+    // rest, and a caller's own markers, whose lifetimes and places are its own, keep the prefix at the
+    // request's retention.
+    const prefixOptions = options.retention === '1h'
+        || ((options.prefixRetention ?? '1h') === '1h' && plan.callerMarkers === 0)
+        ? { ...options, retention: '1h' }
+        : options;
+    const prompt = plan.messages.size === 0
+        ? request.prompt
+        : request.prompt.map((message, index) => plan.messages.has(index)
+            ? applyCacheToMessage(message, provider, plan.prefixMessages.has(index) ? prefixOptions : options)
+            : message);
+    const tools = plan.tool === undefined || !request.tools
+        ? request.tools
+        : request.tools.map((definition, index) => index === plan.tool
+            ? applyProviderOptionsDefaults(definition, getSmartAiMessageCacheProviderOptions(provider, prefixOptions))
+            : definition);
+    return { ...request, prompt, ...(tools ? { tools } : {}) };
 }
 export function createSmartAiCachingMiddleware(options = {}) {
     return {
         specificationVersion: 'v4',
-        transformParams: async ({ params }) => ({
-            ...params,
-            prompt: applySmartAiPromptCaching(params.prompt, options),
-        }),
+        transformParams: async ({ params }) => applySmartAiRequestCaching(params, options),
     };
 }
+/**
+ * OpenAI routes a request to the machine that holds its cached prefix by a hash of the prefix's
+ * first tokens and the `prompt_cache_key`, and a key is meant to carry about 15 requests a minute
+ * across all prefixes using it before traffic overflows to other machines
+ * (https://developers.openai.com/api/docs/guides/prompt-caching, "Prompt cache keys" and
+ * "Cache location", read 2026-10-07). `keyBuckets` is sized by it.
+ */
+export const OPENAI_PROMPT_CACHE_KEY_REQUESTS_PER_MINUTE = 15;
+const hash64 = (text) => {
+    // Two 32-bit FNV-1a lanes: a routing key needs a stable digest, not a cryptographic one.
+    let low = 0x811c9dc5;
+    let high = 0xcbf29ce4;
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        low = Math.imul(low ^ code, 0x01000193) >>> 0;
+        high = Math.imul(high ^ code ^ (low >>> 7), 0x01000193) >>> 0;
+    }
+    return high.toString(16).padStart(8, '0') + low.toString(16).padStart(8, '0');
+};
+/**
+ * A `prompt_cache_key` for the prefix every turn of a request repeats: its instructions and tool
+ * definitions, in the order they are sent, and the host's scope. Requests with the same prefix get
+ * the same key, so their sessions reach the machine holding it; any change to the prefix changes
+ * the key. A scope of letters, digits, `_` and `-` up to 40 characters stays readable in the key,
+ * any other is hashed. With `buckets`, sessions spread over that many keys, each keeping one, so a
+ * session's growing conversation stays with the machine that caches it.
+ */
+export function deriveSmartAiPromptCacheKey(input) {
+    const prefix = hash64(JSON.stringify([
+        input.system ?? '',
+        (input.tools ?? []).map((definition) => [
+            definition.type ?? 'function',
+            definition.name,
+            definition.description ?? '',
+            definition.inputSchema ?? null,
+            definition.strict ?? null,
+        ]),
+    ]));
+    const buckets = input.buckets ?? 1;
+    if (!Number.isSafeInteger(buckets) || buckets < 1)
+        throw new Error('keyBuckets must be a positive integer.');
+    const bucket = buckets > 1 && input.affinity !== undefined
+        ? Number.parseInt(hash64(input.affinity).slice(8), 16) % buckets
+        : 0;
+    const key = bucket === 0 ? prefix : `${prefix}.${bucket}`;
+    if (input.scope === undefined || input.scope === '')
+        return key;
+    const scope = /^[A-Za-z0-9_-]{1,40}$/.test(input.scope) ? input.scope : `s${hash64(input.scope)}`;
+    return `${scope}.${key}`;
+}
+/**
+ * Whether an OpenAI model routes its prompt cache by itself: from GPT-5.6 on the key only separates
+ * cache accounting (https://developers.openai.com/api/docs/guides/prompt-caching, "Summary of model
+ * differences", read 2026-10-07). Earlier and unrecognized models are routed by the key.
+ */
+export function openAiRoutesPromptCacheAutomatically(modelId) {
+    const match = /(?:^|[^a-z0-9])gpt-(\d+)(?:\.(\d+))?/i.exec(modelId ?? '');
+    if (!match)
+        return false;
+    const major = Number(match[1]);
+    const minor = Number(match[2] ?? 0);
+    return major > 5 || (major === 5 && minor >= 6);
+}
 function isOpenAiProvider(provider) {
     const providerLower = provider?.toLowerCase() ?? '';
     return providerLower === 'openai' || providerLower.startsWith('openai.') || providerLower.includes('@ai-sdk/openai');
@@ -166,16 +310,17 @@ export function getSmartAiCacheProviderOptions(input) {
     if (!cacheOptions)
         return undefined;
     if (isOpenAiProvider(input.provider)) {
-        const key = cacheOptions.key ?? input.sessionId;
+        const key = cacheOptions.key ?? input.promptCacheKey ?? input.sessionId;
+        // GPT-5.6 and later take `prompt_cache_options.ttl` instead, whose only value is its default.
+        const retention = (cacheOptions.retention === '24h' || cacheOptions.retention === 'in_memory')
+            && !openAiRoutesPromptCacheAutomatically(input.modelId)
+            ? cacheOptions.retention
+            : undefined;
         return {
             openai: {
                 store: false,
                 ...(key ? { promptCacheKey: key } : {}),
-                ...(cacheOptions.retention === '24h' || cacheOptions.retention === 'in_memory'
-                    ? { promptCacheRetention: cacheOptions.retention }
-                    : key
-                        ? { promptCacheRetention: 'in_memory' }
-                        : {}),
+                ...(retention ? { promptCacheRetention: retention } : {}),
             },
         };
     }
@@ -258,4 +403,4 @@ export function getSmartAiCacheWaitMs(requestedMs, dispatch, now = Date.now()) {
     const headroom = Math.min(1000, Math.ceil(dispatch.warmDurationMs / 10));
     return Math.max(0, Math.min(maximum, Math.floor(dispatch.idleDeadline - now - headroom)));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.cache.js","sourceRoot":"","sources":["../ts_models/smartai.cache.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartai.cache.js","sourceRoot":"","sources":["../ts_models/smartai.cache.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness-models",
-  "version": "10.13.0",
+  "version": "10.14.0",
   "type": "module",
   "description": "Provider-independent model contracts, prompt caching and explicit model registration.",
   "main": "./dist_ts_models/index.js",

package/readme.md

@@ -48,6 +48,43 @@ media type and the content decoded in the stated charset (UTF-8 by default), in
 than any backtick run in the content. Images, PDFs, other binary files, URLs and file references
 pass unchanged; a file that names text but does not decode fails before the request is sent.
 
+### Prompt caching
+
+`TSmartAiCacheSetting` is `'auto'` (the default of a FlexHarness session), `false`, or an
+`ISmartAiCacheOptions` object. It decides the cache hints a request carries:
+
+- **Anthropic** (and the message-level dialects of OpenRouter, Bedrock and OpenAI-compatible
+  servers): `applySmartAiRequestCaching({ prompt, tools }, options)` places at most four
+  breakpoints, counting markers the caller set itself. The first two system messages are the stable
+  ones; the second, or the only one, ends the stable prefix and caches the tool definitions rendered
+  before it. Without a system message the last tool definition ends the prefix, so sessions share
+  it. The last message and the one before it carry the rolling breakpoints of a growing
+  conversation, then the first system message. On Anthropic the stable prefix's breakpoints last an
+  hour (`prefixRetention`, default `'1h'`), so sessions that start minutes apart still read it, while the
+  conversation keeps five-minute breakpoints; a one-hour write costs twice the input price, a
+  five-minute write 1.25 times, and on steady traffic the prefix is written once an hour.
+  `prefixRetention: 'ephemeral'` writes the prefix for five minutes; `retention: '1h'` makes every
+  breakpoint last an hour. A request that carries markers of the caller's own
+  keeps the prefix at `retention`, since a one-hour breakpoint may not follow a five-minute one.
+  `createSmartAiCachingMiddleware(options)` applies it to every call of a model. Each model has a
+  minimum cacheable prefix (512 to 4,096 tokens); a breakpoint below it neither writes nor reads and
+  costs nothing, so the planner places breakpoints without counting tokens it cannot count before
+  the request is sent.
+- **OpenAI** (Responses and the ChatGPT Codex backend): `store: false` and a `prompt_cache_key`.
+  `deriveSmartAiPromptCacheKey({ system, tools, scope })` derives the key from the instructions and
+  tool definitions every turn repeats, so sessions with one prefix reach the machine that caches it;
+  any change to the prefix changes the key. `keyScope` keeps tenants apart, and `key` replaces the
+  derived key. OpenAI suggests about 15 requests a minute per key
+  (`OPENAI_PROMPT_CACHE_KEY_REQUESTS_PER_MINUTE`); `keyBuckets` spreads a prefix over that many keys,
+  each session keeping one by its session id, on models that route by key; requests without a
+  session id take the first. From GPT-5.6 on OpenAI routes by itself
+  and the key only separates cache accounting (`openAiRoutesPromptCacheAutomatically`).
+  `retention: 'in_memory' | '24h'` is sent as `prompt_cache_retention` to earlier models; without it
+  the provider's default applies.
+
+`getSmartAiCacheProviderOptions` and `applySmartAiCacheProviderOptions` return the provider options
+of a setting; a caller's own options win.
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.

package/ts_models/plugins.ts

@@ -14,6 +14,7 @@ export type {
   LanguageModelV3,
   LanguageModelV3Prompt,
   LanguageModelV4,
+  LanguageModelV4CallOptions,
   LanguageModelV4Middleware,
   LanguageModelV4Prompt,
   LanguageModelV4StreamPart,

package/ts_models/readme.md

@@ -48,6 +48,43 @@ media type and the content decoded in the stated charset (UTF-8 by default), in
 than any backtick run in the content. Images, PDFs, other binary files, URLs and file references
 pass unchanged; a file that names text but does not decode fails before the request is sent.
 
+### Prompt caching
+
+`TSmartAiCacheSetting` is `'auto'` (the default of a FlexHarness session), `false`, or an
+`ISmartAiCacheOptions` object. It decides the cache hints a request carries:
+
+- **Anthropic** (and the message-level dialects of OpenRouter, Bedrock and OpenAI-compatible
+  servers): `applySmartAiRequestCaching({ prompt, tools }, options)` places at most four
+  breakpoints, counting markers the caller set itself. The first two system messages are the stable
+  ones; the second, or the only one, ends the stable prefix and caches the tool definitions rendered
+  before it. Without a system message the last tool definition ends the prefix, so sessions share
+  it. The last message and the one before it carry the rolling breakpoints of a growing
+  conversation, then the first system message. On Anthropic the stable prefix's breakpoints last an
+  hour (`prefixRetention`, default `'1h'`), so sessions that start minutes apart still read it, while the
+  conversation keeps five-minute breakpoints; a one-hour write costs twice the input price, a
+  five-minute write 1.25 times, and on steady traffic the prefix is written once an hour.
+  `prefixRetention: 'ephemeral'` writes the prefix for five minutes; `retention: '1h'` makes every
+  breakpoint last an hour. A request that carries markers of the caller's own
+  keeps the prefix at `retention`, since a one-hour breakpoint may not follow a five-minute one.
+  `createSmartAiCachingMiddleware(options)` applies it to every call of a model. Each model has a
+  minimum cacheable prefix (512 to 4,096 tokens); a breakpoint below it neither writes nor reads and
+  costs nothing, so the planner places breakpoints without counting tokens it cannot count before
+  the request is sent.
+- **OpenAI** (Responses and the ChatGPT Codex backend): `store: false` and a `prompt_cache_key`.
+  `deriveSmartAiPromptCacheKey({ system, tools, scope })` derives the key from the instructions and
+  tool definitions every turn repeats, so sessions with one prefix reach the machine that caches it;
+  any change to the prefix changes the key. `keyScope` keeps tenants apart, and `key` replaces the
+  derived key. OpenAI suggests about 15 requests a minute per key
+  (`OPENAI_PROMPT_CACHE_KEY_REQUESTS_PER_MINUTE`); `keyBuckets` spreads a prefix over that many keys,
+  each session keeping one by its session id, on models that route by key; requests without a
+  session id take the first. From GPT-5.6 on OpenAI routes by itself
+  and the key only separates cache accounting (`openAiRoutesPromptCacheAutomatically`).
+  `retention: 'in_memory' | '24h'` is sent as `prompt_cache_retention` to earlier models; without it
+  the provider's default applies.
+
+`getSmartAiCacheProviderOptions` and `applySmartAiCacheProviderOptions` return the provider options
+of a setting; a caller's own options win.
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.

package/ts_models/smartai.cache.ts

@@ -14,10 +14,37 @@ export type TSmartAiCacheRetention = 'ephemeral' | '1h' | 'in_memory' | '24h';
 export interface ISmartAiCacheOptions {
   /** Provider-specific message cache marker namespace. Usually inferred from the model. */
   provider?: TSmartAiMessageCacheProvider;
-  /** Stable session/request key for providers that support request-level prompt cache affinity. */
+  /**
+   * The OpenAI `prompt_cache_key`, sent as given. Without it the key is derived from the request's
+   * stable prefix, its instructions and tool definitions, so sessions that share a prefix share
+   * the provider's cache; see `deriveSmartAiPromptCacheKey`.
+   */
   key?: string;
-  /** Short retention is the default; longer retention is opt-in. */
+  /**
+   * Mixed into the derived key: requests of different scopes, such as tenants, never share a key,
+   * which keeps their cache routing and the provider's cache accounting apart.
+   */
+  keyScope?: string;
+  /**
+   * How many keys a derived key is spread over on OpenAI models that route by key (before GPT-5.6),
+   * each session keeping one. OpenAI suggests about 15 requests a minute per key, so size it as the
+   * prefix's peak requests a minute across all processes divided by 15. Defaults to 1.
+   */
+  keyBuckets?: number;
+  /**
+   * Anthropic: `'1h'` writes one-hour breakpoints instead of the five-minute default. OpenAI models
+   * before GPT-5.6: `'in_memory'` or `'24h'` is sent as `prompt_cache_retention`; without it the
+   * provider's default applies (24 hours, or in memory for Zero Data Retention organizations).
+   */
   retention?: TSmartAiCacheRetention;
+  /**
+   * Anthropic: the lifetime of the stable prefix's breakpoints, the tool definitions and system
+   * prompt, apart from the conversation's. `'1h'` (the default) keeps the prefix for sessions that
+   * start minutes apart while the growing conversation keeps five-minute breakpoints; writing it
+   * costs twice the input price instead of 1.25 times, once an hour on steady traffic.
+   * `'ephemeral'` writes it for five minutes. Never shorter than `retention`.
+   */
+  prefixRetention?: 'ephemeral' | '1h';
   /** Configured maximum idle scheduling budget, not a promise of cache retention or a cache hit. */
   warmDurationMs?: number;
 }
@@ -176,46 +203,229 @@ function applyCacheToMessage(
   return applyProviderOptionsDefaults(message, providerOptions);
 }
 
-export function applySmartAiPromptCaching(
+/** Anthropic accepts at most four cache breakpoints per request; the AI SDK ignores any beyond. */
+const MAX_CACHE_MARKERS = 4;
+
+type TSmartAiPromptMessage = plugins.LanguageModelV4Prompt[number];
+type TSmartAiCacheableTool = NonNullable<plugins.LanguageModelV4CallOptions['tools']>[number];
+
+/** Whether a message, one of its parts, or a tool already carries a caller's cache marker. */
+function hasCacheMarker(
+  item: { providerOptions?: TSmartAiProviderOptions } | undefined,
+  provider: TSmartAiMessageCacheProvider,
+): boolean {
+  if (!item) return false;
+  const [namespace, controls] = Object.entries(getSmartAiMessageCacheProviderOptions(provider))[0];
+  const caller = item.providerOptions?.[namespace];
+  return isObject(caller) && (
+    Object.keys(controls).some((key) => Object.prototype.hasOwnProperty.call(caller, key))
+    || (namespace === 'anthropic' && Object.prototype.hasOwnProperty.call(caller, 'cache_control'))
+  );
+}
+
+function cacheMarkerCount(message: TSmartAiPromptMessage, provider: TSmartAiMessageCacheProvider): number {
+  const own = hasCacheMarker(message as { providerOptions?: TSmartAiProviderOptions }, provider) ? 1 : 0;
+  const parts = Array.isArray(message.content)
+    ? message.content.filter((part) => hasCacheMarker(part as { providerOptions?: TSmartAiProviderOptions }, provider)).length
+    : 0;
+  return own + parts;
+}
+
+interface ICacheMarkerPlan {
+  /** Markers the caller set itself, counted per block as the provider counts them. */
+  callerMarkers: number;
+  messages: Set<number>;
+  /** The messages among `messages` that end the stable prefix rather than the conversation. */
+  prefixMessages: Set<number>;
+  /** The tool definition that ends the stable prefix of a request without a system message. */
+  tool?: number;
+}
+
+/**
+ * Where a request's cache markers go, within the provider's limit of four, counting markers a
+ * caller set itself. The first two system messages are the stable ones (later system messages may
+ * carry per-request content); the second, or the only one, ends the stable prefix and also caches
+ * the tool definitions rendered before it. Without a system message the last tool definition ends
+ * the prefix. In order: that end of the prefix, the last message, the message before it (the rolling
+ * breakpoints of a growing conversation), and the first system message.
+ */
+function planCacheMarkers(
   prompt: plugins.LanguageModelV4Prompt,
-  options: ISmartAiCacheOptions = {},
-): plugins.LanguageModelV4Prompt {
-  const provider = options.provider ?? 'anthropic';
-  const targetIndexes = new Set<number>();
-  const nonSystemIndexes: number[] = [];
-  let systemCount = 0;
-
-  for (let i = 0; i < prompt.length; i++) {
-    const message = prompt[i];
-    if (message.role === 'system') {
-      if (systemCount < 2) targetIndexes.add(i);
-      systemCount++;
+  tools: readonly TSmartAiCacheableTool[] | undefined,
+  provider: TSmartAiMessageCacheProvider,
+): ICacheMarkerPlan {
+  const marked = new Set<number>();
+  const plan: ICacheMarkerPlan = { messages: new Set(), prefixMessages: new Set(), callerMarkers: 0 };
+  // The provider counts every block that carries a marker: a message's own and each marked part.
+  prompt.forEach((message, index) => {
+    const blocks = cacheMarkerCount(message, provider);
+    if (blocks > 0) marked.add(index);
+    plan.callerMarkers += blocks;
+  });
+  const markedTools = (tools ?? []).filter((definition) =>
+    hasCacheMarker(definition as { providerOptions?: TSmartAiProviderOptions }, provider)).length;
+  const toolMarked = markedTools > 0;
+  plan.callerMarkers += markedTools;
+  let budget = MAX_CACHE_MARKERS - plan.callerMarkers;
+  const system = prompt.flatMap((message, index) => message.role === 'system' ? [index] : []).slice(0, 2);
+  const nonSystem = prompt.flatMap((message, index) => message.role === 'system' ? [] : [index]);
+  const rolling = nonSystem.slice(-2).reverse();
+  // A one-hour prefix marker must precede every five-minute one.
+  const isPrefix = (index: number): true | undefined => rolling.every((rollingIndex) => index < rollingIndex) ? true : undefined;
+  const candidates: Array<{ message: number; prefix?: true | undefined } | { tool: number }> = [];
+  if (system.length > 0) {
+    candidates.push({ message: system[system.length - 1], prefix: isPrefix(system[system.length - 1]) });
+  } else if (provider === 'anthropic' && tools && tools.length > 0 && !toolMarked) {
+    candidates.push({ tool: tools.length - 1 });
+  }
+  for (const index of rolling) candidates.push({ message: index });
+  if (system.length > 1) candidates.push({ message: system[0], prefix: isPrefix(system[0]) });
+  for (const candidate of candidates) {
+    if ('tool' in candidate) {
+      if (budget <= 0) continue;
+      plan.tool = candidate.tool;
+      budget--;
       continue;
     }
-    nonSystemIndexes.push(i);
-  }
-
-  for (const index of nonSystemIndexes.slice(-2)) {
-    targetIndexes.add(index);
+    if (plan.messages.has(candidate.message)) continue;
+    if (!marked.has(candidate.message)) {
+      if (budget <= 0) continue;
+      budget--;
+    }
+    plan.messages.add(candidate.message);
+    if (candidate.prefix) plan.prefixMessages.add(candidate.message);
   }
+  return plan;
+}
 
-  if (targetIndexes.size === 0) return prompt;
+export function applySmartAiPromptCaching(
+  prompt: plugins.LanguageModelV4Prompt,
+  options: ISmartAiCacheOptions = {},
+): plugins.LanguageModelV4Prompt {
+  return applySmartAiRequestCaching({ prompt }, options).prompt;
+}
 
-  return prompt.map((message, index) =>
-    targetIndexes.has(index) ? applyCacheToMessage(message, provider, options) : message,
-  ) as plugins.LanguageModelV4Prompt;
+/**
+ * Places cache markers on a request: its prompt and, for Anthropic, its tool definitions. See
+ * `planCacheMarkers` for where they go.
+ */
+export function applySmartAiRequestCaching<
+  TRequest extends { prompt: plugins.LanguageModelV4Prompt; tools?: TSmartAiCacheableTool[] },
+>(request: TRequest, options: ISmartAiCacheOptions = {}): TRequest {
+  const provider = options.provider ?? 'anthropic';
+  const plan = planCacheMarkers(request.prompt, request.tools, provider);
+  // A one-hour breakpoint must precede five-minute ones: the prefix never lives shorter than the
+  // rest, and a caller's own markers, whose lifetimes and places are its own, keep the prefix at the
+  // request's retention.
+  const prefixOptions: ISmartAiCacheOptions = options.retention === '1h'
+    || ((options.prefixRetention ?? '1h') === '1h' && plan.callerMarkers === 0)
+    ? { ...options, retention: '1h' }
+    : options;
+  const prompt = plan.messages.size === 0
+    ? request.prompt
+    : request.prompt.map((message, index) => plan.messages.has(index)
+      ? applyCacheToMessage(message, provider, plan.prefixMessages.has(index) ? prefixOptions : options)
+      : message,
+    ) as plugins.LanguageModelV4Prompt;
+  const tools = plan.tool === undefined || !request.tools
+    ? request.tools
+    : request.tools.map((definition, index) => index === plan.tool
+      ? applyProviderOptionsDefaults(
+        definition as TSmartAiCacheableTool & { providerOptions?: TSmartAiProviderOptions },
+        getSmartAiMessageCacheProviderOptions(provider, prefixOptions),
+      )
+      : definition);
+  return { ...request, prompt, ...(tools ? { tools } : {}) };
 }
 
 export function createSmartAiCachingMiddleware(options: ISmartAiCacheOptions = {}): plugins.LanguageModelV4Middleware {
   return {
     specificationVersion: 'v4',
-    transformParams: async ({ params }) => ({
-      ...params,
-      prompt: applySmartAiPromptCaching(params.prompt, options),
-    }),
+    transformParams: async ({ params }) => applySmartAiRequestCaching(params, options),
   };
 }
 
+/**
+ * OpenAI routes a request to the machine that holds its cached prefix by a hash of the prefix's
+ * first tokens and the `prompt_cache_key`, and a key is meant to carry about 15 requests a minute
+ * across all prefixes using it before traffic overflows to other machines
+ * (https://developers.openai.com/api/docs/guides/prompt-caching, "Prompt cache keys" and
+ * "Cache location", read 2026-10-07). `keyBuckets` is sized by it.
+ */
+export const OPENAI_PROMPT_CACHE_KEY_REQUESTS_PER_MINUTE = 15;
+
+/** A tool definition as a request sends it, for deriving a prompt cache key. */
+export interface ISmartAiPromptCacheTool {
+  type?: string;
+  name: string;
+  description?: string;
+  inputSchema?: unknown;
+  strict?: boolean;
+}
+
+const hash64 = (text: string): string => {
+  // Two 32-bit FNV-1a lanes: a routing key needs a stable digest, not a cryptographic one.
+  let low = 0x811c9dc5;
+  let high = 0xcbf29ce4;
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    low = Math.imul(low ^ code, 0x01000193) >>> 0;
+    high = Math.imul(high ^ code ^ (low >>> 7), 0x01000193) >>> 0;
+  }
+  return high.toString(16).padStart(8, '0') + low.toString(16).padStart(8, '0');
+};
+
+/**
+ * A `prompt_cache_key` for the prefix every turn of a request repeats: its instructions and tool
+ * definitions, in the order they are sent, and the host's scope. Requests with the same prefix get
+ * the same key, so their sessions reach the machine holding it; any change to the prefix changes
+ * the key. A scope of letters, digits, `_` and `-` up to 40 characters stays readable in the key,
+ * any other is hashed. With `buckets`, sessions spread over that many keys, each keeping one, so a
+ * session's growing conversation stays with the machine that caches it.
+ */
+export function deriveSmartAiPromptCacheKey(input: {
+  system?: string;
+  tools?: readonly ISmartAiPromptCacheTool[];
+  scope?: string;
+  /** With `buckets` above 1: the session, which keeps its bucket for every request it sends. */
+  affinity?: string;
+  buckets?: number;
+}): string {
+  const prefix = hash64(JSON.stringify([
+    input.system ?? '',
+    (input.tools ?? []).map((definition) => [
+      definition.type ?? 'function',
+      definition.name,
+      definition.description ?? '',
+      definition.inputSchema ?? null,
+      definition.strict ?? null,
+    ]),
+  ]));
+  const buckets = input.buckets ?? 1;
+  if (!Number.isSafeInteger(buckets) || buckets < 1) throw new Error('keyBuckets must be a positive integer.');
+  const bucket = buckets > 1 && input.affinity !== undefined
+    ? Number.parseInt(hash64(input.affinity).slice(8), 16) % buckets
+    : 0;
+  const key = bucket === 0 ? prefix : `${prefix}.${bucket}`;
+  if (input.scope === undefined || input.scope === '') return key;
+  const scope = /^[A-Za-z0-9_-]{1,40}$/.test(input.scope) ? input.scope : `s${hash64(input.scope)}`;
+  return `${scope}.${key}`;
+}
+
+/**
+ * Whether an OpenAI model routes its prompt cache by itself: from GPT-5.6 on the key only separates
+ * cache accounting (https://developers.openai.com/api/docs/guides/prompt-caching, "Summary of model
+ * differences", read 2026-10-07). Earlier and unrecognized models are routed by the key.
+ */
+export function openAiRoutesPromptCacheAutomatically(modelId: string | undefined): boolean {
+  const match = /(?:^|[^a-z0-9])gpt-(\d+)(?:\.(\d+))?/i.exec(modelId ?? '');
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2] ?? 0);
+  return major > 5 || (major === 5 && minor >= 6);
+}
+
+
 function isOpenAiProvider(provider?: string): boolean {
   const providerLower = provider?.toLowerCase() ?? '';
   return providerLower === 'openai' || providerLower.startsWith('openai.') || providerLower.includes('@ai-sdk/openai');
@@ -225,22 +435,26 @@ export function getSmartAiCacheProviderOptions(input: {
   provider?: string;
   modelId?: string;
   cache?: TSmartAiCacheSetting;
+  /** The derived `prompt_cache_key` (`deriveSmartAiPromptCacheKey`); a configured `key` takes precedence. */
+  promptCacheKey?: string;
+  /** The key used when neither a configured nor a derived key is given. */
   sessionId?: string;
 }): TSmartAiProviderOptions | undefined {
   const cacheOptions = cacheOptionsFromSetting(input.cache);
   if (!cacheOptions) return undefined;
 
   if (isOpenAiProvider(input.provider)) {
-    const key = cacheOptions.key ?? input.sessionId;
+    const key = cacheOptions.key ?? input.promptCacheKey ?? input.sessionId;
+    // GPT-5.6 and later take `prompt_cache_options.ttl` instead, whose only value is its default.
+    const retention = (cacheOptions.retention === '24h' || cacheOptions.retention === 'in_memory')
+      && !openAiRoutesPromptCacheAutomatically(input.modelId)
+      ? cacheOptions.retention
+      : undefined;
     return {
       openai: {
         store: false,
         ...(key ? { promptCacheKey: key } : {}),
-        ...(cacheOptions.retention === '24h' || cacheOptions.retention === 'in_memory'
-          ? { promptCacheRetention: cacheOptions.retention }
-          : key
-            ? { promptCacheRetention: 'in_memory' }
-            : {}),
+        ...(retention ? { promptCacheRetention: retention } : {}),
       },
     };
   }
@@ -253,6 +467,7 @@ export function applySmartAiCacheProviderOptions(input: {
   modelId?: string;
   providerOptions?: TSmartAiProviderOptions;
   cache?: TSmartAiCacheSetting;
+  promptCacheKey?: string;
   sessionId?: string;
 }): TSmartAiProviderOptions | undefined {
   return mergeSmartAiProviderOptions(