@effect/ai 0.26.0 → 0.27.0

package/dist/dts/AiError.d.ts

@@ -1,31 +1,527 @@
+/**
+ * The `AiError` module provides comprehensive error handling for AI operations.
+ *
+ * This module defines a hierarchy of error types that can occur when working
+ * with AI services, including HTTP request/response errors, input/output
+ * validation errors, and general runtime errors. All errors follow Effect's
+ * structured error patterns and provide detailed context for debugging.
+ *
+ * ## Error Types
+ *
+ * - **HttpRequestError**: Errors occurring during HTTP request processing
+ * - **HttpResponseError**: Errors occurring during HTTP response processing
+ * - **MalformedInput**: Errors when input data doesn't match expected format
+ * - **MalformedOutput**: Errors when output data can't be parsed or validated
+ * - **UnknownError**: Catch-all for unexpected runtime errors
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect, Match } from "effect"
+ *
+ * const handleAiError = Match.type<AiError.AiError>().pipe(
+ *   Match.tag("HttpRequestError", (err) =>
+ *     Effect.logError(`Request failed: ${err.message}`)
+ *   ),
+ *   Match.tag("HttpResponseError", (err) =>
+ *     Effect.logError(`Response error (${err.response.status}): ${err.message}`)
+ *   ),
+ *   Match.tag("MalformedInput", (err) =>
+ *     Effect.logError(`Invalid input: ${err.message}`)
+ *   ),
+ *   Match.tag("MalformedOutput", (err) =>
+ *     Effect.logError(`Invalid output: ${err.message}`)
+ *   ),
+ *   Match.orElse((err) =>
+ *     Effect.logError(`Unknown error: ${err.message}`)
+ *   )
+ * )
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect, Option } from "effect"
+ *
+ * const aiOperation = Effect.gen(function* () {
+ *   // Some AI operation that might fail
+ *   return yield* new AiError.HttpRequestError({
+ *     module: "OpenAI",
+ *     method: "completion",
+ *     reason: "Transport",
+ *     request: {
+ *       method: "POST",
+ *       url: "https://api.openai.com/v1/completions",
+ *       urlParams: [],
+ *       hash: Option.none(),
+ *       headers: { "Authorization": "Bearer ***" }
+ *     }
+ *   })
+ * })
+ *
+ * const program = aiOperation.pipe(
+ *   Effect.catchTag("HttpRequestError", (error) => {
+ *     console.log("Request failed:", error.message)
+ *     return Effect.succeed("fallback response")
+ *   })
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ */
+import type * as HttpClientError from "@effect/platform/HttpClientError";
+import type { ParseError } from "effect/ParseResult";
 import * as Schema from "effect/Schema";
 /**
+ * Unique identifier for AI errors.
+ *
  * @since 1.0.0
- * @category type ids
+ * @category Type Ids
  */
-export declare const TypeId: unique symbol;
+export declare const TypeId = "~@effect/ai/AiError";
 /**
+ * Type-level representation of the AI error identifier.
+ *
  * @since 1.0.0
- * @category type ids
+ * @category Type Ids
  */
 export type TypeId = typeof TypeId;
-declare const AiError_base: Schema.TaggedErrorClass<AiError, "AiError", {
-    readonly _tag: Schema.tag<"AiError">;
+/**
+ * Type guard to check if a value is an AI error.
+ *
+ * @param u - The value to check
+ * @returns `true` if the value is an `AiError`, `false` otherwise
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ *
+ * const someError = new Error("generic error")
+ * const aiError = new AiError.UnknownError({
+ *   module: "Test",
+ *   method: "example"
+ * })
+ *
+ * console.log(AiError.isAiError(someError)) // false
+ * console.log(AiError.isAiError(aiError))   // true
+ * ```
+ *
+ * @since 1.0.0
+ * @category Guards
+ */
+export declare const isAiError: (u: unknown) => u is AiError;
+/**
+ * Schema for HTTP request details used in error reporting.
+ *
+ * Captures comprehensive information about HTTP requests that failed,
+ * enabling detailed error analysis and debugging.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Option } from "effect"
+ *
+ * const requestDetails: typeof AiError.HttpRequestDetails.Type = {
+ *   method: "POST",
+ *   url: "https://api.openai.com/v1/completions",
+ *   urlParams: [["model", "gpt-4"], ["stream", "false"]],
+ *   hash: Option.some("#section1"),
+ *   headers: {
+ *     "Content-Type": "application/json",
+ *     "Authorization": "Bearer sk-..."
+ *   }
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare const HttpRequestDetails: Schema.Struct<{
+    method: Schema.Literal<["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD", "OPTIONS"]>;
+    url: typeof Schema.String;
+    urlParams: Schema.Array$<Schema.Tuple2<typeof Schema.String, typeof Schema.String>>;
+    hash: Schema.Option<typeof Schema.String>;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+}>;
+declare const HttpRequestError_base: Schema.TaggedErrorClass<HttpRequestError, "HttpRequestError", {
+    readonly _tag: Schema.tag<"HttpRequestError">;
+} & {
+    module: typeof Schema.String;
+    method: typeof Schema.String;
+    reason: Schema.Literal<["Transport", "Encode", "InvalidUrl"]>;
+    request: Schema.Struct<{
+        method: Schema.Literal<["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD", "OPTIONS"]>;
+        url: typeof Schema.String;
+        urlParams: Schema.Array$<Schema.Tuple2<typeof Schema.String, typeof Schema.String>>;
+        hash: Schema.Option<typeof Schema.String>;
+        headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Error that occurs during HTTP request processing.
+ *
+ * This error is raised when issues arise before receiving an HTTP response,
+ * such as network connectivity problems, request encoding issues, or invalid
+ * URLs.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const handleNetworkError = Effect.gen(function* () {
+ *   const error = new AiError.HttpRequestError({
+ *     module: "OpenAI",
+ *     method: "createCompletion",
+ *     reason: "Transport",
+ *     request: {
+ *       method: "POST",
+ *       url: "https://api.openai.com/v1/completions",
+ *       urlParams: [],
+ *       hash: Option.none(),
+ *       headers: { "Content-Type": "application/json" }
+ *     },
+ *     description: "Connection timeout after 30 seconds"
+ *   })
+ *
+ *   console.log(error.message)
+ *   // "Transport: Connection timeout after 30 seconds (POST https://api.openai.com/v1/completions)"
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class HttpRequestError extends HttpRequestError_base {
+    /**
+     * @since 1.0.0
+     */
+    readonly [TypeId]: TypeId;
+    /**
+     * Creates an HttpRequestError from a platform HttpClientError.RequestError.
+     *
+     * @example
+     * ```ts
+     * import { AiError } from "@effect/ai"
+     * import { HttpClientError } from "@effect/platform"
+     * import { Option } from "effect"
+     *
+     * declare const platformError: HttpClientError.RequestError
+     *
+     * const aiError = AiError.HttpRequestError.fromRequestError({
+     *   module: "ChatGPT",
+     *   method: "sendMessage",
+     *   error: platformError
+     * })
+     * ```
+     *
+     * @since 1.0.0
+     * @category Constructors
+     */
+    static fromRequestError({ error, ...params }: {
+        readonly module: string;
+        readonly method: string;
+        readonly error: HttpClientError.RequestError;
+    }): HttpRequestError;
+    get message(): string;
+}
+/**
+ * Schema for HTTP response details used in error reporting.
+ *
+ * Captures essential information about HTTP responses that caused errors,
+ * including status codes and headers for debugging purposes.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ *
+ * const responseDetails: typeof AiError.HttpResponseDetails.Type = {
+ *   status: 429,
+ *   headers: {
+ *     "Content-Type": "application/json",
+ *     "X-RateLimit-Remaining": "0",
+ *     "Retry-After": "60"
+ *   }
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare const HttpResponseDetails: Schema.Struct<{
+    status: typeof Schema.Number;
+    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+}>;
+declare const HttpResponseError_base: Schema.TaggedErrorClass<HttpResponseError, "HttpResponseError", {
+    readonly _tag: Schema.tag<"HttpResponseError">;
+} & {
+    module: typeof Schema.String;
+    method: typeof Schema.String;
+    request: Schema.Struct<{
+        method: Schema.Literal<["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD", "OPTIONS"]>;
+        url: typeof Schema.String;
+        urlParams: Schema.Array$<Schema.Tuple2<typeof Schema.String, typeof Schema.String>>;
+        hash: Schema.Option<typeof Schema.String>;
+        headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>;
+    response: Schema.Struct<{
+        status: typeof Schema.Number;
+        headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>;
+    reason: Schema.Literal<["StatusCode", "Decode", "EmptyBody"]>;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Error that occurs during HTTP response processing.
+ *
+ * This error is thrown when issues arise after receiving an HTTP response,
+ * such as unexpected status codes, response decoding failures, or empty
+ * response bodies.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Option } from "effect"
+ *
+ * const responseError = new AiError.HttpResponseError({
+ *   module: "OpenAI",
+ *   method: "createCompletion",
+ *   reason: "StatusCode",
+ *   request: {
+ *     method: "POST",
+ *     url: "https://api.openai.com/v1/completions",
+ *     urlParams: [],
+ *     hash: Option.none(),
+ *     headers: { "Authorization": "Bearer sk-..." }
+ *   },
+ *   response: {
+ *     status: 429,
+ *     headers: { "X-RateLimit-Remaining": "0" }
+ *   },
+ *   description: "Rate limit exceeded"
+ * })
+ *
+ * console.log(responseError.message)
+ * // "StatusCode: Rate limit exceeded (429 POST https://api.openai.com/v1/completions)"
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class HttpResponseError extends HttpResponseError_base {
+    /**
+     * @since 1.0.0
+     */
+    readonly [TypeId]: TypeId;
+    /**
+     * Creates an HttpResponseError from a platform HttpClientError.ResponseError.
+     *
+     * @example
+     * ```ts
+     * import { AiError } from "@effect/ai"
+     * import { Headers, HttpClientError } from "@effect/platform"
+     * import { Option } from "effect"
+     *
+     * declare const platformError: HttpClientError.ResponseError
+     *
+     * const aiError = AiError.HttpResponseError.fromResponseError({
+     *   module: "OpenAI",
+     *   method: "completion",
+     *   error: platformError
+     * })
+     * ```
+     *
+     * @since 1.0.0
+     * @category Constructors
+     */
+    static fromResponseError({ error, ...params }: {
+        readonly module: string;
+        readonly method: string;
+        readonly error: HttpClientError.ResponseError;
+    }): HttpResponseError;
+    get message(): string;
+}
+declare const MalformedInput_base: Schema.TaggedErrorClass<MalformedInput, "MalformedInput", {
+    readonly _tag: Schema.tag<"MalformedInput">;
+} & {
+    module: typeof Schema.String;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Error thrown when input data doesn't match the expected format or schema.
+ *
+ * This error occurs when the data provided to an AI operation fails validation,
+ * is missing required fields, or doesn't conform to the expected structure.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const validateInput = (data: unknown) =>
+ *   typeof data === "string" && data.length > 0
+ *     ? Effect.succeed(data)
+ *     : Effect.fail(new AiError.MalformedInput({
+ *         module: "ChatBot",
+ *         method: "processMessage",
+ *         description: "Input must be a non-empty string"
+ *       }))
+ *
+ * const program = validateInput("").pipe(
+ *   Effect.catchTag("MalformedInput", (error) => {
+ *     console.log(`Input validation failed: ${error.description}`)
+ *     return Effect.succeed("Please provide a valid message")
+ *   })
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class MalformedInput extends MalformedInput_base {
+    /**
+     * @since 1.0.0
+     */
+    readonly [TypeId]: TypeId;
+}
+declare const MalformedOutput_base: Schema.TaggedErrorClass<MalformedOutput, "MalformedOutput", {
+    readonly _tag: Schema.tag<"MalformedOutput">;
 } & {
     module: typeof Schema.String;
     method: typeof Schema.String;
-    description: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
     cause: Schema.optional<typeof Schema.Defect>;
 }>;
 /**
+ * Error thrown when output data can't be parsed or validated.
+ *
+ * This error occurs when AI service responses don't match the expected format,
+ * contain invalid data structures, or fail schema validation during parsing.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect, Schema } from "effect"
+ *
+ * const ResponseSchema = Schema.Struct({
+ *   message: Schema.String,
+ *   tokens: Schema.Number
+ * })
+ *
+ * const parseResponse = (data: unknown) =>
+ *   Schema.decodeUnknown(ResponseSchema)(data).pipe(
+ *     Effect.mapError(parseError =>
+ *       new AiError.MalformedOutput({
+ *         module: "OpenAI",
+ *         method: "completion",
+ *         description: "Response doesn't match expected schema",
+ *         cause: parseError
+ *       })
+ *     )
+ *   )
+ *
+ * const program = parseResponse({ invalid: "data" }).pipe(
+ *   Effect.catchTag("MalformedOutput", (error) => {
+ *     console.log(`Parsing failed: ${error.description}`)
+ *     return Effect.succeed({ message: "Error", tokens: 0 })
+ *   })
+ * )
+ * ```
+ *
  * @since 1.0.0
- * @category errors
+ * @category Errors
  */
-export declare class AiError extends AiError_base {
+export declare class MalformedOutput extends MalformedOutput_base {
+    /**
+     * @since 1.0.0
+     */
+    readonly [TypeId]: TypeId;
     /**
+     * Creates a MalformedOutput error from a Schema ParseError.
+     *
+     * @example
+     * ```ts
+     * import { AiError } from "@effect/ai"
+     * import { Effect, Schema } from "effect"
+     *
+     * const UserSchema = Schema.Struct({
+     *   name: Schema.String,
+     *   age: Schema.Number
+     * })
+     *
+     * const parseUser = (data: unknown) =>
+     *   Schema.decodeUnknown(UserSchema)(data).pipe(
+     *     Effect.mapError((parseError) =>
+     *       AiError.MalformedOutput.fromParseError({
+     *         module: "UserService",
+     *         method: "parseUserData",
+     *         error: parseError
+     *       })
+     *     )
+     *   )
+     * ```
+     *
      * @since 1.0.0
+     * @category Constructors
      */
-    static is(u: unknown): u is AiError;
+    static fromParseError({ error, ...params }: {
+        readonly module: string;
+        readonly method: string;
+        readonly error: ParseError;
+    }): MalformedOutput;
+}
+declare const UnknownError_base: Schema.TaggedErrorClass<UnknownError, "UnknownError", {
+    readonly _tag: Schema.tag<"UnknownError">;
+} & {
+    module: typeof Schema.String;
+    method: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+    cause: Schema.optional<typeof Schema.Defect>;
+}>;
+/**
+ * Catch-all error for unexpected runtime errors in AI operations.
+ *
+ * This error is used when an unexpected exception occurs that doesn't fit
+ * into the other specific error categories. It provides context about where
+ * the error occurred and preserves the original cause for debugging.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect } from "effect"
+ *
+ * const riskyOperation = () => {
+ *   try {
+ *     // Some operation that might throw
+ *     throw new Error("Unexpected network issue")
+ *   } catch (cause) {
+ *     return Effect.fail(new AiError.UnknownError({
+ *       module: "ChatService",
+ *       method: "sendMessage",
+ *       description: "An unexpected error occurred during message processing",
+ *       cause
+ *     }))
+ *   }
+ * }
+ *
+ * const program = riskyOperation().pipe(
+ *   Effect.catchTag("UnknownError", (error) => {
+ *     console.log(error.message)
+ *     // "ChatService.sendMessage: An unexpected error occurred during message processing"
+ *     return Effect.succeed("Service temporarily unavailable")
+ *   })
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors
+ */
+export declare class UnknownError extends UnknownError_base {
     /**
      * @since 1.0.0
      */
@@ -35,5 +531,77 @@ export declare class AiError extends AiError_base {
      */
     get message(): string;
 }
+/**
+ * Union type representing all possible AI operation errors.
+ *
+ * This type encompasses all error cases that can occur during AI operations,
+ * providing a comprehensive error handling surface for applications.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Effect, Match } from "effect"
+ *
+ * const handleAnyAiError = Match.type<AiError.AiError>().pipe(
+ *   Match.tag("HttpRequestError", (err) =>
+ *     `Network error: ${err.reason}`
+ *   ),
+ *   Match.tag("HttpResponseError", (err) =>
+ *     `Server error: HTTP ${err.response.status}`
+ *   ),
+ *   Match.tag("MalformedInput", (err) =>
+ *     `Invalid input: ${err.description || "Data validation failed"}`
+ *   ),
+ *   Match.tag("MalformedOutput", (err) =>
+ *     `Invalid response: ${err.description || "Response parsing failed"}`
+ *   ),
+ *   Match.orElse((err) =>
+ *     `Unknown error: ${err.message}`
+ *   )
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Models
+ */
+export type AiError = HttpRequestError | HttpResponseError | MalformedInput | MalformedOutput | UnknownError;
+/**
+ * Schema for validating and parsing AI errors.
+ *
+ * This schema can be used to decode unknown values into properly typed AI
+ * errors, ensuring type safety when handling errors from external sources or
+ * serialized data.
+ *
+ * @example
+ * ```ts
+ * import { AiError } from "@effect/ai"
+ * import { Schema, Effect } from "effect"
+ *
+ * const parseAiError = (data: unknown) =>
+ *   Schema.decodeUnknown(AiError.AiError)(data).pipe(
+ *     Effect.map(error => {
+ *       console.log(`Parsed AI error: ${error._tag}`)
+ *       return error
+ *     }),
+ *     Effect.catchAll(() =>
+ *       Effect.succeed(new AiError.UnknownError({
+ *         module: "Parser",
+ *         method: "parseAiError",
+ *         description: "Failed to parse error data"
+ *       }))
+ *     )
+ *   )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export declare const AiError: Schema.Union<[
+    typeof HttpRequestError,
+    typeof HttpResponseError,
+    typeof MalformedInput,
+    typeof MalformedOutput,
+    typeof UnknownError
+]>;
 export {};
 //# sourceMappingURL=AiError.d.ts.map

package/dist/dts/AiError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AiError.d.ts","sourceRoot":"","sources":["../../src/AiError.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,OAAO,MAAyC,CAAA;AAErE;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAA;;;;;;;;;AAElC;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAK3B;IACA;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,OAAO;IAGnC;;OAEG;IACH,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAS;IAClC;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;CACF"}
+{"version":3,"file":"AiError.d.ts","sourceRoot":"","sources":["../../src/AiError.ts"],"names":[],"mappings":"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"}