@effect/ai-openai 0.37.2 → 4.0.0-beta.1

package/src/internal/errors.ts

@@ -0,0 +1,347 @@
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as Number from "effect/Number"
+import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import * as Redactable from "effect/Redactable"
+import * as Schema from "effect/Schema"
+import * as AiError from "effect/unstable/ai/AiError"
+import type * as Response from "effect/unstable/ai/Response"
+import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
+import type { OpenAiErrorMetadata } from "../OpenAiError.ts"
+
+// =============================================================================
+// OpenAI Error Body Schema
+// =============================================================================
+
+/** @internal */
+export const OpenAiErrorBody = Schema.Struct({
+  error: Schema.Struct({
+    message: Schema.String,
+    type: Schema.optional(Schema.NullOr(Schema.String)),
+    param: Schema.optional(Schema.NullOr(Schema.String)),
+    code: Schema.optional(Schema.NullOr(Schema.String))
+  })
+})
+
+// =============================================================================
+// Error Mappers
+// =============================================================================
+
+/** @internal */
+export const mapSchemaError = dual<
+  (method: string) => (error: Schema.SchemaError) => AiError.AiError,
+  (error: Schema.SchemaError, method: string) => AiError.AiError
+>(2, (error, method) =>
+  AiError.make({
+    module: "OpenAiClient",
+    method,
+    reason: AiError.InvalidOutputError.fromSchemaError(error)
+  }))
+
+/** @internal */
+export const mapHttpClientError = dual<
+  (method: string) => (error: HttpClientError.HttpClientError) => Effect.Effect<never, AiError.AiError>,
+  (error: HttpClientError.HttpClientError, method: string) => Effect.Effect<never, AiError.AiError>
+>(2, (error, method) => {
+  const reason = error.reason
+  switch (reason._tag) {
+    case "TransportError": {
+      return Effect.fail(AiError.make({
+        module: "OpenAiClient",
+        method,
+        reason: new AiError.NetworkError({
+          reason: "TransportError",
+          description: reason.description,
+          request: buildHttpRequestDetails(reason.request)
+        })
+      }))
+    }
+    case "EncodeError": {
+      return Effect.fail(AiError.make({
+        module: "OpenAiClient",
+        method,
+        reason: new AiError.NetworkError({
+          reason: "EncodeError",
+          description: reason.description,
+          request: buildHttpRequestDetails(reason.request)
+        })
+      }))
+    }
+    case "InvalidUrlError": {
+      return Effect.fail(AiError.make({
+        module: "OpenAiClient",
+        method,
+        reason: new AiError.NetworkError({
+          reason: "InvalidUrlError",
+          description: reason.description,
+          request: buildHttpRequestDetails(reason.request)
+        })
+      }))
+    }
+    case "StatusCodeError": {
+      return mapStatusCodeError(reason, method)
+    }
+    case "DecodeError": {
+      return Effect.fail(AiError.make({
+        module: "OpenAiClient",
+        method,
+        reason: new AiError.InvalidOutputError({
+          description: reason.description ?? "Failed to decode response"
+        })
+      }))
+    }
+    case "EmptyBodyError": {
+      return Effect.fail(AiError.make({
+        module: "OpenAiClient",
+        method,
+        reason: new AiError.InvalidOutputError({
+          description: reason.description ?? "Response body was empty"
+        })
+      }))
+    }
+  }
+})
+
+/** @internal */
+const mapStatusCodeError = Effect.fnUntraced(function*(
+  error: HttpClientError.StatusCodeError,
+  method: string
+) {
+  const { request, response, description } = error
+  const status = response.status
+  const headers = response.headers as Record<string, string>
+  const requestId = headers["x-request-id"]
+
+  // Try to get the actual response body. The description from filterStatusOk
+  // is often just "non 2xx status code", so try reading from response.text
+  let body: string | undefined = description
+  if (!description || !description.startsWith("{")) {
+    const responseBody = yield* Effect.option(response.text)
+    if (Option.isSome(responseBody) && responseBody.value) {
+      body = responseBody.value
+    }
+  }
+
+  // Try to parse the body as JSON to extract error details
+  let json: unknown = undefined
+  // @effect-diagnostics effect/tryCatchInEffectGen:off
+  try {
+    json = Predicate.isNotUndefined(body) ? JSON.parse(body) : undefined
+  } catch {
+    json = undefined
+  }
+  const decoded = Schema.decodeUnknownOption(OpenAiErrorBody)(json)
+
+  const reason = mapStatusCodeToReason({
+    status,
+    headers,
+    message: Option.isSome(decoded) ? decoded.value.error.message : undefined,
+    http: buildHttpContext({ request, response, body }),
+    metadata: {
+      errorCode: Option.isSome(decoded) ? decoded.value.error.code ?? null : null,
+      errorType: Option.isSome(decoded) ? decoded.value.error.type ?? null : null,
+      requestId: requestId ?? null
+    }
+  })
+
+  return yield* AiError.make({ module: "OpenAiClient", method, reason })
+})
+
+// =============================================================================
+// Rate Limits
+// =============================================================================
+
+/** @internal */
+export const parseRateLimitHeaders = (headers: Record<string, string>) => {
+  const retryAfterRaw = headers["retry-after"]
+  let retryAfter: Duration.Duration | undefined
+  if (Predicate.isNotUndefined(retryAfterRaw)) {
+    const parsed = Number.parse(retryAfterRaw)
+    if (Predicate.isNotUndefined(parsed)) {
+      retryAfter = Duration.seconds(parsed)
+    }
+  }
+  const remainingRaw = headers["x-ratelimit-remaining-requests"]
+  const remaining = Predicate.isNotUndefined(remainingRaw) ? Number.parse(remainingRaw) ?? null : null
+  return {
+    retryAfter,
+    limit: headers["x-ratelimit-limit-requests"] ?? null,
+    remaining,
+    resetRequests: headers["x-ratelimit-reset-requests"] ?? null,
+    resetTokens: headers["x-ratelimit-reset-tokens"] ?? null
+  }
+}
+
+// =============================================================================
+// HTTP Context
+// =============================================================================
+
+/** @internal */
+export const buildHttpRequestDetails = (
+  request: HttpClientRequest.HttpClientRequest
+): typeof Response.HttpRequestDetails.Type => ({
+  method: request.method,
+  url: request.url,
+  urlParams: Array.from(request.urlParams),
+  hash: request.hash,
+  headers: Redactable.redact(request.headers) as Record<string, string>
+})
+
+/** @internal */
+export const buildHttpContext = (params: {
+  readonly request: HttpClientRequest.HttpClientRequest
+  readonly response?: HttpClientResponse.HttpClientResponse
+  readonly body?: string | undefined
+}): typeof AiError.HttpContext.Type => ({
+  request: buildHttpRequestDetails(params.request),
+  response: Predicate.isNotUndefined(params.response)
+    ? {
+      status: params.response.status,
+      headers: Redactable.redact(params.response.headers) as Record<string, string>
+    }
+    : undefined,
+  body: params.body
+})
+
+// =============================================================================
+// HTTP Status Code
+// =============================================================================
+
+const buildInvalidRequestDescription = (params: {
+  readonly status: number
+  readonly message: string | undefined
+  readonly method: string
+  readonly url: string
+  readonly errorCode: string | null
+  readonly errorType: string | null
+  readonly requestId: string | null
+  readonly body: string | undefined
+}): string => {
+  const parts: Array<string> = []
+
+  // Primary message or status description
+  if (params.message) {
+    parts.push(params.message)
+  } else {
+    parts.push(`HTTP ${params.status}`)
+  }
+
+  // Request context
+  parts.push(`(${params.method} ${params.url})`)
+
+  // Error code/type if available
+  if (params.errorCode) {
+    parts.push(`[code: ${params.errorCode}]`)
+  } else if (params.errorType) {
+    parts.push(`[type: ${params.errorType}]`)
+  }
+
+  // Request ID for debugging
+  if (params.requestId) {
+    parts.push(`[requestId: ${params.requestId}]`)
+  }
+
+  // If no message and we have body, show truncated body
+  if (!params.message && params.body) {
+    const truncated = params.body.length > 200
+      ? params.body.slice(0, 200) + "..."
+      : params.body
+    parts.push(`Response: ${truncated}`)
+  }
+
+  return parts.join(" ")
+}
+
+/** @internal */
+export const mapStatusCodeToReason = ({ status, headers, message, metadata, http }: {
+  readonly status: number
+  readonly headers: Record<string, string>
+  readonly message: string | undefined
+  readonly metadata: OpenAiErrorMetadata
+  readonly http: typeof AiError.HttpContext.Type
+}): AiError.AiErrorReason => {
+  const invalidRequestDescription = buildInvalidRequestDescription({
+    status,
+    message,
+    method: http.request.method,
+    url: http.request.url,
+    errorCode: metadata.errorCode,
+    errorType: metadata.errorType,
+    requestId: metadata.requestId,
+    body: http.body
+  })
+
+  switch (status) {
+    case 400:
+      return new AiError.InvalidRequestError({
+        description: invalidRequestDescription,
+        metadata: { openai: metadata },
+        http
+      })
+    case 401:
+      return new AiError.AuthenticationError({
+        kind: "InvalidKey",
+        metadata,
+        http
+      })
+    case 403:
+      return new AiError.AuthenticationError({
+        kind: "InsufficientPermissions",
+        metadata,
+        http
+      })
+    case 404:
+      return new AiError.InvalidRequestError({
+        description: invalidRequestDescription,
+        metadata: { openai: metadata },
+        http
+      })
+    case 409:
+    case 422:
+      return new AiError.InvalidRequestError({
+        description: invalidRequestDescription,
+        metadata: { openai: metadata },
+        http
+      })
+    case 429: {
+      // Best-effort detection: OpenAI returns insufficient_quota for billing/quota issues
+      if (
+        metadata.errorCode === "insufficient_quota" ||
+        metadata.errorType === "insufficient_quota"
+      ) {
+        return new AiError.QuotaExhaustedError({
+          metadata: { openai: metadata },
+          http
+        })
+      }
+      const { retryAfter, ...rateLimitMetadata } = parseRateLimitHeaders(headers)
+      return new AiError.RateLimitError({
+        retryAfter,
+        metadata: {
+          openai: {
+            ...metadata,
+            ...rateLimitMetadata
+          }
+        },
+        http
+      })
+    }
+    default:
+      if (status >= 500) {
+        return new AiError.InternalProviderError({
+          description: message ?? "Server error",
+          metadata,
+          http
+        })
+      }
+      return new AiError.UnknownError({
+        description: message,
+        metadata,
+        http
+      })
+  }
+}

package/src/internal/utilities.ts

@@ -1,5 +1,4 @@
-import type * as Response from "@effect/ai/Response"
-import * as Predicate from "effect/Predicate"
+import type * as Response from "effect/unstable/ai/Response"
 
 /** @internal */
 export const ProviderOptionsKey = "@effect/ai-openai/OpenAiLanguageModel/ProviderOptions"
@@ -15,16 +14,19 @@ const finishReasonMap: Record<string, Response.FinishReason> = {
   tool_calls: "tool-calls"
 }
 
+/** @internal */
+export const escapeJSONDelta = (delta: string): string => JSON.stringify(delta).slice(1, -1)
+
 /** @internal */
 export const resolveFinishReason = (
-  finishReason: string | undefined,
+  finishReason: string | null | undefined,
   hasToolCalls: boolean
 ): Response.FinishReason => {
-  if (Predicate.isNullable(finishReason)) {
+  if (finishReason == null) {
     return hasToolCalls ? "tool-calls" : "stop"
   }
   const reason = finishReasonMap[finishReason]
-  if (Predicate.isNullable(reason)) {
+  if (reason == null) {
     return hasToolCalls ? "tool-calls" : "unknown"
   }
   return reason

package/Generated/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/Generated.js",
-  "module": "../dist/esm/Generated.js",
-  "types": "../dist/dts/Generated.d.ts"
-}

package/OpenAiClient/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiClient.js",
-  "module": "../dist/esm/OpenAiClient.js",
-  "types": "../dist/dts/OpenAiClient.d.ts"
-}

package/OpenAiConfig/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiConfig.js",
-  "module": "../dist/esm/OpenAiConfig.js",
-  "types": "../dist/dts/OpenAiConfig.d.ts"
-}

package/OpenAiEmbeddingModel/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiEmbeddingModel.js",
-  "module": "../dist/esm/OpenAiEmbeddingModel.js",
-  "types": "../dist/dts/OpenAiEmbeddingModel.d.ts"
-}

package/OpenAiLanguageModel/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiLanguageModel.js",
-  "module": "../dist/esm/OpenAiLanguageModel.js",
-  "types": "../dist/dts/OpenAiLanguageModel.d.ts"
-}

package/OpenAiTelemetry/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiTelemetry.js",
-  "module": "../dist/esm/OpenAiTelemetry.js",
-  "types": "../dist/dts/OpenAiTelemetry.d.ts"
-}

package/OpenAiTokenizer/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiTokenizer.js",
-  "module": "../dist/esm/OpenAiTokenizer.js",
-  "types": "../dist/dts/OpenAiTokenizer.d.ts"
-}

package/OpenAiTool/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/OpenAiTool.js",
-  "module": "../dist/esm/OpenAiTool.js",
-  "types": "../dist/dts/OpenAiTool.d.ts"
-}

package/README.md

@@ -1,5 +0,0 @@
-# `@effect/ai-openai`
-
-## Documentation
-
-- **API Reference**: [View the full documentation](https://effect-ts.github.io/effect/docs/ai/openai).