@core-ai/anthropic 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1,16 +1,43 @@
-import Anthropic from '@anthropic-ai/sdk';
 import { ChatModel, ModelCapabilities } from '@core-ai/core-ai';
+import Anthropic from '@anthropic-ai/sdk';
 import { z } from 'zod';
 
-type AnthropicProviderOptions$1 = {
+type AnthropicChatClient = {
+    messages: {
+        create: Anthropic['messages']['create'];
+    };
+};
+
+type AnthropicChatProviderOptions = {
     apiKey?: string;
     baseURL?: string;
-    client?: Anthropic;
+    client?: AnthropicChatClient;
     defaultMaxTokens?: number;
 };
-type AnthropicProvider = {
+/**
+ * Factory options for sibling packages that compose Anthropic chat.
+ * Not part of {@link createAnthropic} / {@link AnthropicProviderOptions} —
+ * first-party Anthropic always uses strict tool schemas.
+ */
+type AnthropicChatProviderFactoryOptions = {
+    providerId?: string;
+    useStrictToolSchemas?: boolean;
+};
+type AnthropicChatProvider = {
     chatModel(modelId: string): ChatModel;
 };
+type AnthropicProviderOptions$1 = AnthropicChatProviderOptions;
+type AnthropicProvider = AnthropicChatProvider;
+/**
+ * Creates a chat-only Anthropic provider. Handles client construction
+ * internally so consumers do not need a direct dependency on the
+ * `@anthropic-ai/sdk` package, and attributes generation, streaming, and
+ * error handling to the given provider id.
+ *
+ * Sibling packages (e.g. `@core-ai/anthropic-vertex`) pass a custom client
+ * and factory options; end users should prefer {@link createAnthropic}.
+ */
+declare function createAnthropicChatProvider(options?: AnthropicChatProviderOptions, factoryOptions?: AnthropicChatProviderFactoryOptions): AnthropicChatProvider;
 declare function createAnthropic(options?: AnthropicProviderOptions$1): AnthropicProvider;
 
 type AnthropicReasoningMetadata = {
@@ -63,4 +90,4 @@ declare const anthropicProviderOptionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type AnthropicProviderOptions = AnthropicGenerateProviderOptions;
 
-export { type AnthropicCacheControl, type AnthropicGenerateProviderOptions, type AnthropicModelCapabilities, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicCacheControlSchema, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic, getAnthropicModelCapabilities };
+export { type AnthropicCacheControl, type AnthropicChatClient, type AnthropicChatProvider, type AnthropicChatProviderFactoryOptions, type AnthropicChatProviderOptions, type AnthropicGenerateProviderOptions, type AnthropicModelCapabilities, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicCacheControlSchema, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic, createAnthropicChatProvider, getAnthropicModelCapabilities };

package/dist/index.js

@@ -1,15 +1,6 @@
 // src/provider.ts
 import Anthropic from "@anthropic-ai/sdk";
 
-// src/chat-model.ts
-import {
-  StructuredOutputNoObjectGeneratedError,
-  StructuredOutputParseError,
-  StructuredOutputValidationError,
-  createObjectStream,
-  createChatStream
-} from "@core-ai/core-ai";
-
 // src/chat-adapter.ts
 import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
 import {
@@ -153,6 +144,7 @@ function parseAnthropicGenerateProviderOptions(providerOptions) {
 var anthropicProviderOptionsSchema = anthropicGenerateProviderOptionsSchema;
 
 // src/chat-adapter.ts
+var DEFAULT_PROVIDER_ID = "anthropic";
 var UNSUPPORTED_ANTHROPIC_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
   "minimum",
   "maximum",
@@ -304,14 +296,14 @@ function convertUserContentPart(part) {
     }
   };
 }
-function convertTools(tools) {
+function convertTools(tools, useStrictToolSchemas = true) {
   return Object.values(tools).map((tool) => {
     const schema = toAnthropicJsonSchema(tool.parameters);
     return {
       name: tool.name,
       description: tool.description,
       input_schema: schema,
-      strict: true
+      ...useStrictToolSchemas ? { strict: true } : {}
     };
   });
 }
@@ -389,7 +381,7 @@ function isObjectSchema(value) {
 function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function createGenerateRequest(modelId, defaultMaxTokens, options) {
+function createGenerateRequest(modelId, defaultMaxTokens, options, provider = DEFAULT_PROVIDER_ID, useStrictToolSchemas = true) {
   const anthropicOptions = parseAnthropicGenerateProviderOptions(
     options.providerOptions
   );
@@ -397,11 +389,13 @@ function createGenerateRequest(modelId, defaultMaxTokens, options) {
     modelId,
     defaultMaxTokens,
     options,
-    anthropicOptions
+    anthropicOptions,
+    provider,
+    useStrictToolSchemas
   );
   return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
-function createStreamRequest(modelId, defaultMaxTokens, options) {
+function createStreamRequest(modelId, defaultMaxTokens, options, provider = DEFAULT_PROVIDER_ID, useStrictToolSchemas = true) {
   const anthropicOptions = parseAnthropicGenerateProviderOptions(
     options.providerOptions
   );
@@ -410,19 +404,22 @@ function createStreamRequest(modelId, defaultMaxTokens, options) {
       modelId,
       defaultMaxTokens,
       options,
-      anthropicOptions
+      anthropicOptions,
+      provider,
+      useStrictToolSchemas
     ),
     stream: true
   };
   return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
-function createRequestBase(modelId, defaultMaxTokens, options, anthropicOptions) {
+function createRequestBase(modelId, defaultMaxTokens, options, anthropicOptions, provider, useStrictToolSchemas) {
   const maxTokens = options.maxTokens ?? defaultMaxTokens;
   validateAnthropicReasoningConfig(
     modelId,
     maxTokens,
     options,
-    anthropicOptions
+    anthropicOptions,
+    provider
   );
   const converted = convertMessages(options.messages);
   const reasoningFields = mapReasoningToRequestFields(
@@ -435,7 +432,7 @@ function createRequestBase(modelId, defaultMaxTokens, options, anthropicOptions)
     messages: converted.messages,
     max_tokens: maxTokens,
     ...converted.system ? { system: converted.system } : {},
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
+    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools, useStrictToolSchemas) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
     ...reasoningFields,
     ...mapSamplingToRequestFields(options)
@@ -447,27 +444,27 @@ function mapSamplingToRequestFields(options) {
     ...options.topP !== void 0 ? { top_p: options.topP } : {}
   };
 }
-function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropicOptions) {
+function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropicOptions, provider) {
   const alwaysRestrictsSampling = restrictsAnthropicSamplingParamsAlways(modelId);
   if (alwaysRestrictsSampling && options.temperature !== void 0 && options.temperature !== 1) {
     throw new ValidationError(
       `Anthropic model "${modelId}" only supports the default temperature of 1`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (alwaysRestrictsSampling && options.topP !== void 0 && options.topP !== 1) {
     throw new ValidationError(
       `Anthropic model "${modelId}" only supports the default topP of 1`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (alwaysRestrictsSampling && anthropicOptions?.topK !== void 0) {
     throw new ValidationError(
       `Anthropic model "${modelId}" does not support top_k`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (!options.reasoning) {
@@ -477,35 +474,35 @@ function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropic
     throw new ValidationError(
       `Anthropic model "${modelId}" requires maxTokens greater than 1024 when reasoning is enabled`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (options.temperature !== void 0 && (!alwaysRestrictsSampling || options.temperature !== 1)) {
     throw new ValidationError(
       `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (options.topP !== void 0 && (options.topP < 0.95 || options.topP > 1)) {
     throw new ValidationError(
       `Anthropic model "${modelId}" requires topP between 0.95 and 1 when reasoning is enabled`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (options.toolChoice && options.toolChoice !== "auto" && options.toolChoice !== "none") {
     throw new ValidationError(
       `Anthropic model "${modelId}" only supports toolChoice "auto" or "none" when reasoning is enabled`,
       void 0,
-      "anthropic"
+      provider
     );
   }
   if (anthropicOptions?.topK !== void 0) {
     throw new ValidationError(
       `Anthropic model "${modelId}" does not support top_k when reasoning is enabled`,
       void 0,
-      "anthropic"
+      provider
     );
   }
 }
@@ -843,29 +840,33 @@ function extractThinkingText(value) {
     return typeof text === "string" ? [text] : [];
   }).join("");
 }
-function wrapError(error) {
+function wrapError(error, provider = DEFAULT_PROVIDER_ID) {
   if (error instanceof APIUserAbortError || error instanceof Error && error.name === "AbortError") {
-    return new AbortedError(error, "anthropic");
+    return new AbortedError(error, provider);
   }
   if (error instanceof APIError) {
-    return new ProviderError(
-      error.message,
-      "anthropic",
-      error.status,
-      error
-    );
+    return new ProviderError(error.message, provider, error.status, error);
   }
   return new ProviderError(
     error instanceof Error ? error.message : String(error),
-    "anthropic",
+    provider,
     void 0,
     error
   );
 }
 
 // src/chat-model.ts
-function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
-  const provider = "anthropic";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStream,
+  createChatStream
+} from "@core-ai/core-ai";
+function createAnthropicChatModel(client, modelId, modelOptions = {}) {
+  const defaultMaxTokens = modelOptions.defaultMaxTokens ?? 4096;
+  const provider = modelOptions.providerId ?? DEFAULT_PROVIDER_ID;
+  const useStrictToolSchemas = modelOptions.useStrictToolSchemas ?? true;
   async function callAnthropicMessagesApi(request, betas, signal) {
     try {
       return await client.messages.create(request, {
@@ -877,20 +878,28 @@ function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
         signal
       });
     } catch (error) {
-      throw wrapError(error);
+      throw wrapError(error, provider);
     }
   }
   async function generateChat(options) {
     const request = createGenerateRequest(
       modelId,
       defaultMaxTokens,
-      options
+      options,
+      provider,
+      useStrictToolSchemas
     );
     const response = await callAnthropicMessagesApi(request, getAnthropicRequestBetas(modelId, options), options.signal);
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
-    const request = createStreamRequest(modelId, defaultMaxTokens, options);
+    const request = createStreamRequest(
+      modelId,
+      defaultMaxTokens,
+      options,
+      provider,
+      useStrictToolSchemas
+    );
     return createChatStream(
       async () => transformStream(
         await callAnthropicMessagesApi(
@@ -1057,20 +1066,30 @@ function formatZodIssues(issues) {
 }
 
 // src/provider.ts
-function createAnthropic(options = {}) {
+function createAnthropicChatProvider(options = {}, factoryOptions = {}) {
   const client = options.client ?? new Anthropic({
     apiKey: options.apiKey,
     baseURL: options.baseURL
   });
   const defaultMaxTokens = options.defaultMaxTokens ?? 4096;
+  const providerId = factoryOptions.providerId ?? DEFAULT_PROVIDER_ID;
+  const useStrictToolSchemas = factoryOptions.useStrictToolSchemas ?? true;
   return {
-    chatModel: (modelId) => createAnthropicChatModel(client, modelId, defaultMaxTokens)
+    chatModel: (modelId) => createAnthropicChatModel(client, modelId, {
+      defaultMaxTokens,
+      providerId,
+      useStrictToolSchemas
+    })
   };
 }
+function createAnthropic(options = {}) {
+  return createAnthropicChatProvider(options);
+}
 export {
   anthropicCacheControlSchema,
   anthropicGenerateProviderOptionsSchema,
   anthropicProviderOptionsSchema,
   createAnthropic,
+  createAnthropicChatProvider,
   getAnthropicModelCapabilities
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.14.0",
+    "version": "0.16.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -45,7 +45,7 @@
     },
     "dependencies": {
         "@anthropic-ai/sdk": "^0.110.0",
-        "@core-ai/core-ai": "^0.14.0"
+        "@core-ai/core-ai": "^0.16.0"
     },
     "peerDependencies": {
         "zod": "^4.0.0"