@core-ai/anthropic 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { ChatModel } from '@core-ai/core-ai';
+import { z } from 'zod';
 
-type AnthropicProviderOptions = {
+type AnthropicProviderOptions$1 = {
     apiKey?: string;
     baseURL?: string;
     client?: Anthropic;
@@ -10,6 +11,51 @@ type AnthropicProviderOptions = {
 type AnthropicProvider = {
     chatModel(modelId: string): ChatModel;
 };
-declare function createAnthropic(options?: AnthropicProviderOptions): AnthropicProvider;
+declare function createAnthropic(options?: AnthropicProviderOptions$1): AnthropicProvider;
 
-export { type AnthropicProvider, type AnthropicProviderOptions, createAnthropic };
+type AnthropicReasoningMetadata = {
+    signature?: string;
+    redactedData?: string;
+};
+
+declare const anthropicGenerateProviderOptionsSchema: z.ZodObject<{
+    topK: z.ZodOptional<z.ZodNumber>;
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    betas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    outputConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    topK?: number | undefined;
+    stopSequences?: string[] | undefined;
+    betas?: string[] | undefined;
+    outputConfig?: Record<string, unknown> | undefined;
+}, {
+    topK?: number | undefined;
+    stopSequences?: string[] | undefined;
+    betas?: string[] | undefined;
+    outputConfig?: Record<string, unknown> | undefined;
+}>;
+type AnthropicGenerateProviderOptions = z.infer<typeof anthropicGenerateProviderOptionsSchema>;
+declare module '@core-ai/core-ai' {
+    interface GenerateProviderOptions {
+        anthropic?: AnthropicGenerateProviderOptions;
+    }
+}
+declare const anthropicProviderOptionsSchema: z.ZodObject<{
+    topK: z.ZodOptional<z.ZodNumber>;
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    betas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    outputConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    topK?: number | undefined;
+    stopSequences?: string[] | undefined;
+    betas?: string[] | undefined;
+    outputConfig?: Record<string, unknown> | undefined;
+}, {
+    topK?: number | undefined;
+    stopSequences?: string[] | undefined;
+    betas?: string[] | undefined;
+    outputConfig?: Record<string, unknown> | undefined;
+}>;
+type AnthropicProviderOptions = AnthropicGenerateProviderOptions;
+
+export { type AnthropicGenerateProviderOptions, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic };

package/dist/index.js

@@ -6,14 +6,128 @@ import {
   StructuredOutputNoObjectGeneratedError,
   StructuredOutputParseError,
   StructuredOutputValidationError,
-  createObjectStreamResult,
-  createStreamResult
+  createObjectStream,
+  createChatStream
 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
 import { APIError } from "@anthropic-ai/sdk";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { ProviderError } from "@core-ai/core-ai";
+import { ProviderError, getProviderMetadata } from "@core-ai/core-ai";
+
+// src/model-capabilities.ts
+var DEFAULT_CAPABILITIES = {
+  reasoning: {
+    thinkingMode: "adaptive",
+    supportsMaxEffort: false
+  }
+};
+var MODEL_CAPABILITIES = {
+  "claude-opus-4-6": {
+    reasoning: {
+      thinkingMode: "adaptive",
+      supportsMaxEffort: true
+    }
+  },
+  "claude-sonnet-4-6": {
+    reasoning: {
+      thinkingMode: "adaptive",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-opus-4-5": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-sonnet-4-5": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-opus-4-1": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-opus-4": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-sonnet-4": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-haiku-4-5": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  },
+  "claude-sonnet-3-7": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  }
+};
+function getAnthropicModelCapabilities(modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
+}
+function normalizeModelId(modelId) {
+  return modelId.replace(/-\d{8}$/, "");
+}
+function toAnthropicAdaptiveEffort(effort, supportsMaxEffort) {
+  if (effort === "minimal") {
+    return "low";
+  }
+  if (effort === "max") {
+    return supportsMaxEffort ? "max" : "high";
+  }
+  return 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;
+}
+
+// src/provider-options.ts
+import { z } from "zod";
+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()
+}).strict();
+function parseAnthropicGenerateProviderOptions(providerOptions) {
+  const rawOptions = providerOptions?.anthropic;
+  if (rawOptions === void 0) {
+    return void 0;
+  }
+  return anthropicGenerateProviderOptionsSchema.parse(rawOptions);
+}
+var anthropicProviderOptionsSchema = anthropicGenerateProviderOptionsSchema;
+
+// src/chat-adapter.ts
 var UNSUPPORTED_ANTHROPIC_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
   "minimum",
   "maximum",
@@ -44,18 +158,55 @@ function convertMessages(messages) {
     }
     if (message.role === "assistant") {
       const contentBlocks = [];
-      if (message.content) {
-        contentBlocks.push({
-          type: "text",
-          text: message.content
-        });
-      }
-      for (const toolCall of message.toolCalls ?? []) {
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          contentBlocks.push({
+            type: "text",
+            text: part.text
+          });
+          continue;
+        }
+        if (part.type === "tool-call") {
+          contentBlocks.push({
+            type: "tool_use",
+            id: part.toolCall.id,
+            name: part.toolCall.name,
+            input: part.toolCall.arguments
+          });
+          continue;
+        }
+        const anthropicMeta = getProviderMetadata(
+          part.providerMetadata,
+          "anthropic"
+        );
+        if (anthropicMeta == null) {
+          if (part.text.length > 0) {
+            contentBlocks.push({
+              type: "text",
+              text: `<thinking>${part.text}</thinking>`
+            });
+          }
+          continue;
+        }
+        const { signature, redactedData } = anthropicMeta;
+        if (typeof redactedData === "string") {
+          contentBlocks.push({
+            type: "redacted_thinking",
+            data: redactedData
+          });
+          continue;
+        }
+        if (part.text.length === 0) {
+          continue;
+        }
+        if (typeof signature !== "string") {
+          contentBlocks.push({ type: "text", text: part.text });
+          continue;
+        }
         contentBlocks.push({
-          type: "tool_use",
-          id: toolCall.id,
-          name: toolCall.name,
-          input: toolCall.arguments
+          type: "thinking",
+          thinking: part.text,
+          signature
         });
       }
       convertedMessages.push({
@@ -163,13 +314,19 @@ function createStructuredOutputOptions(options) {
   }
   return {
     messages: options.messages,
-    config: options.config,
+    reasoning: options.reasoning,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    topP: options.topP,
     providerOptions: {
       ...options.providerOptions ?? {},
-      output_config: {
-        format: {
-          type: "json_schema",
-          schema
+      anthropic: {
+        ...options.providerOptions?.anthropic ?? {},
+        outputConfig: {
+          format: {
+            type: "json_schema",
+            schema
+          }
         }
       }
     },
@@ -210,58 +367,187 @@ function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function createGenerateRequest(modelId, defaultMaxTokens, options) {
-  return {
-    ...createRequestBase(modelId, defaultMaxTokens, options),
-    ...options.providerOptions
-  };
+  const anthropicOptions = parseAnthropicGenerateProviderOptions(
+    options.providerOptions
+  );
+  const baseRequest = createRequestBase(
+    modelId,
+    defaultMaxTokens,
+    options,
+    anthropicOptions
+  );
+  return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
 function createStreamRequest(modelId, defaultMaxTokens, options) {
-  return {
-    ...createRequestBase(modelId, defaultMaxTokens, options),
-    stream: true,
-    ...options.providerOptions
+  const anthropicOptions = parseAnthropicGenerateProviderOptions(
+    options.providerOptions
+  );
+  const baseRequest = {
+    ...createRequestBase(
+      modelId,
+      defaultMaxTokens,
+      options,
+      anthropicOptions
+    ),
+    stream: true
   };
+  return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
-function createRequestBase(modelId, defaultMaxTokens, options) {
+function createRequestBase(modelId, defaultMaxTokens, options, anthropicOptions) {
+  validateAnthropicReasoningConfig(modelId, options, anthropicOptions);
   const converted = convertMessages(options.messages);
+  const reasoningFields = mapReasoningToRequestFields(modelId, options);
   return {
     model: modelId,
     messages: converted.messages,
-    max_tokens: options.config?.maxTokens ?? defaultMaxTokens,
+    max_tokens: options.maxTokens ?? defaultMaxTokens,
     ...converted.system ? { system: converted.system } : {},
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
-    ...mapConfigToRequestFields(options.config)
+    ...reasoningFields,
+    ...mapSamplingToRequestFields(options)
   };
 }
-function mapConfigToRequestFields(config) {
+function mapSamplingToRequestFields(options) {
   return {
-    ...config?.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config?.topP !== void 0 ? { top_p: config.topP } : {},
-    ...config?.stopSequences ? { stop_sequences: config.stopSequences } : {}
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    ...options.topP !== void 0 ? { top_p: options.topP } : {}
+  };
+}
+function validateAnthropicReasoningConfig(modelId, options, anthropicOptions) {
+  if (!options.reasoning) {
+    return;
+  }
+  if (options.temperature !== void 0) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  if (options.topP !== void 0 && (options.topP < 0.95 || options.topP > 1)) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" requires topP between 0.95 and 1 when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  if (options.toolChoice && options.toolChoice !== "auto" && options.toolChoice !== "none") {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" only supports toolChoice "auto" or "none" when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  if (anthropicOptions?.topK !== void 0) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" does not support top_k when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+}
+function mapReasoningToRequestFields(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getAnthropicModelCapabilities(modelId);
+  const baseFields = {};
+  if (options.tools && Object.keys(options.tools).length > 0) {
+    baseFields["betas"] = ["interleaved-thinking-2025-05-14"];
+  }
+  if (capabilities.reasoning.thinkingMode === "adaptive") {
+    baseFields["thinking"] = { type: "adaptive" };
+    baseFields["output_config"] = {
+      effort: toAnthropicAdaptiveEffort(
+        options.reasoning.effort,
+        capabilities.reasoning.supportsMaxEffort
+      )
+    };
+    return baseFields;
+  }
+  baseFields["thinking"] = {
+    type: "enabled",
+    budget_tokens: toAnthropicManualBudget(options.reasoning.effort)
   };
+  return baseFields;
+}
+function mapAnthropicProviderOptionsToRequest(baseRequest, providerOptions) {
+  if (!providerOptions) {
+    return baseRequest;
+  }
+  const baseOutputConfig = asObject(
+    baseRequest.output_config
+  );
+  const mergedOutputConfig = {
+    ...baseOutputConfig,
+    ...providerOptions.outputConfig ?? {}
+  };
+  const mergedBetas = [
+    ...asStringArray(baseRequest.betas),
+    ...providerOptions.betas ?? []
+  ];
+  const mergedRequest = {
+    ...baseRequest,
+    ...providerOptions.topK !== void 0 ? { top_k: providerOptions.topK } : {},
+    ...providerOptions.stopSequences ? { stop_sequences: providerOptions.stopSequences } : {},
+    ...Object.keys(mergedOutputConfig).length > 0 ? { output_config: mergedOutputConfig } : {},
+    ...mergedBetas.length > 0 ? { betas: uniqueStrings(mergedBetas) } : {}
+  };
+  return mergedRequest;
 }
 function mapGenerateResponse(response) {
-  const toolCalls = [];
-  let content = "";
+  const parts = [];
   for (const block of response.content) {
     if (block.type === "text") {
-      content += block.text;
+      parts.push({
+        type: "text",
+        text: block.text
+      });
       continue;
     }
     if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        name: block.name,
-        arguments: asObject(block.input)
+      parts.push({
+        type: "tool-call",
+        toolCall: {
+          id: block.id,
+          name: block.name,
+          arguments: asObject(block.input)
+        }
+      });
+      continue;
+    }
+    if (block.type === "thinking") {
+      const thinkingText = typeof block.thinking === "string" ? block.thinking : extractThinkingText(block.thinking);
+      const signature = typeof block.signature === "string" ? block.signature : void 0;
+      parts.push({
+        type: "reasoning",
+        text: thinkingText,
+        providerMetadata: {
+          anthropic: { ...signature ? { signature } : {} }
+        }
+      });
+      continue;
+    }
+    if (block.type === "redacted_thinking") {
+      const redactedData = typeof block.data === "string" ? block.data : void 0;
+      parts.push({
+        type: "reasoning",
+        text: "",
+        providerMetadata: {
+          anthropic: { ...redactedData ? { redactedData } : {} }
+        }
       });
     }
   }
   const cacheReadTokens = response.usage.cache_read_input_tokens ?? 0;
   const cacheWriteTokens = response.usage.cache_creation_input_tokens ?? 0;
   const inputTokens = response.usage.input_tokens + cacheReadTokens + cacheWriteTokens;
+  const content = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+  const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
+  const toolCalls = parts.flatMap(
+    (part) => part.type === "tool-call" ? [part.toolCall] : []
+  );
   return {
+    parts,
     content: content.length > 0 ? content : null,
+    reasoning: reasoning.length > 0 ? reasoning : null,
     toolCalls,
     finishReason: mapStopReason(response.stop_reason),
     usage: {
@@ -271,9 +557,7 @@ function mapGenerateResponse(response) {
         cacheReadTokens,
         cacheWriteTokens
       },
-      outputTokenDetails: {
-        reasoningTokens: 0
-      }
+      outputTokenDetails: {}
     }
   };
 }
@@ -286,12 +570,12 @@ async function* transformStream(stream) {
       cacheReadTokens: 0,
       cacheWriteTokens: 0
     },
-    outputTokenDetails: {
-      reasoningTokens: 0
-    }
+    outputTokenDetails: {}
   };
   const toolBuffers = /* @__PURE__ */ new Map();
   const emittedToolCalls = /* @__PURE__ */ new Set();
+  const contentBlockTypeByIndex = /* @__PURE__ */ new Map();
+  const reasoningSignatureByIndex = /* @__PURE__ */ new Map();
   for await (const event of stream) {
     if (event.type === "message_start") {
       const cacheReadTokens = event.message.usage.cache_read_input_tokens ?? 0;
@@ -304,13 +588,18 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {
-          reasoningTokens: 0
-        }
+        outputTokenDetails: {}
       };
       continue;
     }
     if (event.type === "content_block_start") {
+      contentBlockTypeByIndex.set(event.index, event.content_block.type);
+      if (event.content_block.type === "thinking") {
+        yield {
+          type: "reasoning-start"
+        };
+        continue;
+      }
       if (event.content_block.type === "tool_use") {
         const block = event.content_block;
         const initialArguments = block.input && typeof block.input === "object" ? Object.keys(block.input).length > 0 ? JSON.stringify(block.input) : "" : "";
@@ -330,11 +619,29 @@ async function* transformStream(stream) {
     if (event.type === "content_block_delta") {
       if (event.delta.type === "text_delta") {
         yield {
-          type: "content-delta",
+          type: "text-delta",
           text: event.delta.text
         };
         continue;
       }
+      if (event.delta.type === "thinking_delta") {
+        const thinkingDelta = event.delta;
+        const thinkingText = typeof thinkingDelta.thinking === "string" ? thinkingDelta.thinking : typeof thinkingDelta.text === "string" ? thinkingDelta.text : "";
+        if (thinkingText.length > 0) {
+          yield {
+            type: "reasoning-delta",
+            text: thinkingText
+          };
+        }
+        continue;
+      }
+      if (event.delta.type === "signature_delta") {
+        reasoningSignatureByIndex.set(
+          event.index,
+          event.delta.signature
+        );
+        continue;
+      }
       if (event.delta.type === "input_json_delta") {
         const current = toolBuffers.get(event.index);
         if (!current) {
@@ -350,6 +657,19 @@ async function* transformStream(stream) {
       continue;
     }
     if (event.type === "content_block_stop") {
+      if (contentBlockTypeByIndex.get(event.index) === "thinking") {
+        const signature = reasoningSignatureByIndex.get(event.index);
+        reasoningSignatureByIndex.delete(event.index);
+        contentBlockTypeByIndex.delete(event.index);
+        yield {
+          type: "reasoning-end",
+          providerMetadata: {
+            anthropic: { ...signature ? { signature } : {} }
+          }
+        };
+        continue;
+      }
+      contentBlockTypeByIndex.delete(event.index);
       const current = toolBuffers.get(event.index);
       if (!current || emittedToolCalls.has(event.index)) {
         continue;
@@ -377,9 +697,7 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {
-          reasoningTokens: 0
-        }
+        outputTokenDetails: {}
       };
       continue;
     }
@@ -419,6 +737,30 @@ function asObject(value) {
   }
   return {};
 }
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function extractThinkingText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const text = item.text;
+    return typeof text === "string" ? [text] : [];
+  }).join("");
+}
 function wrapError(error) {
   if (error instanceof APIError) {
     return new ProviderError(
@@ -439,22 +781,32 @@ function wrapError(error) {
 // src/chat-model.ts
 function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
   const provider = "anthropic";
-  async function callAnthropicMessagesApi(request) {
+  async function callAnthropicMessagesApi(request, signal) {
     try {
-      return await client.messages.create(request);
+      return await client.messages.create(request, {
+        signal
+      });
     } catch (error) {
       throw wrapError(error);
     }
   }
   async function generateChat(options) {
-    const request = createGenerateRequest(modelId, defaultMaxTokens, options);
-    const response = await callAnthropicMessagesApi(request);
+    const request = createGenerateRequest(
+      modelId,
+      defaultMaxTokens,
+      options
+    );
+    const response = await callAnthropicMessagesApi(request, options.signal);
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
     const request = createStreamRequest(modelId, defaultMaxTokens, options);
-    const stream = await callAnthropicMessagesApi(request);
-    return createStreamResult(transformStream(stream));
+    return createChatStream(
+      async () => transformStream(
+        await callAnthropicMessagesApi(request, options.signal)
+      ),
+      { signal: options.signal }
+    );
   }
   return {
     provider,
@@ -464,7 +816,11 @@ function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
     async generateObject(options) {
       const structuredOptions = createStructuredOutputOptions(options);
       const result = await generateChat(structuredOptions);
-      const object = extractStructuredObject(result, options.schema, provider);
+      const object = extractStructuredObject(
+        result,
+        options.schema,
+        provider
+      );
       return {
         object,
         finishReason: result.finishReason,
@@ -474,12 +830,15 @@ function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
     async streamObject(options) {
       const structuredOptions = createStructuredOutputOptions(options);
       const stream = await streamChat(structuredOptions);
-      return createObjectStreamResult(
+      return createObjectStream(
         transformStructuredOutputStream(
           stream,
           options.schema,
           provider
-        )
+        ),
+        {
+          signal: options.signal
+        }
       );
     }
   };
@@ -496,7 +855,7 @@ function extractStructuredObject(result, schema, provider) {
 async function* transformStructuredOutputStream(stream, schema, provider) {
   let contentBuffer = "";
   for await (const event of stream) {
-    if (event.type === "content-delta") {
+    if (event.type === "text-delta") {
       contentBuffer += event.text;
       yield {
         type: "object-delta",
@@ -556,7 +915,10 @@ function requireStructuredOutputPayload(finishReason, rawOutput, provider, noPay
     );
   }
   if (!rawOutput || rawOutput.length === 0) {
-    throw new StructuredOutputNoObjectGeneratedError(noPayloadMessage, provider);
+    throw new StructuredOutputNoObjectGeneratedError(
+      noPayloadMessage,
+      provider
+    );
   }
   return rawOutput;
 }
@@ -611,5 +973,7 @@ function createAnthropic(options = {}) {
   };
 }
 export {
+  anthropicGenerateProviderOptionsSchema,
+  anthropicProviderOptionsSchema,
   createAnthropic
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.4.0",
+    "version": "0.6.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -38,12 +38,11 @@
         "build": "tsup",
         "lint": "eslint src/ --max-warnings 0",
         "check-types": "tsc --noEmit",
-        "prepublishOnly": "npm run build",
         "test": "vitest run",
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.4.0",
+        "@core-ai/core-ai": "^0.6.0",
         "@anthropic-ai/sdk": "^0.78.0",
         "zod-to-json-schema": "^3.25.1"
     },
@@ -51,8 +50,9 @@
         "zod": "^3.25.0 || ^4.0.0"
     },
     "devDependencies": {
-        "@core-ai/eslint-config": "^0.0.0",
-        "@core-ai/typescript-config": "^0.0.0",
+        "@core-ai/eslint-config": "*",
+        "@core-ai/testing": "*",
+        "@core-ai/typescript-config": "*",
         "typescript": "^5.7.3",
         "vitest": "^3.2.4"
     }