@veryfront/ext-llm-anthropic 0.1.1237 → 0.1.1239

package/esm/anthropic-request-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-request-builder.d.ts","sourceRoot":"","sources":["../src/anthropic-request-builder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,uBAAuB,EAEvB,0BAA0B,EAE3B,MAAM,2BAA2B,CAAC;AAOnC,OAAO,EACL,KAAK,iCAAiC,EAUvC,MAAM,+BAA+B,CAAC;AAEvC,KAAK,gBAAgB,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;AAE9C,KAAK,0BAA0B,GAAG;IAChC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,+BAAgC,SAAQ,uBAAuB;IAC9E,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACjD;AAED,gGAAgG;AAChG,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,CAAC;AAE/D,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,OAAO,EAAE;QACZ,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,IAAI,CAAC;IACT,KAAK,IAAI,KAAK,CAAC;QACb,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzC,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AA0oCF,wBAAgB,iDAAiD,CAC/D,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,+BAA+B,EACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,gBAAgB,GACzB;IACD,IAAI,EAAE,0BAA0B,CAAC;IACjC,qBAAqB,EAAE,iCAAiC,CAAC;CAC1D,CA8JA;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,+BAA+B,EACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,gBAAgB,GACzB,0BAA0B,CAQ5B"}
+{"version":3,"file":"anthropic-request-builder.d.ts","sourceRoot":"","sources":["../src/anthropic-request-builder.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,uBAAuB,EAEvB,0BAA0B,EAE3B,MAAM,2BAA2B,CAAC;AAOnC,OAAO,EACL,KAAK,iCAAiC,EAUvC,MAAM,+BAA+B,CAAC;AAEvC,KAAK,gBAAgB,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;AA2E9C,KAAK,0BAA0B,GAAG;IAChC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,KAAK,CAAC,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF,MAAM,WAAW,+BAAgC,SAAQ,uBAAuB;IAC9E,YAAY,CAAC,EAAE,0BAA0B,CAAC;IAC1C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,UAAU,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACjD;AAED,gGAAgG;AAChG,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,CAAC;AAE/D,KAAK,gBAAgB,GAAG;IACtB,IAAI,CAAC,OAAO,EAAE;QACZ,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,IAAI,CAAC;IACT,KAAK,IAAI,KAAK,CAAC;QACb,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzC,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AA8lEF,wBAAgB,iDAAiD,CAC/D,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,+BAA+B,EACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,gBAAgB,GACzB;IACD,IAAI,EAAE,0BAA0B,CAAC;IACjC,qBAAqB,EAAE,iCAAiC,CAAC;CAC1D,CAgLA;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,+BAA+B,EACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,gBAAgB,GACzB,0BAA0B,CAQ5B"}

package/esm/anthropic-request-builder.js

@@ -1,6 +1,70 @@
-import { jsonValuesEqual, readProviderOptions, readRecord, stringifyToolResultValue, unwrapToolInputSchema, } from "veryfront/provider/shared";
+import { canIdentifyProxyWithoutHooks, isProxyWithoutHooks, jsonValuesEqual, readProviderOptions, readRecord, snapshotProviderJsonValue, stringifyToolResultValue, unwrapToolInputSchema, } from "veryfront/provider/shared";
 import { assertAnthropicMcpRequestContract, normalizeAnthropicMcpServers, normalizeAnthropicMcpToolsetArgs, } from "./anthropic-mcp-request.js";
 import { isAnthropicProviderToolResultBlockType, MAX_ANTHROPIC_RAW_ASSISTANT_BLOCKS, MAX_ANTHROPIC_RAW_ASSISTANT_MESSAGES, parseAnthropicProviderToolUse, parseAnthropicServerToolResult, snapshotAnthropicRawAssistantMetadata, validateAnthropicRawAssistantMessages, } from "./anthropic-native-content.js";
+const apply = Reflect.apply;
+const NativeArray = Array;
+const ArrayIsArray = Array.isArray;
+const booleanValueOf = Boolean.prototype.valueOf;
+const NativeSet = Set;
+const numberValueOf = Number.prototype.valueOf;
+const objectAssign = Object.assign;
+const objectDefineProperty = Object.defineProperty;
+const objectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const objectGetPrototypeOf = Object.getPrototypeOf;
+const objectHasOwn = Object.hasOwn;
+const objectKeys = Object.keys;
+const reflectDeleteProperty = Reflect.deleteProperty;
+const reflectOwnKeys = Reflect.ownKeys;
+const setAdd = Set.prototype.add;
+const setDelete = Set.prototype.delete;
+const setHas = Set.prototype.has;
+const stringValueOf = String.prototype.valueOf;
+function hasSetValue(set, value) {
+    return apply(setHas, set, [value]);
+}
+function addSetValue(set, value) {
+    apply(setAdd, set, [value]);
+}
+function deleteSetValue(set, value) {
+    apply(setDelete, set, [value]);
+}
+function defineOwnEnumerableDataProperty(target, key, value) {
+    apply(objectDefineProperty, Object, [target, key, {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true,
+        }]);
+}
+function boxedPrimitiveKind(value) {
+    try {
+        apply(booleanValueOf, value, []);
+        return "boolean";
+    }
+    catch {
+        // Continue with the other intrinsic brand checks.
+    }
+    try {
+        apply(numberValueOf, value, []);
+        return "number";
+    }
+    catch {
+        // Continue with the other intrinsic brand checks.
+    }
+    try {
+        apply(stringValueOf, value, []);
+        return "string";
+    }
+    catch {
+        return undefined;
+    }
+}
+function isBoxedPrimitive(value) {
+    return boxedPrimitiveKind(value) !== undefined;
+}
+function isBoxedString(value) {
+    return boxedPrimitiveKind(value) === "string";
+}
 function normalizeAnthropicToolChoice(toolChoice) {
     if (typeof toolChoice === "string") {
         return { type: toolChoice };
@@ -30,14 +94,14 @@ function pushAnthropicUserContent(messages, content) {
 function readOwnAnthropicMetadataProperty(value, key, malformedMessage) {
     let descriptor;
     try {
-        descriptor = Object.getOwnPropertyDescriptor(value, key);
+        descriptor = objectGetOwnPropertyDescriptor(value, key);
     }
     catch {
         throw new TypeError(malformedMessage);
     }
     if (descriptor === undefined)
         return undefined;
-    if (!Object.hasOwn(descriptor, "value") || descriptor.enumerable !== true) {
+    if (!objectHasOwn(descriptor, "value") || descriptor.enumerable !== true) {
         throw new TypeError(malformedMessage);
     }
     return descriptor.value;
@@ -141,10 +205,10 @@ const ANTHROPIC_SERVER_TOOL_RESULT_ERROR_FIELDS = new Set([
 ]);
 function readOwnEnumerableDataProperty(value, key) {
     try {
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        const descriptor = objectGetOwnPropertyDescriptor(value, key);
         if (descriptor === undefined)
             return { present: false };
-        if (!Object.hasOwn(descriptor, "value") || descriptor.enumerable !== true) {
+        if (!objectHasOwn(descriptor, "value") || descriptor.enumerable !== true) {
             return undefined;
         }
         return { present: true, value: descriptor.value };
@@ -158,7 +222,7 @@ function readAnthropicServerToolResultErrorFields(value) {
         return undefined;
     }
     try {
-        if (Object.keys(value).some((key) => !ANTHROPIC_SERVER_TOOL_RESULT_ERROR_FIELDS.has(key))) {
+        if (objectKeys(value).some((key) => !ANTHROPIC_SERVER_TOOL_RESULT_ERROR_FIELDS.has(key))) {
             return undefined;
         }
     }
@@ -524,6 +588,75 @@ function resolveAnthropicCacheControlBlock(ttl) {
     }
     return { type: "ephemeral" };
 }
+function resolveAnthropicSystemMessageCacheControl(message, providerName) {
+    const providerOptions = readOwnEnumerableDataProperty(message, "providerOptions");
+    if (!providerOptions) {
+        throw new TypeError("Anthropic system message providerOptions must be an own enumerable data property");
+    }
+    if (!providerOptions.present || providerOptions.value === undefined) {
+        return undefined;
+    }
+    if (!providerOptions.value || typeof providerOptions.value !== "object" ||
+        Array.isArray(providerOptions.value)) {
+        throw new TypeError("Anthropic system message providerOptions must be an object");
+    }
+    let rawCacheControl;
+    let hasCacheControl = false;
+    for (const key of ["anthropic", providerName]) {
+        const providerBucket = readOwnEnumerableDataProperty(providerOptions.value, key);
+        if (!providerBucket) {
+            throw new TypeError("Anthropic system message provider bucket must be an own enumerable data property");
+        }
+        if (!providerBucket.present || !providerBucket.value ||
+            typeof providerBucket.value !== "object" || Array.isArray(providerBucket.value)) {
+            continue;
+        }
+        const cacheControl = readOwnEnumerableDataProperty(providerBucket.value, "cacheControl");
+        if (!cacheControl) {
+            throw new TypeError("Anthropic system message cacheControl must be an own enumerable data property");
+        }
+        if (cacheControl.present && cacheControl.value !== undefined) {
+            hasCacheControl = true;
+            rawCacheControl = cacheControl.value;
+        }
+    }
+    if (!hasCacheControl || rawCacheControl === undefined) {
+        return undefined;
+    }
+    if (!rawCacheControl || typeof rawCacheControl !== "object" || Array.isArray(rawCacheControl)) {
+        throw new TypeError("Anthropic system message cacheControl must be an object");
+    }
+    let unsupportedFields;
+    try {
+        const keys = objectKeys(rawCacheControl);
+        unsupportedFields = [];
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            if (key !== "type" && key !== "ttl") {
+                unsupportedFields.push(key);
+            }
+        }
+    }
+    catch {
+        throw new TypeError("Anthropic system message cacheControl could not be inspected");
+    }
+    if (unsupportedFields.length > 0) {
+        throw new TypeError("Anthropic system message cacheControl contains unsupported fields");
+    }
+    const type = readOwnEnumerableDataProperty(rawCacheControl, "type");
+    const ttl = readOwnEnumerableDataProperty(rawCacheControl, "ttl");
+    if (!type || !ttl) {
+        throw new TypeError("Anthropic system message cacheControl must contain only enumerable data properties");
+    }
+    if (!type.present || type.value !== "ephemeral") {
+        throw new TypeError('Anthropic system message cacheControl.type must be "ephemeral"');
+    }
+    if (ttl.present && ttl.value !== undefined && ttl.value !== "5m" &&
+        ttl.value !== "1h") {
+        throw new TypeError('Anthropic system message cacheControl.ttl must be "5m" or "1h"');
+    }
+    return ttl.value === "1h" ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
+}
 function createValidatedAnthropicProviderToolCorrelationState(canonicalProviderToolNamesById, rawProviderToolNamesById) {
     assertBoundedAnthropicProviderToolState(canonicalProviderToolNamesById);
     assertBoundedAnthropicProviderToolState(rawProviderToolNamesById);
@@ -535,7 +668,7 @@ function createValidatedAnthropicProviderToolCorrelationState(canonicalProviderT
     }
     return correlated;
 }
-function toAnthropicMessages(prompt, systemCacheControl) {
+function toAnthropicMessages(prompt, systemCacheControl, providerName = "anthropic") {
     const systemParts = [];
     const messages = [];
     const lastUserIndex = prompt.findLastIndex((message) => message.role === "user");
@@ -564,7 +697,11 @@ function toAnthropicMessages(prompt, systemCacheControl) {
                 rawProviderToolNamesById = new Map();
                 canonicalProviderToolNamesById = new Map();
                 if (message.content.length > 0) {
-                    systemParts.push(message.content);
+                    const cacheControl = resolveAnthropicSystemMessageCacheControl(message, providerName);
+                    systemParts.push({
+                        text: message.content,
+                        ...(cacheControl === undefined ? {} : { cacheControl }),
+                    });
                 }
                 break;
             case "user":
@@ -664,7 +801,23 @@ function toAnthropicMessages(prompt, systemCacheControl) {
             providerToolNamesById: createValidatedAnthropicProviderToolCorrelationState(canonicalProviderToolNamesById, rawProviderToolNamesById),
         };
     }
-    const joined = systemParts.join("\n\n");
+    if (systemParts.some((part) => part.cacheControl !== undefined)) {
+        const system = systemParts.map((part) => ({
+            type: "text",
+            text: part.text,
+            ...(part.cacheControl === undefined ? {} : { cache_control: part.cacheControl }),
+        }));
+        const lastSystemBlock = system.at(-1);
+        if (systemCacheControl && lastSystemBlock) {
+            lastSystemBlock.cache_control = systemCacheControl;
+        }
+        return {
+            system,
+            messages,
+            providerToolNamesById: createValidatedAnthropicProviderToolCorrelationState(canonicalProviderToolNamesById, rawProviderToolNamesById),
+        };
+    }
+    const joined = systemParts.map((part) => part.text).join("\n\n");
     if (systemCacheControl) {
         return {
             system: [{
@@ -763,6 +916,660 @@ function applyAnthropicToolsCacheControl(tools, cacheControl) {
     const lastIndex = tools.length - 1;
     return tools.map((tool, index) => index === lastIndex ? { ...tool, cache_control: cacheControl } : tool);
 }
+function isOmittedJsonObjectPropertyValue(value) {
+    return value === undefined || typeof value === "function" || typeof value === "symbol";
+}
+function assertNoAnthropicCacheJsonHook(value) {
+    const visited = new NativeSet();
+    let candidate = value;
+    let depth = 0;
+    while (candidate !== null && !hasSetValue(visited, candidate) && depth < 64) {
+        if (isProxyWithoutHooks(candidate)) {
+            throw new TypeError("Anthropic cache inputs must not contain Proxy values");
+        }
+        addSetValue(visited, candidate);
+        depth += 1;
+        let descriptor;
+        try {
+            descriptor = objectGetOwnPropertyDescriptor(candidate, "toJSON");
+        }
+        catch {
+            throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+        }
+        if (descriptor !== undefined) {
+            if (!objectHasOwn(descriptor, "value") || typeof descriptor.value === "function") {
+                throw new TypeError("Anthropic cache inputs must not define toJSON hooks");
+            }
+            return;
+        }
+        try {
+            candidate = objectGetPrototypeOf(candidate);
+        }
+        catch {
+            throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+        }
+    }
+    if (candidate !== null) {
+        throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+    }
+}
+function assertNoNestedAnthropicCacheJsonHooks(value, label = "Anthropic cache_control", ancestors = new NativeSet(), depth = 0) {
+    if (depth >= 64 || hasSetValue(ancestors, value)) {
+        throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+    }
+    if (isBoxedPrimitive(value)) {
+        throw new TypeError(`${label} must not contain boxed primitive values`);
+    }
+    assertNoAnthropicCacheJsonHook(value);
+    addSetValue(ancestors, value);
+    try {
+        if (ArrayIsArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const key = `${index}`;
+                let descriptor;
+                try {
+                    descriptor = objectGetOwnPropertyDescriptor(value, key);
+                }
+                catch {
+                    throw new TypeError(`${label} could not be inspected`);
+                }
+                if (descriptor === undefined) {
+                    assertNoInheritedAnthropicArrayElement(value, index, label);
+                    continue;
+                }
+                if (!objectHasOwn(descriptor, "value")) {
+                    throw new TypeError(`${label} must contain only indexed data properties`);
+                }
+                const nested = descriptor.value;
+                if (nested !== null &&
+                    (typeof nested === "object" || typeof nested === "function")) {
+                    assertNoNestedAnthropicCacheJsonHooks(nested, label === "Anthropic message content" ? "Anthropic cache records" : label, ancestors, depth + 1);
+                }
+            }
+            return;
+        }
+        let keys;
+        try {
+            keys = objectKeys(value);
+        }
+        catch {
+            throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+        }
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            let descriptor;
+            try {
+                descriptor = objectGetOwnPropertyDescriptor(value, key);
+            }
+            catch {
+                throw new TypeError("Anthropic cache input toJSON hooks could not be inspected");
+            }
+            if (!descriptor || !objectHasOwn(descriptor, "value")) {
+                throw new TypeError(`${label} must contain only enumerable data properties`);
+            }
+            const nested = descriptor.value;
+            if (nested !== null &&
+                (typeof nested === "object" || typeof nested === "function")) {
+                const nestedLabel = key === "cache_control" ? "Anthropic cache_control" : label;
+                if (nestedLabel === "Anthropic cache_control" &&
+                    (key === "type" || key === "ttl") &&
+                    isBoxedString(nested)) {
+                    assertNoAnthropicCacheJsonHook(nested);
+                    continue;
+                }
+                assertNoNestedAnthropicCacheJsonHooks(nested, nestedLabel, ancestors, depth + 1);
+            }
+        }
+    }
+    finally {
+        deleteSetValue(ancestors, value);
+    }
+}
+function assertNoAnthropicCacheRecordSerializationHooks(value) {
+    if (isBoxedPrimitive(value)) {
+        throw new TypeError("Anthropic cache records must not contain boxed primitive values");
+    }
+    assertNoAnthropicCacheJsonHook(value);
+    let keys;
+    try {
+        keys = objectKeys(value);
+    }
+    catch {
+        throw new TypeError("Anthropic cache records could not be inspected");
+    }
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        let descriptor;
+        try {
+            descriptor = objectGetOwnPropertyDescriptor(value, key);
+        }
+        catch {
+            throw new TypeError("Anthropic cache records could not be inspected");
+        }
+        if (!descriptor || !objectHasOwn(descriptor, "value")) {
+            if (key === "cache_control") {
+                throw new TypeError("Anthropic cache_control must be an own enumerable data property");
+            }
+            throw new TypeError("Anthropic cache records must contain only enumerable data properties");
+        }
+        const nested = descriptor.value;
+        if (nested !== null &&
+            (typeof nested === "object" || typeof nested === "function")) {
+            const nestedLabel = key === "cache_control"
+                ? "Anthropic cache_control"
+                : key === "content" && ArrayIsArray(nested)
+                    ? "Anthropic message content"
+                    : "Anthropic cache records";
+            assertNoNestedAnthropicCacheJsonHooks(nested, nestedLabel);
+        }
+    }
+}
+function cloneAnthropicCacheRecord(value) {
+    assertNoAnthropicCacheRecordSerializationHooks(value);
+    const clone = {};
+    const keys = objectKeys(value);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const descriptor = objectGetOwnPropertyDescriptor(value, key);
+        if (!descriptor || !objectHasOwn(descriptor, "value")) {
+            throw new TypeError("Anthropic cache records must contain only enumerable data properties");
+        }
+        defineOwnEnumerableDataProperty(clone, key, descriptor.value);
+    }
+    return clone;
+}
+const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
+function assertNoInheritedAnthropicArrayElement(value, index, label) {
+    const key = `${index}`;
+    const visited = new NativeSet();
+    let candidate;
+    try {
+        candidate = objectGetPrototypeOf(value);
+    }
+    catch {
+        throw new TypeError(`${label} inherited indexed properties could not be inspected`);
+    }
+    let depth = 0;
+    while (candidate !== null && !hasSetValue(visited, candidate) && depth < 64) {
+        if (isProxyWithoutHooks(candidate)) {
+            throw new TypeError(`${label} inherited indexed properties could not be inspected`);
+        }
+        addSetValue(visited, candidate);
+        depth += 1;
+        let descriptor;
+        try {
+            descriptor = objectGetOwnPropertyDescriptor(candidate, key);
+        }
+        catch {
+            throw new TypeError(`${label} inherited indexed properties could not be inspected`);
+        }
+        if (descriptor !== undefined) {
+            throw new TypeError(`${label} must not contain inherited indexed properties`);
+        }
+        try {
+            candidate = objectGetPrototypeOf(candidate);
+        }
+        catch {
+            throw new TypeError(`${label} inherited indexed properties could not be inspected`);
+        }
+    }
+    if (candidate !== null) {
+        throw new TypeError(`${label} inherited indexed properties could not be inspected`);
+    }
+}
+function snapshotAnthropicCacheArray(value, label) {
+    assertNoAnthropicCacheJsonHook(value);
+    const snapshot = new NativeArray(value.length);
+    for (let index = 0; index < value.length; index += 1) {
+        let descriptor;
+        try {
+            descriptor = objectGetOwnPropertyDescriptor(value, `${index}`);
+        }
+        catch {
+            throw new TypeError(`${label} could not be inspected`);
+        }
+        if (descriptor === undefined) {
+            assertNoInheritedAnthropicArrayElement(value, index, label);
+            continue;
+        }
+        if (!objectHasOwn(descriptor, "value")) {
+            throw new TypeError(`${label} must contain only indexed data properties`);
+        }
+        defineOwnEnumerableDataProperty(snapshot, `${index}`, descriptor.value);
+    }
+    return snapshot;
+}
+function hasEmittedAnthropicCacheBreakpoint(value) {
+    assertNoAnthropicCacheRecordSerializationHooks(value);
+    let descriptor;
+    try {
+        descriptor = objectGetOwnPropertyDescriptor(value, "cache_control");
+    }
+    catch {
+        throw new TypeError("Anthropic cache_control could not be inspected");
+    }
+    if (descriptor === undefined || descriptor.enumerable !== true) {
+        return false;
+    }
+    if (!objectHasOwn(descriptor, "value")) {
+        throw new TypeError("Anthropic cache_control must be an own enumerable data property");
+    }
+    if (typeof descriptor.value === "function" ||
+        (typeof descriptor.value === "object" && descriptor.value !== null)) {
+        assertNoAnthropicCacheJsonHook(descriptor.value);
+    }
+    return !isOmittedJsonObjectPropertyValue(descriptor.value);
+}
+function isAnthropicMessageCacheBlock(value) {
+    if (typeof value === "function" || ArrayIsArray(value)) {
+        assertNoAnthropicCacheJsonHook(value);
+        return false;
+    }
+    return typeof value === "object" && value !== null;
+}
+function readEmittedAnthropicMessageContent(message) {
+    assertNoAnthropicCacheRecordSerializationHooks(message);
+    let descriptor;
+    try {
+        descriptor = objectGetOwnPropertyDescriptor(message, "content");
+    }
+    catch {
+        throw new TypeError("Anthropic message content could not be inspected");
+    }
+    if (descriptor === undefined || descriptor.enumerable !== true) {
+        return [];
+    }
+    if (!objectHasOwn(descriptor, "value")) {
+        throw new TypeError("Anthropic message content must be an own enumerable data property");
+    }
+    const content = descriptor.value;
+    if (!ArrayIsArray(content)) {
+        if ((typeof content === "object" && content !== null) ||
+            typeof content === "function") {
+            assertNoAnthropicCacheJsonHook(content);
+        }
+        return [];
+    }
+    return snapshotAnthropicCacheArray(content, "Anthropic message content");
+}
+function readAnthropicArrayDataElement(value, index, label) {
+    let descriptor;
+    try {
+        descriptor = objectGetOwnPropertyDescriptor(value, `${index}`);
+    }
+    catch {
+        throw new TypeError(`${label} could not be inspected`);
+    }
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (!objectHasOwn(descriptor, "value")) {
+        throw new TypeError(`${label} must contain only indexed data properties`);
+    }
+    return descriptor.value;
+}
+function retainLatestAnthropicMessageCacheBreakpoints(messages, maximum) {
+    const breakpointCount = countAnthropicMessageCacheBreakpoints(messages);
+    let remainingToRemove = breakpointCount > maximum ? breakpointCount - maximum : 0;
+    if (remainingToRemove === 0) {
+        return messages;
+    }
+    const normalizedMessages = new NativeArray(messages.length);
+    for (let messageIndex = 0; messageIndex < messages.length; messageIndex += 1) {
+        const message = readAnthropicArrayDataElement(messages, messageIndex, "Anthropic messages");
+        if (message === undefined) {
+            continue;
+        }
+        const originalContent = readEmittedAnthropicMessageContent(message);
+        let content = originalContent;
+        for (let contentIndex = 0; remainingToRemove > 0 && contentIndex < originalContent.length; contentIndex += 1) {
+            const block = readAnthropicArrayDataElement(originalContent, contentIndex, "Anthropic message content");
+            if (!isAnthropicMessageCacheBlock(block) ||
+                !hasEmittedAnthropicCacheBreakpoint(block)) {
+                continue;
+            }
+            if (content === originalContent) {
+                content = snapshotAnthropicCacheArray(originalContent, "Anthropic message content");
+            }
+            const next = cloneAnthropicCacheRecord(block);
+            reflectDeleteProperty(next, "cache_control");
+            defineOwnEnumerableDataProperty(content, `${contentIndex}`, next);
+            remainingToRemove -= 1;
+        }
+        if (content === originalContent) {
+            defineOwnEnumerableDataProperty(normalizedMessages, `${messageIndex}`, message);
+        }
+        else {
+            const nextMessage = cloneAnthropicCacheRecord(message);
+            defineOwnEnumerableDataProperty(nextMessage, "content", content);
+            defineOwnEnumerableDataProperty(normalizedMessages, `${messageIndex}`, nextMessage);
+        }
+    }
+    return normalizedMessages;
+}
+function countAnthropicMessageCacheBreakpoints(messages) {
+    let count = 0;
+    for (let messageIndex = 0; messageIndex < messages.length; messageIndex += 1) {
+        const message = readAnthropicArrayDataElement(messages, messageIndex, "Anthropic messages");
+        if (message === undefined) {
+            continue;
+        }
+        const content = readEmittedAnthropicMessageContent(message);
+        for (let contentIndex = 0; contentIndex < content.length; contentIndex += 1) {
+            const block = readAnthropicArrayDataElement(content, contentIndex, "Anthropic message content");
+            if (isAnthropicMessageCacheBlock(block) &&
+                hasEmittedAnthropicCacheBreakpoint(block)) {
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+function readJsonSerializedAnthropicString(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    assertNoAnthropicCacheJsonHook(value);
+    try {
+        apply(stringValueOf, value, []);
+    }
+    catch {
+        return undefined;
+    }
+    throw new TypeError("Anthropic cache strings must use primitive string values");
+}
+function snapshotAnthropicProviderBucket(bucket) {
+    if (isProxyWithoutHooks(bucket)) {
+        throw new TypeError("Anthropic provider options could not be inspected");
+    }
+    const snapshot = {};
+    let keys;
+    try {
+        keys = apply(reflectOwnKeys, Reflect, [bucket]);
+    }
+    catch {
+        throw new TypeError("Anthropic provider options could not be inspected");
+    }
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (typeof key !== "string")
+            continue;
+        let descriptor;
+        try {
+            descriptor = objectGetOwnPropertyDescriptor(bucket, key);
+        }
+        catch {
+            throw new TypeError("Anthropic provider options could not be inspected");
+        }
+        if (descriptor?.enumerable !== true)
+            continue;
+        if (!objectHasOwn(descriptor, "value")) {
+            throw new TypeError("Anthropic provider options could not be inspected");
+        }
+        defineOwnEnumerableDataProperty(snapshot, key, descriptor.value);
+    }
+    return snapshot;
+}
+function prepareAnthropicProviderOptions(providerOptions, ...providerNames) {
+    if (providerOptions === undefined)
+        return undefined;
+    try {
+        if (canIdentifyProxyWithoutHooks) {
+            if (isProxyWithoutHooks(providerOptions)) {
+                throw new TypeError("Anthropic provider options could not be inspected");
+            }
+            const snapshot = {};
+            for (let index = 0; index < providerNames.length; index += 1) {
+                const providerName = providerNames[index];
+                const descriptor = objectGetOwnPropertyDescriptor(providerOptions, providerName);
+                if (descriptor === undefined)
+                    continue;
+                if (!objectHasOwn(descriptor, "value")) {
+                    throw new TypeError("Anthropic provider options could not be inspected");
+                }
+                const value = descriptor.value;
+                defineOwnEnumerableDataProperty(snapshot, providerName, value !== null && typeof value === "object" && !ArrayIsArray(value)
+                    ? snapshotAnthropicProviderBucket(value)
+                    : value);
+            }
+            return snapshot;
+        }
+        const snapshot = snapshotProviderJsonValue(providerOptions, {
+            dropUndefinedMembers: true,
+            sortObjectKeys: false,
+        });
+        if (snapshot === null || typeof snapshot !== "object" || ArrayIsArray(snapshot)) {
+            throw new TypeError("Anthropic provider options could not be inspected");
+        }
+        return snapshot;
+    }
+    catch {
+        throw new TypeError("Anthropic provider options could not be inspected");
+    }
+}
+function readEmittedAnthropicCacheTtl(value) {
+    let descriptor;
+    try {
+        descriptor = objectGetOwnPropertyDescriptor(value, "cache_control");
+    }
+    catch {
+        return undefined;
+    }
+    if (descriptor === undefined || descriptor.enumerable !== true ||
+        !objectHasOwn(descriptor, "value")) {
+        return undefined;
+    }
+    const cacheControl = descriptor.value;
+    if (typeof cacheControl !== "object" || cacheControl === null ||
+        ArrayIsArray(cacheControl)) {
+        return undefined;
+    }
+    assertNoNestedAnthropicCacheJsonHooks(cacheControl);
+    let keys;
+    try {
+        keys = objectKeys(cacheControl);
+    }
+    catch {
+        return undefined;
+    }
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const property = readOwnEnumerableDataProperty(cacheControl, key);
+        if (!property) {
+            throw new TypeError("Anthropic cache_control must contain only enumerable data properties");
+        }
+        if (!isOmittedJsonObjectPropertyValue(property.value) && key !== "type" && key !== "ttl") {
+            return undefined;
+        }
+    }
+    const type = readOwnEnumerableDataProperty(cacheControl, "type");
+    const ttl = readOwnEnumerableDataProperty(cacheControl, "ttl");
+    const typeValue = type?.present ? readJsonSerializedAnthropicString(type.value) : undefined;
+    const ttlValue = ttl?.present ? readJsonSerializedAnthropicString(ttl.value) : undefined;
+    if (!type?.present || isOmittedJsonObjectPropertyValue(type.value) ||
+        typeValue !== "ephemeral" || !ttl) {
+        return undefined;
+    }
+    if (ttl.present && ttlValue === "1h") {
+        return "1h";
+    }
+    return !ttl.present || isOmittedJsonObjectPropertyValue(ttl.value) || ttlValue === "5m"
+        ? "5m"
+        : undefined;
+}
+function upgradeEmittedAnthropicCacheTtl(value) {
+    const upgraded = cloneAnthropicCacheRecord(value);
+    defineOwnEnumerableDataProperty(upgraded, "cache_control", { type: "ephemeral", ttl: "1h" });
+    return upgraded;
+}
+function normalizeAnthropicCacheTtls(values, requiresOneHourPrefix) {
+    let normalized = values;
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const value = values[index];
+        if (!value || !hasEmittedAnthropicCacheBreakpoint(value)) {
+            continue;
+        }
+        const ttl = readEmittedAnthropicCacheTtl(value);
+        if (ttl === "1h") {
+            requiresOneHourPrefix = true;
+        }
+        else if (ttl === "5m" && requiresOneHourPrefix) {
+            if (normalized === values) {
+                normalized = snapshotAnthropicCacheArray(values, "Anthropic cache blocks");
+            }
+            defineOwnEnumerableDataProperty(normalized, `${index}`, upgradeEmittedAnthropicCacheTtl(value));
+        }
+    }
+    return { values: normalized, requiresOneHourPrefix };
+}
+function normalizeAnthropicMessageCacheTtls(messages) {
+    let normalizedMessages = messages;
+    let requiresOneHourPrefix = false;
+    for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+        const message = messages[messageIndex];
+        if (!message) {
+            continue;
+        }
+        const content = readEmittedAnthropicMessageContent(message);
+        let normalizedContent = content;
+        for (let contentIndex = content.length - 1; contentIndex >= 0; contentIndex -= 1) {
+            const block = content[contentIndex];
+            if (!isAnthropicMessageCacheBlock(block) ||
+                !hasEmittedAnthropicCacheBreakpoint(block)) {
+                continue;
+            }
+            const ttl = readEmittedAnthropicCacheTtl(block);
+            if (ttl === "1h") {
+                requiresOneHourPrefix = true;
+            }
+            else if (ttl === "5m" && requiresOneHourPrefix) {
+                if (normalizedContent === content) {
+                    normalizedContent = snapshotAnthropicCacheArray(content, "Anthropic message content");
+                }
+                defineOwnEnumerableDataProperty(normalizedContent, `${contentIndex}`, upgradeEmittedAnthropicCacheTtl(block));
+            }
+        }
+        if (normalizedContent !== content) {
+            if (normalizedMessages === messages) {
+                normalizedMessages = snapshotAnthropicCacheArray(messages, "Anthropic messages");
+            }
+            const nextMessage = cloneAnthropicCacheRecord(message);
+            defineOwnEnumerableDataProperty(nextMessage, "content", normalizedContent);
+            defineOwnEnumerableDataProperty(normalizedMessages, `${messageIndex}`, nextMessage);
+        }
+    }
+    return { messages: normalizedMessages, requiresOneHourPrefix };
+}
+function retainLatestAnthropicCacheBreakpoints(values, maximum) {
+    const breakpointIndexes = new NativeArray(values.length);
+    let breakpointCount = 0;
+    for (let index = 0; index < values.length; index += 1) {
+        const descriptor = objectGetOwnPropertyDescriptor(values, `${index}`);
+        if (descriptor !== undefined &&
+            hasEmittedAnthropicCacheBreakpoint(descriptor.value)) {
+            defineOwnEnumerableDataProperty(breakpointIndexes, `${breakpointCount}`, index);
+            breakpointCount += 1;
+        }
+    }
+    const removalCount = breakpointCount > maximum ? breakpointCount - maximum : 0;
+    if (removalCount === 0) {
+        return values;
+    }
+    const retained = new NativeArray(values.length);
+    for (let index = 0; index < values.length; index += 1) {
+        const descriptor = objectGetOwnPropertyDescriptor(values, `${index}`);
+        if (descriptor !== undefined) {
+            defineOwnEnumerableDataProperty(retained, `${index}`, descriptor.value);
+        }
+    }
+    for (let position = 0; position < removalCount; position += 1) {
+        const index = breakpointIndexes[position];
+        const next = cloneAnthropicCacheRecord(retained[index]);
+        reflectDeleteProperty(next, "cache_control");
+        defineOwnEnumerableDataProperty(retained, `${index}`, next);
+    }
+    return retained;
+}
+function countAnthropicCacheBreakpoints(values) {
+    let count = 0;
+    for (let index = 0; index < values.length; index += 1) {
+        const value = readAnthropicArrayDataElement(values, index, "Anthropic cache blocks");
+        if (value !== undefined && hasEmittedAnthropicCacheBreakpoint(value)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function limitAnthropicCacheBreakpoints(system, tools, messages) {
+    const inspectedMessages = snapshotAnthropicCacheArray(messages, "Anthropic messages");
+    const inspectedSystem = ArrayIsArray(system)
+        ? snapshotAnthropicCacheArray(system, "Anthropic system")
+        : system;
+    const inspectedTools = tools ? snapshotAnthropicCacheArray(tools, "Anthropic tools") : undefined;
+    const boundedMessages = retainLatestAnthropicMessageCacheBreakpoints(inspectedMessages, ANTHROPIC_MAX_CACHE_BREAKPOINTS);
+    const messageBreakpointCount = countAnthropicMessageCacheBreakpoints(boundedMessages);
+    const boundedSystem = ArrayIsArray(inspectedSystem)
+        ? retainLatestAnthropicCacheBreakpoints(inspectedSystem, ANTHROPIC_MAX_CACHE_BREAKPOINTS - messageBreakpointCount)
+        : inspectedSystem;
+    const systemBreakpointCount = ArrayIsArray(boundedSystem)
+        ? countAnthropicCacheBreakpoints(boundedSystem)
+        : 0;
+    const boundedTools = inspectedTools
+        ? retainLatestAnthropicCacheBreakpoints(inspectedTools, ANTHROPIC_MAX_CACHE_BREAKPOINTS - messageBreakpointCount - systemBreakpointCount)
+        : undefined;
+    const normalizedMessages = normalizeAnthropicMessageCacheTtls(boundedMessages);
+    const normalizedSystem = ArrayIsArray(boundedSystem)
+        ? normalizeAnthropicCacheTtls(boundedSystem, normalizedMessages.requiresOneHourPrefix)
+        : {
+            values: boundedSystem,
+            requiresOneHourPrefix: normalizedMessages.requiresOneHourPrefix,
+        };
+    const normalizedTools = boundedTools
+        ? normalizeAnthropicCacheTtls(boundedTools, normalizedSystem.requiresOneHourPrefix).values
+        : undefined;
+    return {
+        system: normalizedSystem.values,
+        tools: normalizedTools,
+        messages: normalizedMessages.messages,
+    };
+}
+function assertAnthropicCacheableRequestFields(body) {
+    assertNoAnthropicCacheJsonHook(body);
+    if (!ArrayIsArray(body.messages)) {
+        throw new TypeError("Anthropic messages must be an array");
+    }
+    if (body.system !== undefined && typeof body.system !== "string" &&
+        !ArrayIsArray(body.system)) {
+        throw new TypeError("Anthropic system must be a string or an array");
+    }
+    if (body.tools !== undefined && !ArrayIsArray(body.tools)) {
+        throw new TypeError("Anthropic tools must be an array");
+    }
+    const keys = objectKeys(body);
+    let lastCacheFieldIndex = -1;
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === "messages" || key === "system" || key === "tools") {
+            lastCacheFieldIndex = index;
+        }
+    }
+    for (let index = 0; index <= lastCacheFieldIndex; index += 1) {
+        const key = keys[index];
+        if (key === "messages" || key === "system" || key === "tools") {
+            continue;
+        }
+        const descriptor = objectGetOwnPropertyDescriptor(body, key);
+        if (!descriptor || !objectHasOwn(descriptor, "value")) {
+            throw new TypeError("Anthropic request fields must use enumerable data properties");
+        }
+        const value = descriptor.value;
+        if (value !== null &&
+            (typeof value === "object" || typeof value === "function")) {
+            assertNoNestedAnthropicCacheJsonHooks(value, "Anthropic request fields");
+        }
+    }
+}
 function containsAnthropicMcpToolset(tools) {
     return tools?.some((tool) => tool.type === "mcp_toolset") ?? false;
 }
@@ -825,23 +1632,32 @@ function resolveAnthropicThinkingBudget(option) {
     }
 }
 function resolveAnthropicProviderThinkingBudget(options) {
-    const thinking = options.thinking;
+    const thinkingProperty = readOwnEnumerableDataProperty(options, "thinking");
+    if (!thinkingProperty) {
+        throw new TypeError("Anthropic provider thinking must be an object");
+    }
+    const thinking = thinkingProperty.present ? thinkingProperty.value : undefined;
     if (thinking === undefined) {
         return undefined;
     }
-    if (thinking === null || typeof thinking !== "object" || Array.isArray(thinking)) {
+    if (thinking === null || typeof thinking !== "object" || ArrayIsArray(thinking) ||
+        isProxyWithoutHooks(thinking)) {
         throw new TypeError("Anthropic provider thinking must be an object");
     }
-    const record = thinking;
-    if (typeof record.type !== "string" || record.type.length === 0) {
+    const type = readOwnEnumerableDataProperty(thinking, "type");
+    if (!type?.present || typeof type.value !== "string" || type.value.length === 0) {
         throw new TypeError("Anthropic provider thinking.type must be a non-empty string");
     }
-    const budgetTokens = record.budget_tokens;
+    const budgetTokensProperty = readOwnEnumerableDataProperty(thinking, "budget_tokens");
+    if (!budgetTokensProperty) {
+        throw new TypeError("Anthropic provider thinking.budget_tokens must be a safe integer of at least 1024");
+    }
+    const budgetTokens = budgetTokensProperty.present ? budgetTokensProperty.value : undefined;
     if (budgetTokens !== undefined &&
         (!Number.isSafeInteger(budgetTokens) || budgetTokens < 1024)) {
         throw new TypeError("Anthropic provider thinking.budget_tokens must be a safe integer of at least 1024");
     }
-    if (record.type !== "enabled") {
+    if (type.value !== "enabled") {
         return undefined;
     }
     if (budgetTokens === undefined) {
@@ -852,17 +1668,17 @@ function resolveAnthropicProviderThinkingBudget(options) {
 export function buildAnthropicMessagesRequestWithCorrelationState(modelId, providerName, options, stream, warnings) {
     const systemCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.system);
     const toolsCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.tools);
-    const { system, messages, providerToolNamesById } = toAnthropicMessages(options.prompt, systemCacheControl);
+    const { system, messages, providerToolNamesById } = toAnthropicMessages(options.prompt, systemCacheControl, providerName);
     const mcpConfiguration = normalizeAnthropicMcpServers(options.mcpServers);
     const callerTools = toAnthropicTools(options.tools);
     const anthropicTools = applyAnthropicToolsCacheControl(mergeAnthropicMcpToolsets(callerTools, mcpConfiguration), toolsCacheControl);
-    const rawProviderOptions = readProviderOptions(options.providerOptions, "anthropic", providerName);
+    const rawProviderOptions = readProviderOptions(prepareAnthropicProviderOptions(options.providerOptions, "anthropic", providerName), "anthropic", providerName);
     if (mcpConfiguration &&
-        (Object.hasOwn(rawProviderOptions, "mcp_servers") ||
-            Object.hasOwn(rawProviderOptions, "tools"))) {
+        (objectHasOwn(rawProviderOptions, "mcp_servers") ||
+            objectHasOwn(rawProviderOptions, "tools"))) {
         throw new TypeError("Anthropic MCP configuration must not be split between mcpServers and providerOptions");
     }
-    if (Object.hasOwn(rawProviderOptions, "tools") &&
+    if (objectHasOwn(rawProviderOptions, "tools") &&
         containsAnthropicMcpToolset(callerTools)) {
         throw new TypeError("Anthropic MCP toolsets must not be defined in both tools and providerOptions");
     }
@@ -964,10 +1780,25 @@ export function buildAnthropicMessagesRequestWithCorrelationState(modelId, provi
         ...(mcpConfiguration ? { mcp_servers: mcpConfiguration.servers } : {}),
         ...(options.anthropicContainer !== undefined ? { container: options.anthropicContainer } : {}),
     };
-    Object.assign(body, rawProviderOptions);
+    apply(objectAssign, Object, [body, rawProviderOptions]);
     if (thinkingBudget !== undefined || providerThinkingBudget !== undefined) {
         body.thinking = { type: "enabled", budget_tokens: effectiveThinkingBudget };
     }
+    assertAnthropicCacheableRequestFields(body);
+    const boundedCacheBreakpoints = limitAnthropicCacheBreakpoints(body.system, body.tools, body.messages);
+    if (boundedCacheBreakpoints.system === undefined) {
+        reflectDeleteProperty(body, "system");
+    }
+    else {
+        body.system = boundedCacheBreakpoints.system;
+    }
+    if (boundedCacheBreakpoints.tools === undefined) {
+        reflectDeleteProperty(body, "tools");
+    }
+    else {
+        body.tools = boundedCacheBreakpoints.tools;
+    }
+    body.messages = boundedCacheBreakpoints.messages;
     assertAnthropicMcpRequestContract(body);
     return {
         body,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-llm-anthropic",
-  "version": "0.1.1237",
+  "version": "0.1.1239",
   "description": "Veryfront first-party extension package for ext-llm-anthropic",
   "keywords": [
     "veryfront",
@@ -50,7 +50,7 @@
     "@deno/shim-timers": "~0.1.0"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1237"
+    "veryfront": "^0.1.1239"
   },
   "type": "module",
   "types": "./esm/index.d.ts",