@effect/ai-openai 0.29.1 → 0.30.0

package/src/OpenAiTelemetry.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import * as AiTelemetry from "@effect/ai/AiTelemetry"
+import * as Telemetry from "@effect/ai/Telemetry"
 import { dual } from "effect/Function"
 import * as Predicate from "effect/Predicate"
 import * as String from "effect/String"
@@ -18,9 +18,9 @@ import type { Simplify } from "effect/Types"
  * @category Models
  */
 export type OpenAiTelemetryAttributes = Simplify<
-  & AiTelemetry.GenAITelemetryAttributes
-  & AiTelemetry.AttributesWithPrefix<RequestAttributes, "gen_ai.openai.request">
-  & AiTelemetry.AttributesWithPrefix<ResponseAttributes, "gen_ai.openai.request">
+  & Telemetry.GenAITelemetryAttributes
+  & Telemetry.AttributesWithPrefix<RequestAttributes, "gen_ai.openai.request">
+  & Telemetry.AttributesWithPrefix<ResponseAttributes, "gen_ai.openai.request">
 >
 
 /**
@@ -30,7 +30,7 @@ export type OpenAiTelemetryAttributes = Simplify<
  * @since 1.0.0
  * @category Models
  */
-export type AllAttributes = AiTelemetry.AllAttributes & RequestAttributes & ResponseAttributes
+export type AllAttributes = Telemetry.AllAttributes & RequestAttributes & ResponseAttributes
 
 /**
  * Telemetry attributes which are part of the GenAI specification and are
@@ -97,17 +97,17 @@ export type WellKnownServiceTier = "auto" | "default"
  * @since 1.0.0
  * @since Models
  */
-export type OpenAiTelemetryAttributeOptions = AiTelemetry.GenAITelemetryAttributeOptions & {
+export type OpenAiTelemetryAttributeOptions = Telemetry.GenAITelemetryAttributeOptions & {
   openai?: {
     request?: RequestAttributes | undefined
     response?: ResponseAttributes | undefined
   } | undefined
 }
 
-const addOpenAiRequestAttributes = AiTelemetry.addSpanAttributes("gen_ai.openai.request", String.camelToSnake)<
+const addOpenAiRequestAttributes = Telemetry.addSpanAttributes("gen_ai.openai.request", String.camelToSnake)<
   RequestAttributes
 >
-const addOpenAiResponseAttributes = AiTelemetry.addSpanAttributes("gen_ai.openai.response", String.camelToSnake)<
+const addOpenAiResponseAttributes = Telemetry.addSpanAttributes("gen_ai.openai.response", String.camelToSnake)<
   ResponseAttributes
 >
 
@@ -142,7 +142,7 @@ export const addGenAIAnnotations = dual<
    */
   (span: Span, options: OpenAiTelemetryAttributeOptions) => void
 >(2, (span, options) => {
-  AiTelemetry.addGenAIAnnotations(span, options)
+  Telemetry.addGenAIAnnotations(span, options)
   if (Predicate.isNotNullable(options.openai)) {
     if (Predicate.isNotNullable(options.openai.request)) {
       addOpenAiRequestAttributes(span, options.openai.request)

package/src/OpenAiTokenizer.ts

@@ -1,14 +1,11 @@
 /**
  * @since 1.0.0
  */
-import { AiError } from "@effect/ai/AiError"
-import type * as AiInput from "@effect/ai/AiInput"
+import * as AiError from "@effect/ai/AiError"
+import type * as Prompt from "@effect/ai/Prompt"
 import * 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 * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
 import * as GptTokenizer from "gpt-tokenizer"
 
 /**
@@ -17,43 +14,42 @@ import * as GptTokenizer from "gpt-tokenizer"
  */
 export const make = (options: { readonly model: string }) =>
   Tokenizer.make({
-    tokenize(input) {
+    tokenize(prompt) {
       return Effect.try({
-        try: () =>
-          GptTokenizer.encodeChat(
-            Arr.flatMap(input.messages, (message) =>
-              Arr.filterMap(
-                message.parts as Array<
-                  | AiInput.AssistantMessagePart
-                  | AiInput.ToolMessagePart
-                  | AiInput.UserMessagePart
-                >,
-                (part) => {
-                  if (
-                    part._tag === "FilePart" ||
-                    part._tag === "FileUrlPart" ||
-                    part._tag === "ImagePart" ||
-                    part._tag === "ImageUrlPart" ||
-                    part._tag === "ReasoningPart" ||
-                    part._tag === "RedactedReasoningPart"
-                  ) return Option.none()
-                  return Option.some(
-                    {
-                      role: message._tag === "UserMessage" ? "user" : "assistant",
-                      name: message._tag === "UserMessage" && Predicate.isNotUndefined(message.userName)
-                        ? message.userName
-                        : undefined,
-                      content: part._tag === "TextPart"
-                        ? part.text
-                        : JSON.stringify(part._tag === "ToolCallPart" ? part.params : part.result)
-                    } as const
-                  )
+        try: () => {
+          const content: Array<{
+            readonly role: "assistant" | "system" | "user"
+            readonly content: string
+          }> = []
+
+          for (const message of prompt.content) {
+            if (message.role === "system") {
+              content.push({ role: getRole(message), content: message.content })
+              continue
+            }
+
+            for (const part of message.content) {
+              switch (part.type) {
+                case "reasoning":
+                case "text": {
+                  content.push({ role: getRole(message), content: part.text })
+                  break
+                }
+                case "tool-call": {
+                  content.push({ role: getRole(message), content: JSON.stringify(part.params) })
+                  break
                 }
-              )),
-            options.model as any
-          ),
+                case "tool-result": {
+                  content.push({ role: getRole(message), content: JSON.stringify(part.result) })
+                  break
+                }
+              }
+            }
+          }
+          return GptTokenizer.encodeChat(content, options.model as any)
+        },
         catch: (cause) =>
-          new AiError({
+          new AiError.UnknownError({
             module: "OpenAiTokenizer",
             method: "tokenize",
             description: "Could not tokenize",
@@ -69,3 +65,6 @@ export const make = (options: { readonly model: string }) =>
  */
 export const layer = (options: { readonly model: string }): Layer.Layer<Tokenizer.Tokenizer> =>
   Layer.succeed(Tokenizer.Tokenizer, make(options))
+
+const getRole = (message: Prompt.Message): "assistant" | "system" | "user" =>
+  message.role === "tool" ? "assistant" : message.role

package/src/OpenAiTool.ts

@@ -0,0 +1,110 @@
+/**
+ * @since 1.0.0
+ */
+import * as Tool from "@effect/ai/Tool"
+import * as Schema from "effect/Schema"
+import * as Struct from "effect/Struct"
+import * as Generated from "./Generated.js"
+
+/**
+ * @since 1.0.0
+ * @category Tools
+ */
+export const CodeInterpreter = Tool.providerDefined({
+  id: "openai.code_interpreter",
+  toolkitName: "OpenAiCodeInterpreter",
+  providerName: "code_interpreter",
+  args: {
+    /**
+     * The configuration for the code interpreter container.
+     *
+     * Can be either a string which specifies the ID of a container created via
+     * the `/v1/containers` endpoint, or an object which specifies an optional
+     * list of files to make available to the container.
+     */
+    container: Schema.Union(
+      Schema.String,
+      Schema.Struct({
+        type: Schema.Literal("auto"),
+        /**
+         * An optional list of uploaded files to make available to your code.
+         */
+        file_ids: Schema.optional(Schema.Array(Schema.String))
+      })
+    )
+  },
+  parameters: {
+    code: Schema.NullOr(Schema.String),
+    container_id: Schema.String
+  },
+  success: Schema.NullOr(Schema.Array(Schema.Union(
+    Generated.CodeInterpreterOutputLogs,
+    Generated.CodeInterpreterOutputImage
+  )))
+})
+
+/**
+ * @since 1.0.0
+ * @category Tools
+ */
+export const FileSearch = Tool.providerDefined({
+  id: "openai.file_search",
+  toolkitName: "OpenAiFileSearch",
+  providerName: "file_search",
+  args: Struct.omit(Generated.FileSearchTool.fields, "type"),
+  success: Generated.FileSearchToolCall.pipe(Schema.omit("id", "type"))
+})
+
+/**
+ * @since 1.0.0
+ * @category Tools
+ */
+export const WebSearch = Tool.providerDefined({
+  id: "openai.web_search",
+  toolkitName: "OpenAiWebSearch",
+  providerName: "web_search",
+  args: Struct.omit(Generated.WebSearchTool.fields, "type"),
+  parameters: {
+    action: Schema.Union(
+      Generated.WebSearchActionSearch,
+      Generated.WebSearchActionOpenPage,
+      Generated.WebSearchActionFind
+    )
+  },
+  success: Schema.Struct({
+    status: Generated.WebSearchToolCallStatus
+  })
+})
+
+/**
+ * @since 1.0.0
+ * @category Tools
+ */
+export const WebSearchPreview = Tool.providerDefined({
+  id: "openai.web_search_preview",
+  toolkitName: "OpenAiWebSearchPreview",
+  providerName: "web_search_preview",
+  args: Struct.omit(Generated.WebSearchPreviewTool.fields, "type"),
+  parameters: {
+    action: Schema.Union(
+      Generated.WebSearchActionSearch,
+      Generated.WebSearchActionOpenPage,
+      Generated.WebSearchActionFind
+    )
+  },
+  success: Schema.Struct({
+    status: Generated.WebSearchToolCallStatus
+  })
+})
+
+type ProviderToolNames = "code_interpreter" | "file_search" | "web_search" | "web_search_preview"
+
+const ProviderToolNamesMap: Map<ProviderToolNames | (string & {}), string> = new Map([
+  ["code_interpreter", "OpenAiCodeInterpreter"],
+  ["file_search", "OpenAiFileSearch"],
+  ["web_search", "OpenAiWebSearch"],
+  ["web_search_preview", "OpenAiWebSearchPreview"]
+])
+
+/** @internal */
+export const getProviderDefinedToolName = (name: string): string | undefined => ProviderToolNamesMap.get(name)

package/src/index.ts

@@ -32,3 +32,8 @@ export * as OpenAiTelemetry from "./OpenAiTelemetry.js"
  * @since 1.0.0
  */
 export * as OpenAiTokenizer from "./OpenAiTokenizer.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as OpenAiTool from "./OpenAiTool.js"

package/src/internal/utilities.ts

@@ -1,10 +1,13 @@
-import type * as AiResponse from "@effect/ai/AiResponse"
+import type * as Response from "@effect/ai/Response"
 import * as Predicate from "effect/Predicate"
 
+/** @internal */
+export const ProviderOptionsKey = "@effect/ai-openai/OpenAiLanguageModel/ProviderOptions"
+
 /** @internal */
 export const ProviderMetadataKey = "@effect/ai-openai/OpenAiLanguageModel/ProviderMetadata"
 
-const finishReasonMap: Record<string, AiResponse.FinishReason> = {
+const finishReasonMap: Record<string, Response.FinishReason> = {
   content_filter: "content-filter",
   function_call: "tool-calls",
   length: "length",
@@ -13,7 +16,16 @@ const finishReasonMap: Record<string, AiResponse.FinishReason> = {
 }
 
 /** @internal */
-export const resolveFinishReason = (finishReason: string): AiResponse.FinishReason => {
+export const resolveFinishReason = (
+  finishReason: string | undefined,
+  hasToolCalls: boolean
+): Response.FinishReason => {
+  if (Predicate.isNullable(finishReason)) {
+    return hasToolCalls ? "tool-calls" : "stop"
+  }
   const reason = finishReasonMap[finishReason]
-  return Predicate.isUndefined(reason) ? "unknown" : reason
+  if (Predicate.isNullable(reason)) {
+    return hasToolCalls ? "tool-calls" : "unknown"
+  }
+  return reason
 }