@core-ai/anthropic 0.5.1 → 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,14 @@ 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 = {
@@ -110,6 +110,23 @@ function toAnthropicManualBudget(effort) {
   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",
@@ -158,8 +175,20 @@ function convertMessages(messages) {
           });
           continue;
         }
-        const signature = part.providerMetadata?.["signature"];
-        const redactedData = part.providerMetadata?.["redactedData"];
+        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",
@@ -167,14 +196,18 @@ function convertMessages(messages) {
           });
           continue;
         }
-        const thinkingBlock = {
-          type: "thinking",
-          thinking: part.text
-        };
-        if (typeof signature === "string") {
-          thinkingBlock["signature"] = signature;
+        if (part.text.length === 0) {
+          continue;
+        }
+        if (typeof signature !== "string") {
+          contentBlocks.push({ type: "text", text: part.text });
+          continue;
         }
-        contentBlocks.push(thinkingBlock);
+        contentBlocks.push({
+          type: "thinking",
+          thinking: part.text,
+          signature
+        });
       }
       convertedMessages.push({
         role: "assistant",
@@ -282,13 +315,18 @@ function createStructuredOutputOptions(options) {
   return {
     messages: options.messages,
     reasoning: options.reasoning,
-    config: options.config,
+    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
+          }
         }
       }
     },
@@ -329,49 +367,64 @@ function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function createGenerateRequest(modelId, defaultMaxTokens, options) {
-  const baseRequest = createRequestBase(modelId, defaultMaxTokens, options);
-  return mergeProviderOptions(baseRequest, options.providerOptions);
+  const anthropicOptions = parseAnthropicGenerateProviderOptions(
+    options.providerOptions
+  );
+  const baseRequest = createRequestBase(
+    modelId,
+    defaultMaxTokens,
+    options,
+    anthropicOptions
+  );
+  return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
 function createStreamRequest(modelId, defaultMaxTokens, options) {
+  const anthropicOptions = parseAnthropicGenerateProviderOptions(
+    options.providerOptions
+  );
   const baseRequest = {
-    ...createRequestBase(modelId, defaultMaxTokens, options),
+    ...createRequestBase(
+      modelId,
+      defaultMaxTokens,
+      options,
+      anthropicOptions
+    ),
     stream: true
   };
-  return mergeProviderOptions(baseRequest, options.providerOptions);
+  return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
-function createRequestBase(modelId, defaultMaxTokens, options) {
-  validateAnthropicReasoningConfig(modelId, 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) } : {},
     ...reasoningFields,
-    ...mapConfigToRequestFields(options.config)
+    ...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) {
+function validateAnthropicReasoningConfig(modelId, options, anthropicOptions) {
   if (!options.reasoning) {
     return;
   }
-  if (options.config?.temperature !== void 0) {
+  if (options.temperature !== void 0) {
     throw new ProviderError(
       `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
       "anthropic"
     );
   }
-  if (options.config?.topP !== void 0 && (options.config.topP < 0.95 || options.config.topP > 1)) {
+  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"
@@ -383,8 +436,7 @@ function validateAnthropicReasoningConfig(modelId, options) {
       "anthropic"
     );
   }
-  const providerOptions = asObject(options.providerOptions);
-  if (providerOptions["top_k"] !== void 0) {
+  if (anthropicOptions?.topK !== void 0) {
     throw new ProviderError(
       `Anthropic model "${modelId}" does not support top_k when reasoning is enabled`,
       "anthropic"
@@ -416,25 +468,25 @@ function mapReasoningToRequestFields(modelId, options) {
   };
   return baseFields;
 }
-function mergeProviderOptions(baseRequest, providerOptions) {
+function mapAnthropicProviderOptionsToRequest(baseRequest, providerOptions) {
   if (!providerOptions) {
     return baseRequest;
   }
   const baseOutputConfig = asObject(
     baseRequest.output_config
   );
-  const providerOutputConfig = asObject(providerOptions["output_config"]);
   const mergedOutputConfig = {
     ...baseOutputConfig,
-    ...providerOutputConfig
+    ...providerOptions.outputConfig ?? {}
   };
   const mergedBetas = [
     ...asStringArray(baseRequest.betas),
-    ...asStringArray(providerOptions["betas"])
+    ...providerOptions.betas ?? []
   ];
   const mergedRequest = {
     ...baseRequest,
-    ...providerOptions,
+    ...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) } : {}
   };
@@ -467,11 +519,9 @@ function mapGenerateResponse(response) {
       parts.push({
         type: "reasoning",
         text: thinkingText,
-        ...signature ? {
-          providerMetadata: {
-            signature
-          }
-        } : {}
+        providerMetadata: {
+          anthropic: { ...signature ? { signature } : {} }
+        }
       });
       continue;
     }
@@ -480,11 +530,9 @@ function mapGenerateResponse(response) {
       parts.push({
         type: "reasoning",
         text: "",
-        ...redactedData ? {
-          providerMetadata: {
-            redactedData
-          }
-        } : {}
+        providerMetadata: {
+          anthropic: { ...redactedData ? { redactedData } : {} }
+        }
       });
     }
   }
@@ -527,6 +575,7 @@ async function* transformStream(stream) {
   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;
@@ -586,6 +635,13 @@ async function* transformStream(stream) {
         }
         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) {
@@ -602,11 +658,18 @@ async function* transformStream(stream) {
     }
     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"
+          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;
@@ -718,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,
@@ -743,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,
@@ -753,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
+        }
       );
     }
   };
@@ -835,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;
 }
@@ -890,5 +973,7 @@ function createAnthropic(options = {}) {
   };
 }
 export {
+  anthropicGenerateProviderOptionsSchema,
+  anthropicProviderOptionsSchema,
   createAnthropic
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.5.1",
+    "version": "0.6.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.5.1",
+        "@core-ai/core-ai": "^0.6.0",
         "@anthropic-ai/sdk": "^0.78.0",
         "zod-to-json-schema": "^3.25.1"
     },
@@ -50,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"
     }