@effect/ai-openai 4.0.0-beta.3 → 4.0.0-beta.31

package/src/OpenAiClient.ts

@@ -281,7 +281,7 @@ export const layerConfig = (options?: {
   /**
    * The config value to load for the API key.
    */
-  readonly apiKey?: Config.Config<Redacted.Redacted<string>> | undefined
+  readonly apiKey?: Config.Config<Redacted.Redacted<string> | undefined> | undefined
 
   /**
    * The config value to load for the API URL.
@@ -291,12 +291,12 @@ export const layerConfig = (options?: {
   /**
    * The config value to load for the organization ID.
    */
-  readonly organizationId?: Config.Config<Redacted.Redacted<string>> | undefined
+  readonly organizationId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined
 
   /**
    * The config value to load for the project ID.
    */
-  readonly projectId?: Config.Config<Redacted.Redacted<string>> | undefined
+  readonly projectId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined
 
   /**
    * Optional transformer for the HTTP client.

package/src/OpenAiError.ts

@@ -57,51 +57,43 @@ export type OpenAiRateLimitMetadata = OpenAiErrorMetadata & {
 }
 
 declare module "effect/unstable/ai/AiError" {
-  export interface RateLimitError {
-    readonly metadata: {
-      readonly openai?: OpenAiRateLimitMetadata | null
-    }
+  export interface RateLimitErrorMetadata {
+    readonly openai?: OpenAiRateLimitMetadata | null
   }
 
-  export interface QuotaExhaustedError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface QuotaExhaustedErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface AuthenticationError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface AuthenticationErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface ContentPolicyError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface ContentPolicyErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface InvalidRequestError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface InvalidRequestErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface InternalProviderError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface InternalProviderErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface InvalidOutputError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface InvalidOutputErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 
-  export interface UnknownError {
-    readonly metadata: {
-      readonly openai?: OpenAiErrorMetadata | null
-    }
+  export interface StructuredOutputErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
+  }
+
+  export interface UnsupportedSchemaErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
+  }
+
+  export interface UnknownErrorMetadata {
+    readonly openai?: OpenAiErrorMetadata | null
   }
 }

package/src/OpenAiLanguageModel.ts

@@ -8,7 +8,7 @@
  */
 import * as DateTime from "effect/DateTime"
 import * as Effect from "effect/Effect"
-import * as Base64 from "effect/encoding/Base64"
+import * as Encoding from "effect/Encoding"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Predicate from "effect/Predicate"
@@ -23,6 +23,7 @@ import * as AiError from "effect/unstable/ai/AiError"
 import * as IdGenerator from "effect/unstable/ai/IdGenerator"
 import * as LanguageModel from "effect/unstable/ai/LanguageModel"
 import * as AiModel from "effect/unstable/ai/Model"
+import { toCodecOpenAI } from "effect/unstable/ai/OpenAiStructuredOutput"
 import type * as Prompt from "effect/unstable/ai/Prompt"
 import type * as Response from "effect/unstable/ai/Response"
 import * as Tool from "effect/unstable/ai/Tool"
@@ -319,7 +320,7 @@ export const model = (
   model: (string & {}) | Model,
   config?: Omit<typeof Config.Service, "model">
 ): AiModel.Model<"openai", LanguageModel.LanguageModel, OpenAiClient> =>
-  AiModel.make("openai", layer({ model, config }))
+  AiModel.make("openai", model, layer({ model, config }))
 
 // TODO
 // /**
@@ -330,7 +331,7 @@ export const model = (
 //   model: (string & {}) | Model,
 //   config?: Omit<typeof Config.Service, "model">
 // ): AiModel.Model<"openai", LanguageModel.LanguageModel | Tokenizer.Tokenizer, OpenAiClient> =>
-//   AiModel.make("openai", layerWithTokenizer({ model, config }))
+//   AiModel.make("openai", model, layerWithTokenizer({ model, config }))
 
 /**
  * Creates an OpenAI language model service.
@@ -369,7 +370,7 @@ export const make = Effect.fnUntraced(function*({ model, config: providerConfig
         options,
         toolNameMapper
       })
-      const responseFormat = prepareResponseFormat({
+      const responseFormat = yield* prepareResponseFormat({
         config,
         options
       })
@@ -389,6 +390,7 @@ export const make = Effect.fnUntraced(function*({ model, config: providerConfig
   )
 
   return yield* LanguageModel.make({
+    codecTransformer: toCodecOpenAI,
     generateText: Effect.fnUntraced(
       function*(options) {
         const config = yield* makeConfig
@@ -592,7 +594,7 @@ const prepareMessages = Effect.fnUntraced(
                   }
 
                   if (part.data instanceof Uint8Array) {
-                    const base64 = Base64.encode(part.data)
+                    const base64 = Encoding.encodeBase64(part.data)
                     const imageUrl = `data:${mediaType};base64,${base64}`
                     content.push({ type: "input_image", image_url: imageUrl, detail })
                   }
@@ -606,7 +608,7 @@ const prepareMessages = Effect.fnUntraced(
                   }
 
                   if (part.data instanceof Uint8Array) {
-                    const base64 = Base64.encode(part.data)
+                    const base64 = Encoding.encodeBase64(part.data)
                     const fileName = part.fileName ?? `part-${index}.pdf`
                     const fileData = `data:application/pdf;base64,${base64}`
                     content.push({ type: "input_file", filename: fileName, file_data: fileData })
@@ -1036,10 +1038,11 @@ const makeResponse = Effect.fnUntraced(
 
         case "function_call": {
           hasToolCalls = true
+
           const toolName = part.name
-          const toolParams = part.arguments
-          const params = yield* Effect.try({
-            try: () => Tool.unsafeSecureJsonParse(toolParams),
+
+          const toolParams = yield* Effect.try({
+            try: () => Tool.unsafeSecureJsonParse(part.arguments),
             catch: (cause) =>
               AiError.make({
                 module: "OpenAiLanguageModel",
@@ -1051,6 +1054,9 @@ const makeResponse = Effect.fnUntraced(
                 })
               })
           })
+
+          const params = yield* transformToolCallParams(options.tools, part.name, toolParams)
+
           parts.push({
             type: "tool-call",
             id: part.call_id,
@@ -1730,11 +1736,14 @@ const makeStreamResponse = Effect.fnUntraced(
 
               case "function_call": {
                 delete activeToolCalls[event.output_index]
+
                 hasToolCalls = true
+
                 const toolName = event.item.name
-                const toolParams = event.item.arguments
-                const params = yield* Effect.try({
-                  try: () => Tool.unsafeSecureJsonParse(toolParams),
+                const toolArgs = event.item.arguments
+
+                const toolParams = yield* Effect.try({
+                  try: () => Tool.unsafeSecureJsonParse(toolArgs),
                   catch: (cause) =>
                     AiError.make({
                       module: "OpenAiLanguageModel",
@@ -1746,10 +1755,14 @@ const makeStreamResponse = Effect.fnUntraced(
                       })
                     })
                 })
+
+                const params = yield* transformToolCallParams(options.tools, toolName, toolParams)
+
                 parts.push({
                   type: "tool-params-end",
                   id: event.item.call_id
                 })
+
                 parts.push({
                   type: "tool-call",
                   id: event.item.call_id,
@@ -1757,6 +1770,7 @@ const makeStreamResponse = Effect.fnUntraced(
                   params,
                   metadata: { openai: { ...makeItemIdMetadata(event.item.id) } }
                 })
+
                 break
               }
 
@@ -2281,12 +2295,14 @@ const prepareTools = Effect.fnUntraced(function*<Tools extends ReadonlyArray<Too
   for (const tool of allowedTools) {
     if (Tool.isUserDefined(tool)) {
       const strict = Tool.getStrictMode(tool) ?? config.strictJsonSchema ?? true
+      const description = Tool.getDescription(tool)
+      const parameters = yield* tryJsonSchema(tool.parametersSchema, "prepareTools")
       tools.push({
         type: "function",
         name: tool.name,
-        description: Tool.getDescription(tool) ?? null,
-        parameters: Tool.getJsonSchema(tool) as { readonly [x: string]: Schema.Json },
-        strict
+        parameters,
+        strict,
+        ...(Predicate.isNotUndefined(description) ? { description } : undefined)
       })
     }
 
@@ -2480,23 +2496,45 @@ const makeItemIdMetadata = (itemId: string | undefined) => Predicate.isNotUndefi
 const makeEncryptedContentMetadata = (encryptedContent: string | null | undefined) =>
   Predicate.isNotNullish(encryptedContent) ? { encryptedContent } : undefined
 
-const prepareResponseFormat = ({ config, options }: {
+const unsupportedSchemaError = (error: unknown, method: string): AiError.AiError =>
+  AiError.make({
+    module: "OpenAiLanguageModel",
+    method,
+    reason: new AiError.UnsupportedSchemaError({
+      description: error instanceof Error ? error.message : String(error)
+    })
+  })
+
+const tryCodecTransform = <S extends Schema.Top>(schema: S, method: string) =>
+  Effect.try({
+    try: () => toCodecOpenAI(schema),
+    catch: (error) => unsupportedSchemaError(error, method)
+  })
+
+const tryJsonSchema = <S extends Schema.Top>(schema: S, method: string) =>
+  Effect.try({
+    try: () => Tool.getJsonSchemaFromSchema(schema, { transformer: toCodecOpenAI }),
+    catch: (error) => unsupportedSchemaError(error, method)
+  })
+
+const prepareResponseFormat = Effect.fnUntraced(function*({ config, options }: {
   readonly config: typeof Config.Service
   readonly options: LanguageModel.ProviderOptions
-}): typeof Generated.TextResponseFormatConfiguration.Encoded => {
+}): Effect.fn.Return<typeof Generated.TextResponseFormatConfiguration.Encoded, AiError.AiError> {
   if (options.responseFormat.type === "json") {
     const name = options.responseFormat.objectName
     const schema = options.responseFormat.schema
+    const jsonSchema = yield* tryJsonSchema(schema, "prepareResponseFormat")
     return {
       type: "json_schema",
       name,
       description: AST.resolveDescription(schema.ast) ?? "Response with a JSON object",
-      schema: Tool.getJsonSchemaFromSchema(schema) as any,
+      schema: jsonSchema,
       strict: config.strictJsonSchema ?? true
     }
   }
   return { type: "text" }
-}
+})
 
 interface ModelCapabilities {
   readonly isReasoningModel: boolean
@@ -2606,3 +2644,40 @@ const getUsage = (usage: Generated.ResponseUsage | null | undefined): Response.U
     }
   }
 }
+
+const transformToolCallParams = Effect.fnUntraced(function*<Tools extends ReadonlyArray<Tool.Any>>(
+  tools: Tools,
+  toolName: string,
+  toolParams: unknown
+): Effect.fn.Return<unknown, AiError.AiError> {
+  const tool = tools.find((tool) => tool.name === toolName)
+
+  if (Predicate.isUndefined(tool)) {
+    return yield* AiError.make({
+      module: "OpenAiLanguageModel",
+      method: "makeResponse",
+      reason: new AiError.ToolNotFoundError({
+        toolName,
+        availableTools: tools.map((tool) => tool.name)
+      })
+    })
+  }
+
+  const { codec } = yield* tryCodecTransform(tool.parametersSchema, "makeResponse")
+
+  const transform = Schema.decodeEffect(codec)
+
+  return yield* (
+    transform(toolParams) as Effect.Effect<unknown, Schema.SchemaError>
+  ).pipe(Effect.mapError((error) =>
+    AiError.make({
+      module: "OpenAiLanguageModel",
+      method: "makeResponse",
+      reason: new AiError.ToolParameterValidationError({
+        toolName,
+        toolParams,
+        description: error.issue.toString()
+      })
+    })
+  ))
+})