@effect/ai-anthropic 0.0.2 → 0.0.4

package/src/AnthropicCompletions.ts

@@ -3,22 +3,25 @@
  */
 import { AiError } from "@effect/ai/AiError"
 import type * as AiInput from "@effect/ai/AiInput"
+import * as AiModel from "@effect/ai/AiModel"
 import * as AiResponse from "@effect/ai/AiResponse"
 import * as AiRole from "@effect/ai/AiRole"
 import { addGenAIAnnotations } from "@effect/ai/AiTelemetry"
 import * as Completions from "@effect/ai/Completions"
-import type * as Tokenizer from "@effect/ai/Tokenizer"
+import * as Tokenizer from "@effect/ai/Tokenizer"
 import * as Arr from "effect/Array"
 import * as Chunk from "effect/Chunk"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Stream from "effect/Stream"
 import type { Span } from "effect/Tracer"
+import type { Simplify } from "effect/Types"
 import type { StreamChunk } from "./AnthropicClient.js"
 import { AnthropicClient } from "./AnthropicClient.js"
-import { AnthropicConfig } from "./AnthropicConfig.js"
 import * as AnthropicTokenizer from "./AnthropicTokenizer.js"
 import type * as Generated from "./Generated.js"
 
@@ -28,97 +31,166 @@ import type * as Generated from "./Generated.js"
  */
 export type Model = typeof Generated.ModelEnum.Encoded
 
-const make = (options: { readonly model: (string & {}) | Model }) =>
-  Effect.gen(function*() {
-    const client = yield* AnthropicClient
-    const config = yield* AnthropicConfig.getOrUndefined
+// =============================================================================
+// Configuration
+// =============================================================================
 
-    const makeRequest = ({
-      input,
-      required,
-      system,
-      tools
-    }: Completions.CompletionOptions) => {
-      const useStructured = tools.length === 1 && tools[0].structured
-      return Effect.map(
-        Effect.context<never>(),
-        (context): typeof Generated.CreateMessageParams.Encoded => ({
-          model: options.model,
-          // TODO: re-evaluate a better way to do this
-          max_tokens: 4096,
-          ...config,
-          ...context.unsafeMap.get(AnthropicConfig.key),
-          system: Option.getOrUndefined(system),
-          messages: makeMessages(input),
-          tools: tools.length === 0 ? undefined : tools.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.parameters as any
-          })),
-          tool_choice: !useStructured && tools.length > 0
-            // For non-structured outputs, ensure tools are used if required
-            ? typeof required === "boolean"
-              ? required ? { type: "any" } : { type: "auto" }
-              : { type: "tool", name: required }
-            // For structured outputs, ensure the json output tool is used
-            : useStructured
-            ? { type: "tool", name: tools[0].name }
-            : undefined
-        })
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export class Config extends Context.Tag("@effect/ai-anthropic/AnthropicCompletions/Config")<
+  Config,
+  Config.Service
+>() {
+  /**
+   * @since 1.0.0
+   */
+  static readonly getOrUndefined: Effect.Effect<typeof Config.Service | undefined> = Effect.map(
+    Effect.context<never>(),
+    (context) => context.unsafeMap.get(Config.key)
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export declare namespace Config {
+  /**
+   * @since 1.0.0
+   * @category configuration
+   */
+  export interface Service extends
+    Simplify<
+      Partial<
+        Omit<
+          typeof Generated.CreateMessageParams.Encoded,
+          "messages" | "tools" | "tool_choice" | "stream"
+        >
+      >
+    >
+  {}
+}
+
+// =============================================================================
+// Anthropic Completions
+// =============================================================================
+
+const modelCacheKey = Symbol.for("@effect/ai-anthropic/AnthropicCompletions/AiModel")
+
+/**
+ * @since 1.0.0
+ * @category ai models
+ */
+export const model = (
+  model: (string & {}) | Model,
+  config?: Omit<Config.Service, "model">
+): AiModel.AiModel<Completions.Completions | Tokenizer.Tokenizer, AnthropicClient> =>
+  AiModel.make({
+    model,
+    cacheKey: modelCacheKey,
+    requires: AnthropicClient,
+    provides: make({ model, config }).pipe(
+      Effect.map((completions) =>
+        Context.merge(
+          Context.make(Completions.Completions, completions),
+          Context.make(Tokenizer.Tokenizer, AnthropicTokenizer.make)
+        )
       )
+    ),
+    updateContext: (context) => {
+      const innerConfig = context.unsafeMap.get(Config.key) as Config.Service | undefined
+      return Context.merge(context, Context.make(Config, { model, ...config, ...innerConfig }))
     }
+  })
 
-    return yield* Completions.make({
-      create({ span, ...options }) {
-        return makeRequest(options).pipe(
-          Effect.tap((request) => annotateRequest(span, request)),
-          Effect.flatMap((payload) => client.client.messagesPost({ params: {}, payload })),
-          Effect.tap((response) => annotateChatResponse(span, response)),
-          Effect.flatMap((response) =>
-            makeResponse(
-              response,
-              "create",
-              options.tools.length === 1 && options.tools[0].structured
-                ? options.tools[0]
-                : undefined
-            )
-          ),
-          Effect.catchAll((cause) =>
-            Effect.fail(
-              new AiError({
-                module: "AnthropicCompletions",
-                method: "create",
-                description: "An error occurred",
-                cause
-              })
-            )
+const make = Effect.fnUntraced(function*(options: {
+  readonly model: (string & {}) | Model
+  readonly config?: Omit<Config.Service, "model">
+}) {
+  const client = yield* AnthropicClient
+
+  const makeRequest = ({ input, required, system, tools }: Completions.CompletionOptions) => {
+    const useStructured = tools.length === 1 && tools[0].structured
+    return Effect.map(
+      Effect.context<never>(),
+      (context): typeof Generated.CreateMessageParams.Encoded => ({
+        model: options.model,
+        // TODO: re-evaluate a better way to do this
+        max_tokens: 4096,
+        ...options.config,
+        ...context.unsafeMap.get(Config.key),
+        system: Option.getOrUndefined(system),
+        messages: makeMessages(input),
+        tools: tools.length === 0 ? undefined : tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.parameters as any
+        })),
+        tool_choice: !useStructured && tools.length > 0
+          // For non-structured outputs, ensure tools are used if required
+          ? typeof required === "boolean"
+            ? required ? { type: "any" } : { type: "auto" }
+            : { type: "tool", name: required }
+          // For structured outputs, ensure the json output tool is used
+          : useStructured
+          ? { type: "tool", name: tools[0].name }
+          : undefined
+      })
+    )
+  }
+
+  return yield* Completions.make({
+    create({ span, ...options }) {
+      return makeRequest(options).pipe(
+        Effect.tap((request) => annotateRequest(span, request)),
+        Effect.flatMap((payload) => client.client.messagesPost({ params: {}, payload })),
+        Effect.tap((response) => annotateChatResponse(span, response)),
+        Effect.flatMap((response) =>
+          makeResponse(
+            response,
+            "create",
+            options.tools.length === 1 && options.tools[0].structured
+              ? options.tools[0]
+              : undefined
+          )
+        ),
+        Effect.catchAll((cause) =>
+          Effect.fail(
+            new AiError({
+              module: "AnthropicCompletions",
+              method: "create",
+              description: "An error occurred",
+              cause
+            })
           )
         )
-      },
-      stream({ span, ...options }) {
-        return makeRequest(options).pipe(
-          Effect.tap((request) => annotateRequest(span, request)),
-          Effect.map(client.stream),
-          Stream.unwrap,
-          Stream.tap((response) => {
-            annotateStreamResponse(span, response)
-            return Effect.void
-          }),
-          Stream.map((response) => response.asAiResponse),
-          Stream.catchAll((cause) =>
-            Effect.fail(
-              new AiError({
-                module: "AnthropicCompletions",
-                method: "stream",
-                description: "An error occurred",
-                cause
-              })
-            )
+      )
+    },
+    stream({ span, ...options }) {
+      return makeRequest(options).pipe(
+        Effect.tap((request) => annotateRequest(span, request)),
+        Effect.map(client.stream),
+        Stream.unwrap,
+        Stream.tap((response) => {
+          annotateStreamResponse(span, response)
+          return Effect.void
+        }),
+        Stream.map((response) => response.asAiResponse),
+        Stream.catchAll((cause) =>
+          Effect.fail(
+            new AiError({
+              module: "AnthropicCompletions",
+              method: "stream",
+              description: "An error occurred",
+              cause
+            })
           )
         )
-      }
-    })
+      )
+    }
   })
+})
 
 /**
  * @since 1.0.0
@@ -126,7 +198,12 @@ const make = (options: { readonly model: (string & {}) | Model }) =>
  */
 export const layerCompletions = (options: {
   readonly model: (string & {}) | Model
-}): Layer.Layer<Completions.Completions, never, AnthropicClient> => Layer.effect(Completions.Completions, make(options))
+  readonly config?: Omit<Config.Service, "model">
+}): Layer.Layer<Completions.Completions, never, AnthropicClient> =>
+  Layer.effect(
+    Completions.Completions,
+    make({ model: options.model, config: options.config })
+  )
 
 /**
  * @since 1.0.0
@@ -134,11 +211,41 @@ export const layerCompletions = (options: {
  */
 export const layer = (options: {
   readonly model: (string & {}) | Model
-}): Layer.Layer<
-  Completions.Completions | Tokenizer.Tokenizer,
-  never,
-  AnthropicClient
-> => Layer.merge(layerCompletions(options), AnthropicTokenizer.layer)
+  readonly config?: Omit<Config.Service, "model">
+}): Layer.Layer<Completions.Completions | Tokenizer.Tokenizer, never, AnthropicClient> =>
+  Layer.merge(layerCompletions(options), AnthropicTokenizer.layer)
+
+/**
+ * @since 1.0.0
+ * @category configuration
+ */
+export const withConfigOverride: {
+  /**
+   * @since 1.0.0
+   * @category configuration
+   */
+  (config: Config.Service): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * @since 1.0.0
+   * @category configuration
+   */
+  <A, E, R>(self: Effect.Effect<A, E, R>, config: Config.Service): Effect.Effect<A, E, R>
+} = dual<
+  /**
+   * @since 1.0.0
+   * @category configuration
+   */
+  (config: Config.Service) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  /**
+   * @since 1.0.0
+   * @category configuration
+   */
+  <A, E, R>(self: Effect.Effect<A, E, R>, config: Config.Service) => Effect.Effect<A, E, R>
+>(2, (self, overrides) =>
+  Effect.flatMap(
+    Config.getOrUndefined,
+    (config) => Effect.provideService(self, Config, { ...config, ...overrides })
+  ))
 
 const makeMessages = (
   aiInput: AiInput.AiInput

package/src/AnthropicConfig.ts

@@ -5,8 +5,6 @@ import type { HttpClient } from "@effect/platform/HttpClient"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
-import type { Simplify } from "effect/Types"
-import type * as Generated from "./Generated.js"
 
 /**
  * @since 1.0.0
@@ -34,16 +32,7 @@ export declare namespace AnthropicConfig {
    * @since 1.0.0
    * @category models
    */
-  export interface Service extends
-    Simplify<
-      Partial<
-        Omit<
-          typeof Generated.CreateMessageParams.Encoded,
-          "messages" | "tools" | "tool_choice" | "stream"
-        >
-      >
-    >
-  {
+  export interface Service {
     readonly transformClient?: (client: HttpClient) => HttpClient
   }
 }

package/src/AnthropicTokenizer.ts

@@ -10,7 +10,11 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 
-const make = Tokenizer.make({
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = Tokenizer.make({
   tokenize(content) {
     return Effect.try({
       try: () => {

package/src/Generated.ts

@@ -14,17 +14,16 @@ export class MessagesPostParams extends S.Struct({
 }) {}
 
 export class ModelEnum extends S.Literal(
-  "claude-3-5-haiku-latest",
-  "claude-3-5-haiku-20241022",
+  "claude-3-7-sonnet-latest",
+  "claude-3-7-sonnet-20250219",
   "claude-3-5-sonnet-latest",
   "claude-3-5-sonnet-20241022",
   "claude-3-5-sonnet-20240620",
+  "claude-3-5-haiku-latest",
+  "claude-3-5-haiku-20241022",
+  "claude-3-5-haiku-20240307",
   "claude-3-opus-latest",
-  "claude-3-opus-20240229",
-  "claude-3-sonnet-20240229",
-  "claude-3-haiku-20240307",
-  "claude-2.1",
-  "claude-2.0"
+  "claude-3-opus-20240229"
 ) {}
 
 export class Model extends S.Union(S.String, ModelEnum) {}