Custom Error Support for LoomError

[Wolfenheimm]

Overview

Improve error handling by providing more type-safe and flexible error management for users of the library.

Changes

1. Modified LoomError enum

   • Introduced a new variant Llm that uses the associated type PromptError from the Llm trait.
   • This allows for more specific and type-safe error handling.

2. Added PromptError associated type to Llm trait:

   • Introduced a new associated type PromptError in the Llm trait.
   • This type implements the Error trait.

3. Updated Result type alias:

   • Modified the Result type alias to use LoomError<U> as the error type.
   • This change propagates the type-safe error handling throughout the library.

Usage Example

Users can now define their custom PromptError types and use them with the library:

use std::error::Error;

#[derive(Debug, thiserror::Error)]
enum MyPromptError {
    #[error("Bad configuration: {0}")]
    BadConfig(String),
    #[error("API error: {0}")]
    ApiError(String),
}

struct MyLlm;

impl Llm<MyConfig> for MyLlm {
    type PromptError = MyPromptError;
    
    // ... other associated types and methods ...

    async fn prompt(
        &self,
        // ... other parameters ...
    ) -> Result<Self::Response, MyConfig> {
        // If an error occurs:
        Err(LoomError::Llm(MyPromptError::BadConfig("Invalid prompt".to_string())))
    }
}

Error Handling

The new error structure allows for more precise error handling:

match result {
    Ok(response) => println!("Success: {:?}", response),
    Err(LoomError::Llm(prompt_error)) => match prompt_error {
        MyPromptError::BadConfig(msg) => println!("Configuration error: {}", msg),
        MyPromptError::ApiError(msg) => println!("API error: {}", msg),
    },
    Err(LoomError::Storage(storage_error)) => println!("Storage error: {}", storage_error),
    Err(LoomError::BadConfig(msg)) => println!("Bad configuration: {}", msg),
    Err(LoomError::MaxCompletionTokensIsZero) => println!("Exceeded max prompt tokens"),
    Err(LoomError::UnknownError(msg)) => println!("Unknown error: {}", msg),
}

Benefits

• Type-safe error handling: Errors are now more closely tied to their sources.
• Flexible: Users can define their own error types for different LLM implementations.
• Consistent: The Result type alias ensures consistent error handling throughout the library.

Supplemental

• Modified Result across the codebase to accommodate this structural change.
• Test(s) have been updated to accommodate these changes

[snowmead]

The approach you took does not allow the user to specify his own custom error type and have it propagated within the weave function in a type safe way. The Llm trait functions still return dyn Error and therefore any error can be returned from the user, so there is no guarantee that the result of the weave function would yield the error they expected.

I have updated the issue #11 to describe more deeply the requirements that should be met.

[snowmead]

close #12