@effect/ai-openai 0.1.0

package/src/OpenAiClient.ts

@@ -0,0 +1,291 @@
+/**
+ * @since 1.0.0
+ */
+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 Redacted from "effect/Redacted"
+import * as Stream from "effect/Stream"
+import * as Generated from "./Generated.js"
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export class OpenAiClient extends Context.Tag("@effect/ai-openai/OpenAiClient")<
+  OpenAiClient,
+  OpenAiClient.Service
+>() {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace OpenAiClient {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Service {
+    readonly client: Generated.Client
+    readonly streamRequest: <A>(
+      request: HttpClientRequest.HttpClientRequest
+    ) => Stream.Stream<A, HttpClientError.HttpClientError>
+    readonly stream: (
+      request: StreamCompletionRequest
+    ) => Stream.Stream<StreamChunk, HttpClientError.HttpClientError>
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = (options: {
+  readonly apiKey: Redacted.Redacted
+  readonly organizationId?: Redacted.Redacted | undefined
+  readonly projectId?: Redacted.Redacted | undefined
+}): Effect.Effect<OpenAiClient.Service, never, HttpClient.HttpClient> =>
+  Effect.gen(function*() {
+    const httpClient = (yield* HttpClient.HttpClient).pipe(
+      HttpClient.mapRequest((request) =>
+        request.pipe(
+          HttpClientRequest.prependUrl("https://api.openai.com/v1"),
+          HttpClientRequest.bearerToken(options.apiKey),
+          options.organizationId !== undefined
+            ? HttpClientRequest.setHeader("OpenAI-Organization", Redacted.value(options.organizationId))
+            : identity,
+          options.projectId !== undefined
+            ? HttpClientRequest.setHeader("OpenAI-Project", Redacted.value(options.projectId))
+            : identity,
+          HttpClientRequest.acceptJson
+        )
+      )
+    )
+    const httpClientOk = HttpClient.filterStatusOk(httpClient)
+    const client = Generated.make(httpClient)
+    const streamRequest = <A = unknown>(request: HttpClientRequest.HttpClientRequest) =>
+      httpClientOk.execute(request).pipe(
+        Effect.map((r) => r.stream),
+        Stream.unwrapScoped,
+        Stream.decodeText(),
+        Stream.pipeThroughChannel(Sse.makeChannel()),
+        Stream.takeWhile((event) => event.data !== "[DONE]"),
+        Stream.map((event) => JSON.parse(event.data) as A)
+      )
+    const stream = (request: StreamCompletionRequest) =>
+      streamRequest<RawCompletionChunk>(HttpClientRequest.post("/chat/completions", {
+        body: HttpBody.unsafeJson({
+          ...request,
+          stream: true
+        })
+      })).pipe(
+        Stream.mapAccum(new Map<number, ContentPart | Array<ToolCallPart>>(), (acc, chunk) => {
+          const parts: Array<StreamChunkPart> = []
+          for (let i = 0; i < chunk.choices.length; i++) {
+            const choice = chunk.choices[i]
+            if ("content" in choice.delta && typeof choice.delta.content === "string") {
+              let part = acc.get(choice.index) as ContentPart | undefined
+              part = {
+                _tag: "Content",
+                content: choice.delta.content
+              }
+              acc.set(choice.index, part)
+              parts.push(part)
+            } else if ("tool_calls" in choice.delta && Array.isArray(choice.delta.tool_calls)) {
+              const parts = (acc.get(choice.index) ?? []) as Array<ToolCallPart>
+              for (const toolCall of choice.delta.tool_calls) {
+                const part = parts[toolCall.index]
+                const toolPart = part?._tag === "ToolCall" ?
+                  {
+                    ...part,
+                    arguments: part.arguments + toolCall.function.arguments
+                  } :
+                  {
+                    _tag: "ToolCall",
+                    ...toolCall,
+                    ...toolCall.function,
+                    role: choice.delta.role!
+                  } as any
+                parts[toolCall.index] = toolPart
+              }
+              acc.set(choice.index, parts)
+            } else if (choice.finish_reason === "tool_calls") {
+              const toolParts = acc.get(choice.index) as Array<ToolCallPart>
+              for (const part of toolParts) {
+                try {
+                  const args = JSON.parse(part.arguments as string)
+                  parts.push({
+                    _tag: "ToolCall",
+                    id: part.id,
+                    name: part.name,
+                    arguments: args
+                  })
+                  // eslint-disable-next-line no-empty
+                } catch {}
+              }
+            }
+          }
+          return [acc, parts.length === 0 ? Option.none() : Option.some(new StreamChunk({ parts }))]
+        }),
+        Stream.filterMap(identity)
+      )
+    return OpenAiClient.of({ client, streamRequest, stream })
+  })
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = (options: {
+  readonly apiKey: Redacted.Redacted
+  readonly organizationId?: Redacted.Redacted | undefined
+  readonly projectId?: Redacted.Redacted | undefined
+}): Layer.Layer<OpenAiClient, never, HttpClient.HttpClient> => Layer.effect(OpenAiClient, make(options))
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerConfig = (
+  options: Config.Config.Wrap<{
+    readonly apiKey: Redacted.Redacted
+    readonly organizationId?: Redacted.Redacted | undefined
+    readonly projectId?: Redacted.Redacted | undefined
+  }>
+): Layer.Layer<OpenAiClient, ConfigError, HttpClient.HttpClient> =>
+  Config.unwrap(options).pipe(
+    Effect.flatMap(make),
+    Layer.effect(OpenAiClient)
+  )
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type StreamCompletionRequest = Omit<typeof Generated.CreateChatCompletionRequest.Encoded, "stream">
+
+interface RawCompletionChunk {
+  readonly id: string
+  readonly object: "chat.completion.chunk"
+  readonly created: number
+  readonly model: string
+  readonly choices: Array<
+    {
+      readonly index: number
+      readonly finish_reason: null
+      readonly delta: RawDelta
+    } | {
+      readonly index: number
+      readonly finish_reason: string
+      readonly delta: {}
+    }
+  >
+  readonly system_fingerprint: string
+}
+
+type RawDelta = {
+  readonly index?: number
+  readonly role?: string
+  readonly content: string
+} | {
+  readonly index?: number
+  readonly role?: string
+  readonly content?: null
+  readonly tool_calls: Array<RawToolCall>
+}
+
+type RawToolCall = {
+  readonly index: number
+  readonly id: string
+  readonly type: "function"
+  readonly function: {
+    readonly name: string
+    readonly arguments: string
+  }
+} | {
+  readonly index: number
+  readonly function: {
+    readonly arguments: string
+  }
+}
+
+/**
+ * @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]
+    return part._tag === "Content" ?
+      AiResponse.AiResponse.fromText({
+        role: AiRole.model,
+        content: part.content
+      }) :
+      new AiResponse.AiResponse({
+        role: AiRole.model,
+        parts: Chunk.of(AiResponse.ToolCallPart.fromUnknown({
+          id: part.id,
+          name: part.name,
+          params: part.arguments
+        }))
+      })
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type StreamChunkPart = ContentPart | ToolCallPart
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ContentPart {
+  readonly _tag: "Content"
+  readonly name?: string
+  readonly content: string
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ToolCallPart {
+  readonly _tag: "ToolCall"
+  readonly id: string
+  readonly name: string
+  readonly arguments: unknown
+}

package/src/OpenAiCompletions.ts

@@ -0,0 +1,260 @@
+/**
+ * @since 1.0.0
+ */
+import { AiError } from "@effect/ai/AiError"
+import type * as AiInput from "@effect/ai/AiInput"
+import * as AiResponse from "@effect/ai/AiResponse"
+import * as AiRole from "@effect/ai/AiRole"
+import * as Completions from "@effect/ai/Completions"
+import type * as Tokenizer from "@effect/ai/Tokenizer"
+import * as Arr from "effect/Array"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
+import type * as Generated from "./Generated.js"
+import { OpenAiClient } from "./OpenAiClient.js"
+import { OpenAiConfig } from "./OpenAiConfig.js"
+import * as OpenAiTokenizer from "./OpenAiTokenizer.js"
+
+const make = (options: {
+  readonly model: string
+}) =>
+  Effect.gen(function*() {
+    const client = yield* OpenAiClient
+    const config = yield* OpenAiConfig.getOrUndefined
+
+    const makeRequest = ({ input, required, system, tools }: Completions.CompletionOptions) =>
+      Effect.map(
+        Effect.context<never>(),
+        (context): typeof Generated.CreateChatCompletionRequest.Encoded => ({
+          model: options.model,
+          ...config,
+          ...context.unsafeMap.get(OpenAiConfig.key),
+          messages: makeMessages(input, system),
+          tools: tools.length > 0 ?
+            tools.map((tool) => ({
+              type: "function",
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters as any,
+                strict: true
+              }
+            })) :
+            undefined,
+          tool_choice: tools.length > 0 ?
+            typeof required === "boolean" ? (required ? "required" : "auto") : {
+              type: "function",
+              function: { name: required }
+            } :
+            undefined
+        })
+      )
+
+    return yield* Completions.make({
+      create(options) {
+        return makeRequest(options).pipe(
+          Effect.flatMap(client.client.createChatCompletion),
+          Effect.catchAll((cause) =>
+            Effect.fail(
+              new AiError({
+                module: "OpenAiCompletions",
+                method: "create",
+                description: "An error occurred",
+                cause
+              })
+            )
+          ),
+          Effect.flatMap((response) => makeResponse(response, "create"))
+        )
+      },
+      stream(options) {
+        return makeRequest(options).pipe(
+          Effect.map(client.stream),
+          Stream.unwrap,
+          Stream.catchAll((cause) =>
+            Effect.fail(
+              new AiError({
+                module: "OpenAiCompletions",
+                method: "stream",
+                description: "An error occurred",
+                cause
+              })
+            )
+          ),
+          Stream.map((response) => response.asAiResponse)
+        )
+      }
+    })
+  })
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerCompletions = (options: {
+  readonly model: string
+}): Layer.Layer<Completions.Completions, never, OpenAiClient> => Layer.effect(Completions.Completions, make(options))
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = (options: {
+  readonly model: string
+}): Layer.Layer<Completions.Completions | Tokenizer.Tokenizer, never, OpenAiClient> =>
+  Layer.merge(layerCompletions(options), OpenAiTokenizer.layer(options))
+
+const makeMessages = (
+  input: AiInput.AiInput,
+  system: Option.Option<string>
+): Arr.NonEmptyReadonlyArray<typeof Generated.ChatCompletionRequestMessage.Encoded> => {
+  const messages: Array<typeof Generated.ChatCompletionRequestMessage.Encoded> = system._tag === "Some" ?
+    [makeSystemMessage(system.value)] :
+    []
+  for (const message of input) {
+    // eslint-disable-next-line no-restricted-syntax
+    messages.push(...convertMessage(message))
+  }
+  return messages as any
+}
+
+const formatRole = (role: AiRole.AiRole) => {
+  switch (role._tag) {
+    case "UserWithName":
+      return {
+        role: "user",
+        name: safeName(role.name)
+      } as const
+    case "User":
+      return {
+        role: "user"
+      } as const
+    case "Model":
+      return {
+        role: "assistant"
+      } as const
+  }
+}
+
+const convertMessage = (
+  message: AiInput.Message
+): Array<typeof Generated.ChatCompletionRequestMessage.Encoded> => {
+  const messages: Array<typeof Generated.ChatCompletionRequestMessage.Encoded> = []
+  let parts: Array<typeof Generated.ChatCompletionRequestUserMessageContentPart.Encoded> = []
+  let toolCalls: Array<typeof Generated.ChatCompletionMessageToolCall.Encoded> = []
+  function flushContent() {
+    if (parts.length === 0) return
+    messages.push({
+      ...formatRole(message.role),
+      content: parts as any
+    })
+    parts = []
+  }
+  function flushToolCalls() {
+    if (toolCalls.length === 0) return
+    messages.push({
+      role: "assistant",
+      content: null,
+      tool_calls: toolCalls
+    })
+    toolCalls = []
+  }
+  for (const part of message.parts) {
+    if (part._tag === "ToolCall") {
+      flushContent()
+      toolCalls.push({
+        id: part.id,
+        type: "function",
+        function: {
+          name: part.name,
+          arguments: JSON.stringify(part.params)
+        }
+      })
+    } else if (part._tag === "ToolCallResolved") {
+      flushContent()
+      flushToolCalls()
+      messages.push({
+        role: "tool",
+        tool_call_id: part.toolCallId,
+        content: JSON.stringify(part.value)
+      })
+    } else {
+      flushToolCalls()
+      parts.push(makeContentPart(part))
+    }
+  }
+  flushContent()
+  flushToolCalls()
+  return messages
+}
+
+const makeContentPart = (
+  part: AiInput.TextPart | AiInput.ImagePart | AiInput.ImageUrlPart
+): typeof Generated.ChatCompletionRequestUserMessageContentPart.Encoded => {
+  switch (part._tag) {
+    case "Image":
+      return {
+        type: "image_url",
+        image_url: {
+          url: part.asDataUri,
+          detail: part.quality
+        }
+      }
+    case "ImageUrl":
+      return {
+        type: "image_url",
+        image_url: {
+          url: part.url,
+          detail: part.quality
+        }
+      }
+    case "Text":
+      return {
+        type: "text",
+        text: part.content
+      }
+  }
+}
+
+const makeResponse = (
+  response: Generated.CreateChatCompletionResponse,
+  method: string
+): Effect.Effect<AiResponse.AiResponse, AiError> =>
+  Arr.head(response.choices).pipe(
+    Effect.mapError(() =>
+      new AiError({
+        module: "OpenAiCompletions",
+        method,
+        description: "Could not get response"
+      })
+    ),
+    Effect.flatMap((choice) => {
+      const response = typeof choice.message.content === "string" ?
+        AiResponse.AiResponse.fromText({
+          role: AiRole.model,
+          content: choice.message.content!
+        }) :
+        AiResponse.AiResponse.empty
+
+      if (choice.message.tool_calls && choice.message.tool_calls.length > 0) {
+        return response.withToolCallsJson(choice.message.tool_calls.map((toolCall) => ({
+          id: toolCall.id,
+          name: toolCall.function.name,
+          params: toolCall.function.arguments
+        })))
+      }
+
+      return Effect.succeed(response)
+    })
+  )
+
+const makeSystemMessage = (content: string): typeof Generated.ChatCompletionRequestSystemMessage.Encoded => {
+  return {
+    role: "system",
+    content
+  }
+}
+
+const safeName = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/, "_")

package/src/OpenAiConfig.ts

@@ -0,0 +1,31 @@
+/**
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import type { Simplify } from "effect/Types"
+import type * as Generated from "./Generated.js"
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export class OpenAiConfig extends Context.Tag("@effect/ai-openai/OpenAiConfig")<
+  OpenAiConfig,
+  Simplify<
+    Partial<
+      Omit<
+        typeof Generated.CreateChatCompletionRequest.Encoded,
+        "messages" | "tools" | "tool_choice" | "stream" | "stream_options" | "functions"
+      >
+    >
+  >
+>() {
+  /**
+   * @since 1.0.0
+   */
+  static readonly getOrUndefined: Effect.Effect<typeof OpenAiConfig.Service | undefined> = Effect.map(
+    Effect.context<never>(),
+    (context) => context.unsafeMap.get(OpenAiConfig.key)
+  )
+}

package/src/OpenAiTokenizer.ts

@@ -0,0 +1,59 @@
+/**
+ * @since 1.0.0
+ */
+import { AiError } from "@effect/ai/AiError"
+import * as Tokenizer from "@effect/ai/Tokenizer"
+import * as Arr from "effect/Array"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as GptTokenizer from "gpt-tokenizer"
+import { OpenAiConfig } from "./OpenAiConfig.js"
+
+const make = (options: { readonly model: string }) =>
+  Tokenizer.make({
+    tokenize(content) {
+      return Effect.tryMap(OpenAiConfig.getOrUndefined, {
+        try: (localConfig) =>
+          GptTokenizer.encodeChat(
+            content.pipe(
+              Chunk.toReadonlyArray,
+              Arr.flatMap((message) =>
+                message.parts.pipe(
+                  Arr.filterMap((part) => {
+                    if (part._tag === "Image" || part._tag === "ImageUrl") {
+                      return Option.none()
+                    }
+                    return Option.some(
+                      {
+                        role: message.role.kind === "user" ? "user" : "assistant",
+                        name: message.role._tag === "UserWithName" ? message.role.name : undefined,
+                        content: part._tag === "Text"
+                          ? part.content
+                          : JSON.stringify(part._tag === "ToolCall" ? part.params : part.value)
+                      } as const
+                    )
+                  })
+                )
+              )
+            ),
+            localConfig?.model ?? options.model as any
+          ),
+        catch: (cause) =>
+          new AiError({
+            module: "OpenAiCompletions",
+            method: "tokenize",
+            description: "Could not tokenize",
+            cause
+          })
+      })
+    }
+  })
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer = (options: { readonly model: string }): Layer.Layer<Tokenizer.Tokenizer> =>
+  Layer.succeed(Tokenizer.Tokenizer, make(options))

package/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * @since 1.0.0
+ */
+export * as Generated from "./Generated.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OpenAiClient from "./OpenAiClient.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OpenAiCompletions from "./OpenAiCompletions.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OpenAiConfig from "./OpenAiConfig.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OpenAiTokenizer from "./OpenAiTokenizer.js"