```typescript TypeScript
import { b } from './baml_client'
// For catching parsing errors and cancellation errors, you can import these
import { BamlValidationError, BamlClientFinishReasonError, BamlAbortError } from '@boundaryml/baml'
// The rest of the BAML errors contain a string that is prefixed with:
// "BamlError:"
// Subclasses are sequentially appended to the string.
// For example, BamlInvalidArgumentError is returned as:
// "BamlError: BamlInvalidArgumentError:"
// Or, BamlClientHttpError is returned as:
// "BamlError: BamlClientError: BamlClientHttpError:"


async function example() {
  try {
    await b.CallFunctionThatRaisesError()
  } catch (e) {
    if (e instanceof BamlAbortError) {
      // Handle cancellation
      console.log('Operation was cancelled:', e.message)
      console.log('Cancellation reason:', e.reason)
    } else if (e instanceof BamlValidationError || e instanceof BamlClientFinishReasonError) {
      // You should be lenient to these fields missing.
      // The original prompt sent to the LLM
      console.log(e.prompt)
      // The LLM response string
      console.log(e.raw_output)
      // A human-readable error message
      console.log(e.message)
      // Complete error history (includes fallback attempts)
      console.log(e.detailed_message)
    } else {
      // Handle other BAML errors
      console.log(e)
    }
  }
}

// Error handling support coming soon for Go
// Currently, Go functions return standard (non-typed) Go errors

# Example coming soon

use myproject::baml_client::sync_client::B;

fn main() {
    match B.CallFunctionThatRaisesError.call() {
        Ok(result) => println!("Result: {:?}", result),
        Err(e) => {
            // All BAML errors implement Display and Debug
            eprintln!("Error: {}", e);
            // Use Debug format for detailed error info
            eprintln!("Details: {:?}", e);
        }
    }
}

# Cancel after 5 seconds
async def cancel_after_timeout():
    await asyncio.sleep(5)
    controller.abort('timeout')

asyncio.create_task(cancel_after_timeout())

try:
    result = await b.ExtractData(
        input_text,
        baml_options={"abort_controller": controller}
    )
except BamlAbortError as e:
    if e.reason == 'timeout':
        print("Operation timed out after 5 seconds")
    else:
        print(f"Operation was cancelled: {e.message}")
except BamlValidationError as e:
    print(f"Validation failed: {e.message}")

```typescript TypeScript
import { b } from './baml_client'
import { BamlAbortError } from '@boundaryml/baml'

async function example() {
  const controller = new AbortController()

  // Cancel after 5 seconds
  setTimeout(() => controller.abort('timeout'), 5000)

  try {
    const result = await b.ExtractData(inputText, {
      abortController: controller
    })
  } catch (e) {
    if (e instanceof BamlAbortError) {
      if (e.reason === 'timeout') {
        console.log('Operation timed out after 5 seconds')
      } else {
        console.log(`Operation was cancelled: ${e.message}`)
      }
    } else if (e instanceof BamlValidationError) {
      console.log(`Validation failed: ${e.message}`)
    }
  }
}

import (
    "context"
    "errors"
    "time"
)

func example() {
    // Create context with 5 second timeout
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    result, err := b.ExtractData(ctx, inputText)
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            fmt.Println("Operation timed out after 5 seconds")
        } else if errors.Is(err, context.Canceled) {
            fmt.Println("Operation was cancelled")
        } else {
            // Handle other errors
            fmt.Printf("Error: %v\n", err)
        }
    }
}

begin
  controller = Baml::AbortController.new

  # Cancel after 5 seconds in another thread
  Thread.new do
    sleep(5)
    controller.abort('timeout')
  end

  result = b.extract_data(
    input_text,
    baml_options: { abort_controller: controller }
  )
rescue Baml::AbortError => e
  if e.reason == 'timeout'
    puts "Operation timed out after 5 seconds"
  else
    puts "Operation was cancelled: #{e.message}"
  end
rescue Baml::ValidationError => e
  puts "Validation failed: #{e.message}"
end

use baml::CancellationToken;
use myproject::baml_client::sync_client::B;
use std::time::Duration;

fn main() {
    // Cancel after 5 seconds
    let token = CancellationToken::new_with_timeout(Duration::from_secs(5));

    let result = B.ExtractData
        .with_cancellation_token(Some(token))
        .call(input_text);

    match result {
        Ok(data) => println!("Result: {:?}", data),
        Err(e) => {
            let error_str = format!("{:?}", e).to_lowercase();
            if error_str.contains("cancel") || error_str.contains("timeout") {
                println!("Operation timed out after 5 seconds");
            } else {
                eprintln!("Error: {}", e);
            }
        }
    }
}

function FixupFoo(errorMessage: string) -> MyClass {
    client GPT4o
    prompt #"
        Fix this malformed JSON. Preserve the same information.

        {{ ctx.output_format }}

        Original data and parse error:
        {{ errorMessage }}
    "#
}

```go Go
// Example coming soon.

begin
  result = b.foo(my_data)
rescue Baml::ValidationError => e
  result = b.fixup_foo(JSON.generate(e))
end

use myproject::baml_client::sync_client::B;

let result = match B.Foo.call(my_data) {
    Ok(result) => result,
    Err(e) => {
        // Attempt fixup on errors
        B.FixupFoo.call(&format!("{:?}", e)).unwrap()
    }
};