@core-ai/anthropic 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -18,11 +18,26 @@ type AnthropicReasoningMetadata = {
     redactedData?: string;
 };
 
+declare const anthropicCacheControlSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ephemeral">;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "5m": "5m";
+        "1h": "1h";
+    }>>;
+}, z.core.$strict>;
+type AnthropicCacheControl = z.infer<typeof anthropicCacheControlSchema>;
 declare const anthropicGenerateProviderOptionsSchema: z.ZodObject<{
     topK: z.ZodOptional<z.ZodNumber>;
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     betas: z.ZodOptional<z.ZodArray<z.ZodString>>;
     outputConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodEnum<{
+            "5m": "5m";
+            "1h": "1h";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 type AnthropicGenerateProviderOptions = z.infer<typeof anthropicGenerateProviderOptionsSchema>;
 declare module '@core-ai/core-ai' {
@@ -35,7 +50,14 @@ declare const anthropicProviderOptionsSchema: z.ZodObject<{
     stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     betas: z.ZodOptional<z.ZodArray<z.ZodString>>;
     outputConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    cacheControl: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"ephemeral">;
+        ttl: z.ZodOptional<z.ZodEnum<{
+            "5m": "5m";
+            "1h": "1h";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 type AnthropicProviderOptions = AnthropicGenerateProviderOptions;
 
-export { type AnthropicGenerateProviderOptions, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic };
+export { type AnthropicCacheControl, type AnthropicGenerateProviderOptions, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicCacheControlSchema, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic };

package/dist/index.js

@@ -11,10 +11,21 @@ import {
 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
-import { APIError } from "@anthropic-ai/sdk";
-import { ProviderError, getProviderMetadata, zodSchemaToJsonSchema } from "@core-ai/core-ai";
+import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
+import {
+  AbortedError,
+  asObject,
+  getProviderMetadata,
+  ProviderError,
+  ValidationError,
+  safeParseJsonObject,
+  zodSchemaToJsonSchema
+} from "@core-ai/core-ai";
 
 // src/model-capabilities.ts
+import {
+  stripModelDateSuffix
+} from "@core-ai/core-ai";
 var DEFAULT_CAPABILITIES = {
   reasoning: {
     thinkingMode: "adaptive",
@@ -77,45 +88,48 @@ var MODEL_CAPABILITIES = {
     }
   }
 };
+var ANTHROPIC_ADAPTIVE_EFFORT_MAP = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high"
+};
+var ANTHROPIC_MANUAL_BUDGET_MAP = {
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 32768,
+  max: 65536
+};
 function getAnthropicModelCapabilities(modelId) {
   const normalizedModelId = normalizeModelId(modelId);
   return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
 }
 function normalizeModelId(modelId) {
-  return modelId.replace(/-\d{8}$/, "");
+  return stripModelDateSuffix(modelId);
 }
 function toAnthropicAdaptiveEffort(effort, supportsMaxEffort) {
-  if (effort === "minimal") {
-    return "low";
-  }
   if (effort === "max") {
     return supportsMaxEffort ? "max" : "high";
   }
-  return effort;
+  return ANTHROPIC_ADAPTIVE_EFFORT_MAP[effort];
 }
 function toAnthropicManualBudget(effort) {
-  if (effort === "minimal") {
-    return 1024;
-  }
-  if (effort === "low") {
-    return 2048;
-  }
-  if (effort === "medium") {
-    return 8192;
-  }
-  if (effort === "high") {
-    return 32768;
-  }
-  return 65536;
+  return ANTHROPIC_MANUAL_BUDGET_MAP[effort];
 }
 
 // src/provider-options.ts
 import { z } from "zod";
+var anthropicCacheControlSchema = z.object({
+  type: z.literal("ephemeral"),
+  ttl: z.enum(["5m", "1h"]).optional()
+}).strict();
 var anthropicGenerateProviderOptionsSchema = z.object({
   topK: z.number().int().optional(),
   stopSequences: z.array(z.string()).optional(),
   betas: z.array(z.string()).optional(),
-  outputConfig: z.record(z.string(), z.unknown()).optional()
+  outputConfig: z.record(z.string(), z.unknown()).optional(),
+  cacheControl: anthropicCacheControlSchema.optional()
 }).strict();
 function parseAnthropicGenerateProviderOptions(providerOptions) {
   const rawOptions = providerOptions?.anthropic;
@@ -417,26 +431,30 @@ function validateAnthropicReasoningConfig(modelId, options, anthropicOptions) {
     return;
   }
   if (options.temperature !== void 0) {
-    throw new ProviderError(
+    throw new ValidationError(
       `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
+      void 0,
       "anthropic"
     );
   }
   if (options.topP !== void 0 && (options.topP < 0.95 || options.topP > 1)) {
-    throw new ProviderError(
+    throw new ValidationError(
       `Anthropic model "${modelId}" requires topP between 0.95 and 1 when reasoning is enabled`,
+      void 0,
       "anthropic"
     );
   }
   if (options.toolChoice && options.toolChoice !== "auto" && options.toolChoice !== "none") {
-    throw new ProviderError(
+    throw new ValidationError(
       `Anthropic model "${modelId}" only supports toolChoice "auto" or "none" when reasoning is enabled`,
+      void 0,
       "anthropic"
     );
   }
   if (anthropicOptions?.topK !== void 0) {
-    throw new ProviderError(
+    throw new ValidationError(
       `Anthropic model "${modelId}" does not support top_k when reasoning is enabled`,
+      void 0,
       "anthropic"
     );
   }
@@ -483,6 +501,7 @@ function mapAnthropicProviderOptionsToRequest(baseRequest, providerOptions) {
   ];
   const mergedRequest = {
     ...baseRequest,
+    ...providerOptions.cacheControl ? { cache_control: providerOptions.cacheControl } : {},
     ...providerOptions.topK !== void 0 ? { top_k: providerOptions.topK } : {},
     ...providerOptions.stopSequences ? { stop_sequences: providerOptions.stopSequences } : {},
     ...Object.keys(mergedOutputConfig).length > 0 ? { output_config: mergedOutputConfig } : {},
@@ -721,20 +740,6 @@ function mapStopReason(reason) {
   }
   return "unknown";
 }
-function safeParseJsonObject(json) {
-  try {
-    const parsed = JSON.parse(json);
-    return asObject(parsed);
-  } catch {
-    return {};
-  }
-}
-function asObject(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return value;
-  }
-  return {};
-}
 function asStringArray(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -760,6 +765,9 @@ function extractThinkingText(value) {
   }).join("");
 }
 function wrapError(error) {
+  if (error instanceof APIUserAbortError || error instanceof Error && error.name === "AbortError") {
+    return new AbortedError(error, "anthropic");
+  }
   if (error instanceof APIError) {
     return new ProviderError(
       error.message,
@@ -971,6 +979,7 @@ function createAnthropic(options = {}) {
   };
 }
 export {
+  anthropicCacheControlSchema,
   anthropicGenerateProviderOptionsSchema,
   anthropicProviderOptionsSchema,
   createAnthropic

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -42,7 +42,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.7.0",
+        "@core-ai/core-ai": "^0.8.0",
         "@anthropic-ai/sdk": "^0.78.0"
     },
     "peerDependencies": {