@effect/ai-anthropic 0.4.1 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/ai-anthropic",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Effect modules for working with AI apis",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,7 @@
     "@anthropic-ai/tokenizer": "^0.0.4"
   },
   "peerDependencies": {
-    "@effect/ai": "^0.14.1",
+    "@effect/ai": "^0.15.0",
     "@effect/experimental": "^0.45.1",
     "@effect/platform": "^0.81.1",
     "effect": "^3.14.22"
@@ -37,16 +37,16 @@
       "import": "./dist/esm/AnthropicClient.js",
       "default": "./dist/cjs/AnthropicClient.js"
     },
-    "./AnthropicCompletions": {
-      "types": "./dist/dts/AnthropicCompletions.d.ts",
-      "import": "./dist/esm/AnthropicCompletions.js",
-      "default": "./dist/cjs/AnthropicCompletions.js"
-    },
     "./AnthropicConfig": {
       "types": "./dist/dts/AnthropicConfig.d.ts",
       "import": "./dist/esm/AnthropicConfig.js",
       "default": "./dist/cjs/AnthropicConfig.js"
     },
+    "./AnthropicLanguageModel": {
+      "types": "./dist/dts/AnthropicLanguageModel.d.ts",
+      "import": "./dist/esm/AnthropicLanguageModel.js",
+      "default": "./dist/cjs/AnthropicLanguageModel.js"
+    },
     "./AnthropicTokenizer": {
       "types": "./dist/dts/AnthropicTokenizer.d.ts",
       "import": "./dist/esm/AnthropicTokenizer.js",
@@ -68,12 +68,12 @@
       "AnthropicClient": [
         "./dist/dts/AnthropicClient.d.ts"
       ],
-      "AnthropicCompletions": [
-        "./dist/dts/AnthropicCompletions.d.ts"
-      ],
       "AnthropicConfig": [
         "./dist/dts/AnthropicConfig.d.ts"
       ],
+      "AnthropicLanguageModel": [
+        "./dist/dts/AnthropicLanguageModel.d.ts"
+      ],
       "AnthropicTokenizer": [
         "./dist/dts/AnthropicTokenizer.d.ts"
       ],

package/src/AnthropicClient.ts

@@ -2,32 +2,32 @@
  * @since 1.0.0
  */
 import * as AiError from "@effect/ai/AiError"
-import * as AiModels from "@effect/ai/AiModels"
+import * as AiInput from "@effect/ai/AiInput"
 import * as AiResponse from "@effect/ai/AiResponse"
-import * as AiRole from "@effect/ai/AiRole"
 import * as Sse from "@effect/experimental/Sse"
 import * as HttpBody from "@effect/platform/HttpBody"
 import * as HttpClient from "@effect/platform/HttpClient"
 import type * as HttpClientError from "@effect/platform/HttpClientError"
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
-import * as Chunk from "effect/Chunk"
 import * as Config from "effect/Config"
 import type { ConfigError } from "effect/ConfigError"
 import * as Context from "effect/Context"
-import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import { identity } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
 import * as Redacted from "effect/Redacted"
 import * as Stream from "effect/Stream"
-import type { Mutable } from "effect/Types"
 import { AnthropicConfig } from "./AnthropicConfig.js"
 import * as Generated from "./Generated.js"
+import * as InternalUtilities from "./internal/utilities.js"
+
+const constDisableValidation = { disableValidation: true } as const
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Context
  */
 export class AnthropicClient extends Context.Tag(
   "@effect/ai-openai/AnthropicClient"
@@ -35,12 +35,11 @@ export class AnthropicClient extends Context.Tag(
 
 /**
  * @since 1.0.0
- * @category models
  */
 export declare namespace AnthropicClient {
   /**
    * @since 1.0.0
-   * @category models
+   * @category Models
    */
   export interface Service {
     readonly client: Generated.Client
@@ -49,13 +48,13 @@ export declare namespace AnthropicClient {
     ) => Stream.Stream<A, HttpClientError.HttpClientError>
     readonly stream: (
       request: StreamCompletionRequest
-    ) => Stream.Stream<StreamChunk, HttpClientError.HttpClientError>
+    ) => Stream.Stream<AiResponse.AiResponse, HttpClientError.HttpClientError>
   }
 }
 
 /**
  * @since 1.0.0
- * @category constructors
+ * @category Constructors
  */
 export const make = (options: {
   readonly apiKey?: Redacted.Redacted | undefined
@@ -71,9 +70,19 @@ export const make = (options: {
     const httpClient = (yield* HttpClient.HttpClient).pipe(
       HttpClient.mapRequest((request) =>
         request.pipe(
-          HttpClientRequest.prependUrl(options.apiUrl ?? "https://api.anthropic.com"),
-          options.apiKey ? HttpClientRequest.setHeader("x-api-key", Redacted.value(options.apiKey)) : identity,
-          HttpClientRequest.setHeader("anthropic-version", options.anthropicVersion ?? "2023-06-01"),
+          HttpClientRequest.prependUrl(
+            options.apiUrl ?? "https://api.anthropic.com"
+          ),
+          options.apiKey
+            ? HttpClientRequest.setHeader(
+              "x-api-key",
+              Redacted.value(options.apiKey)
+            )
+            : identity,
+          HttpClientRequest.setHeader(
+            "anthropic-version",
+            options.anthropicVersion ?? "2023-06-01"
+          ),
           HttpClientRequest.acceptJson
         )
       ),
@@ -99,100 +108,195 @@ export const make = (options: {
       )
     const stream = (request: StreamCompletionRequest) =>
       Stream.suspend(() => {
-        const usage: Mutable<Partial<UsagePart>> = { _tag: "Usage" }
+        const toolCalls = {} as Record<number, RawToolCall>
+        let finishReason: AiResponse.FinishReason = "unknown"
+        let reasoning:
+          | {
+            readonly content: Array<string>
+            readonly signature?: string
+          }
+          | undefined = undefined
+        let usage: AiResponse.Usage = {
+          inputTokens: 0,
+          outputTokens: 0,
+          totalTokens: 0,
+          reasoningTokens: 0,
+          cacheReadInputTokens: 0,
+          cacheWriteInputTokens: 0
+        }
+        const metadata: Record<string, unknown> = {}
         return streamRequest<MessageStreamEvent>(
           HttpClientRequest.post("/v1/messages", {
             body: HttpBody.unsafeJson({ ...request, stream: true })
           })
         ).pipe(
-          Stream.mapAccumEffect(new Map<number, ContentPart | ToolCallPart>(), (acc, chunk) => {
-            const parts: Array<StreamChunkPart> = []
+          Stream.filterMapEffect((chunk) => {
+            const parts: Array<AiResponse.Part> = []
             switch (chunk.type) {
               case "message_start": {
-                usage.id = chunk.message.id
-                usage.model = chunk.message.model
-                usage.inputTokens = chunk.message.usage.input_tokens
+                usage = {
+                  inputTokens: chunk.message.usage.input_tokens,
+                  outputTokens: chunk.message.usage.output_tokens,
+                  totalTokens: chunk.message.usage.input_tokens +
+                    chunk.message.usage.output_tokens,
+                  reasoningTokens: 0,
+                  cacheWriteInputTokens: chunk.message.usage.cache_creation_input_tokens ?? 0,
+                  cacheReadInputTokens: chunk.message.usage.cache_read_input_tokens ?? 0
+                }
+                parts.push(
+                  new AiResponse.MetadataPart(
+                    {
+                      id: chunk.message.id,
+                      model: chunk.message.model
+                    },
+                    constDisableValidation
+                  )
+                )
                 break
               }
               case "message_delta": {
-                usage.finishReasons = [chunk.delta.stop_reason]
-                usage.outputTokens = chunk.usage.output_tokens
-                parts.push(usage as UsagePart)
+                usage = {
+                  ...usage,
+                  outputTokens: chunk.usage.output_tokens
+                }
+                if (Predicate.isNotNullable(chunk.delta.stop_sequence)) {
+                  metadata.stopSequence = chunk.delta.stop_sequence
+                }
+                finishReason = InternalUtilities.resolveFinishReason(chunk.delta.stop_reason)
                 break
               }
               case "message_stop": {
+                parts.push(
+                  new AiResponse.FinishPart({
+                    usage,
+                    reason: finishReason,
+                    providerMetadata: { [InternalUtilities.ProviderMetadataKey]: metadata }
+                  }, constDisableValidation)
+                )
                 break
               }
               case "content_block_start": {
                 const content = chunk.content_block
-                if (content.type === "tool_use") {
-                  acc.set(chunk.index, {
-                    _tag: "ToolCall",
-                    id: content.id,
-                    name: content.name,
-                    arguments: ""
-                  })
+                switch (content.type) {
+                  case "text": {
+                    break
+                  }
+                  case "thinking": {
+                    reasoning = { content: [content.thinking] }
+                    break
+                  }
+                  case "tool_use": {
+                    toolCalls[chunk.index] = {
+                      id: content.id,
+                      name: content.name,
+                      params: ""
+                    }
+                    break
+                  }
+                  case "redacted_thinking": {
+                    parts.push(
+                      new AiResponse.RedactedReasoningPart(
+                        { redactedText: content.data },
+                        constDisableValidation
+                      )
+                    )
+                    break
+                  }
                 }
                 break
               }
               case "content_block_delta": {
                 switch (chunk.delta.type) {
-                  // TODO: add support for citations (?)
-                  case "citations_delta": {
+                  case "text_delta": {
+                    parts.push(
+                      new AiResponse.TextPart(
+                        { text: chunk.delta.text },
+                        constDisableValidation
+                      )
+                    )
+                    break
+                  }
+                  case "thinking_delta": {
+                    if (Predicate.isNotUndefined(reasoning)) {
+                      reasoning.content.push(chunk.delta.thinking)
+                    }
+                    break
+                  }
+                  case "signature_delta": {
+                    if (Predicate.isNotUndefined(reasoning)) {
+                      reasoning = {
+                        ...reasoning,
+                        signature: chunk.delta.signature
+                      }
+                    }
                     break
                   }
                   case "input_json_delta": {
-                    const toolCall = acc.get(chunk.index) as ToolCallPart
-                    acc.set(chunk.index, {
-                      ...toolCall,
-                      arguments: toolCall.arguments + chunk.delta.partial_json
-                    })
+                    const tool = toolCalls[chunk.index]
+                    if (Predicate.isNotUndefined(tool)) {
+                      tool.params += chunk.delta.partial_json
+                    }
                     break
                   }
-                  case "text_delta": {
-                    parts.push({
-                      _tag: "Content",
-                      content: chunk.delta.text
-                    })
+                  // TODO: add support for citations (?)
+                  case "citations_delta": {
                     break
                   }
                 }
                 break
               }
               case "content_block_stop": {
-                if (acc.has(chunk.index)) {
-                  const toolCall = acc.get(chunk.index) as ToolCallPart
+                if (Predicate.isNotUndefined(toolCalls[chunk.index])) {
+                  const tool = toolCalls[chunk.index]
                   try {
-                    const args = JSON.parse(toolCall.arguments as string)
-                    parts.push({
-                      _tag: "ToolCall",
-                      id: toolCall.id,
-                      name: toolCall.name,
-                      arguments: args
-                    })
+                    const params = JSON.parse(tool.params)
+                    parts.push(
+                      new AiResponse.ToolCallPart({
+                        id: AiInput.ToolCallId.make(tool.id),
+                        name: tool.name,
+                        params
+                      }, constDisableValidation)
+                    )
+                    delete toolCalls[chunk.index]
                     // eslint-disable-next-line no-empty
                   } catch {}
                 }
+                if (Predicate.isNotUndefined(reasoning)) {
+                  parts.push(
+                    new AiResponse.ReasoningPart({
+                      reasoningText: reasoning.content.join(""),
+                      signature: reasoning.signature
+                    }, constDisableValidation)
+                  )
+                  reasoning = undefined
+                }
                 break
               }
               case "error": {
-                return Effect.die(
-                  new AiError.AiError({
-                    module: "AnthropicClient",
-                    method: "stream",
-                    description: `${chunk.error.type}: ${chunk.error.message}`
-                  })
+                return Option.some(
+                  Effect.die(
+                    new AiError.AiError({
+                      module: "AnthropicClient",
+                      method: "stream",
+                      description: `${chunk.error.type}: ${chunk.error.message}`
+                    })
+                  )
                 )
               }
             }
-            return Effect.succeed([
-              acc,
-              parts.length === 0
-                ? Option.none()
-                : Option.some(new StreamChunk({ parts }))
-            ])
-          }),
-          Stream.filterMap(identity)
+            return parts.length === 0
+              ? Option.none()
+              : Option.some(
+                Effect.succeed(
+                  AiResponse.AiResponse.make(
+                    {
+                      parts
+                    },
+                    constDisableValidation
+                  )
+                )
+              )
+          })
         )
       })
     return AnthropicClient.of({ client, streamRequest, stream })
@@ -200,7 +304,7 @@ export const make = (options: {
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layer = (options: {
   readonly apiKey?: Redacted.Redacted | undefined
@@ -209,15 +313,15 @@ export const layer = (options: {
   readonly transformClient?: (
     client: HttpClient.HttpClient
   ) => HttpClient.HttpClient
-}): Layer.Layer<AiModels.AiModels | AnthropicClient, never, HttpClient.HttpClient> =>
-  Layer.merge(
-    AiModels.layer,
-    Layer.effect(AnthropicClient, make(options))
-  )
+}): Layer.Layer<
+  AnthropicClient,
+  never,
+  HttpClient.HttpClient
+> => Layer.effect(AnthropicClient, make(options))
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerConfig = (
   options: Config.Config.Wrap<{
@@ -228,16 +332,19 @@ export const layerConfig = (
       client: HttpClient.HttpClient
     ) => HttpClient.HttpClient
   }>
-): Layer.Layer<AiModels.AiModels | AnthropicClient, ConfigError, HttpClient.HttpClient> =>
+): Layer.Layer<
+  AnthropicClient,
+  ConfigError,
+  HttpClient.HttpClient
+> =>
   Config.unwrap(options).pipe(
     Effect.flatMap(make),
-    Layer.effect(AnthropicClient),
-    Layer.merge(AiModels.layer)
+    Layer.effect(AnthropicClient)
   )
 
 /**
  * @since 1.0.0
- * @category models
+ * @category Models
  */
 export type StreamCompletionRequest = Omit<
   typeof Generated.CreateMessageParams.Encoded,
@@ -280,9 +387,7 @@ interface MessageStopEvent {
 interface ContentBlockStartEvent {
   readonly type: "content_block_start"
   readonly index: number
-  readonly content_block:
-    | typeof Generated.ResponseTextBlock.Encoded
-    | typeof Generated.ResponseToolUseBlock.Encoded
+  readonly content_block: typeof Generated.ContentBlock.Encoded
 }
 
 interface ContentBlockDeltaEvent {
@@ -291,7 +396,9 @@ interface ContentBlockDeltaEvent {
   readonly delta:
     | CitationsDelta
     | InputJsonContentBlockDelta
+    | SignatureDelta
     | TextContentBlockDelta
+    | ThinkingDelta
 }
 
 interface CitationsDelta {
@@ -306,11 +413,21 @@ interface InputJsonContentBlockDelta {
   readonly partial_json: string
 }
 
+interface SignatureDelta {
+  readonly type: "signature_delta"
+  readonly signature: string
+}
+
 interface TextContentBlockDelta {
   readonly type: "text_delta"
   readonly text: string
 }
 
+interface ThinkingDelta {
+  readonly type: "thinking_delta"
+  readonly thinking: string
+}
+
 interface ContentBlockStopEvent {
   readonly type: "content_block_stop"
   readonly index: number
@@ -332,90 +449,8 @@ interface ErrorEvent {
   }
 }
 
-/**
- * @since 1.0.0
- * @category models
- */
-export class StreamChunk extends Data.Class<{
-  readonly parts: Array<StreamChunkPart>
-}> {
-  /**
-   * @since 1.0.0
-   */
-  get text(): Option.Option<string> {
-    return this.parts[0]?._tag === "Content"
-      ? Option.some(this.parts[0].content)
-      : Option.none()
-  }
-  /**
-   * @since 1.0.0
-   */
-  get asAiResponse(): AiResponse.AiResponse {
-    if (this.parts.length === 0) {
-      return AiResponse.AiResponse.fromText({
-        role: AiRole.model,
-        content: ""
-      })
-    }
-    const part = this.parts[0]
-    switch (part._tag) {
-      case "Content":
-        return AiResponse.AiResponse.fromText({
-          role: AiRole.model,
-          content: part.content
-        })
-      case "ToolCall":
-        return new AiResponse.AiResponse({
-          role: AiRole.model,
-          parts: Chunk.of(
-            AiResponse.ToolCallPart.fromUnknown({
-              id: part.id,
-              name: part.name,
-              params: part.arguments
-            })
-          )
-        })
-      case "Usage":
-        return AiResponse.AiResponse.empty
-    }
-  }
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export type StreamChunkPart = ContentPart | ToolCallPart | UsagePart
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface ContentPart {
-  readonly _tag: "Content"
-  readonly content: string
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface ToolCallPart {
-  readonly _tag: "ToolCall"
+type RawToolCall = {
   readonly id: string
   readonly name: string
-  readonly arguments: unknown
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface UsagePart {
-  readonly _tag: "Usage"
-  readonly id: string
-  readonly model: string
-  readonly inputTokens: number
-  readonly outputTokens: number
-  readonly finishReasons: ReadonlyArray<string>
+  params: string
 }

package/src/AnthropicConfig.ts

@@ -8,7 +8,7 @@ import { dual } from "effect/Function"
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Context
  */
 export class AnthropicConfig extends Context.Tag("@effect/ai-openai/AnthropicConfig")<
   AnthropicConfig,
@@ -25,12 +25,11 @@ export class AnthropicConfig extends Context.Tag("@effect/ai-openai/AnthropicCon
 
 /**
  * @since 1.0.0
- * @category models
  */
 export declare namespace AnthropicConfig {
   /**
    * @since 1.0.0
-   * @category models
+   * @category Models
    */
   export interface Service {
     readonly transformClient?: (client: HttpClient) => HttpClient
@@ -39,17 +38,17 @@ export declare namespace AnthropicConfig {
 
 /**
  * @since 1.0.0
- * @category configuration
+ * @category Configuration
  */
 export const withClientTransform: {
   /**
    * @since 1.0.0
-   * @category configuration
+   * @category Configuration
    */
   (transform: (client: HttpClient) => HttpClient): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
    * @since 1.0.0
-   * @category configuration
+   * @category Configuration
    */
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
@@ -58,12 +57,12 @@ export const withClientTransform: {
 } = dual<
   /**
    * @since 1.0.0
-   * @category configuration
+   * @category Configuration
    */
   (transform: (client: HttpClient) => HttpClient) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   /**
    * @since 1.0.0
-   * @category configuration
+   * @category Configuration
    */
   <A, E, R>(
     self: Effect.Effect<A, E, R>,