ops-rs 1.63.594

// Simple test to check compilation
use std::sync::Arc;

// Mock structures to test compilation without full dependencies
struct MockTaskService;
struct MockLlmStreamUpdate;

trait MockCallback: Send + Sync {
    fn handle_update_sync(&self, update: MockLlmStreamUpdate);
}

struct MockTaskAwareLlmCallback;

impl MockCallback for MockTaskAwareLlmCallback {
    fn handle_update_sync(&self, _update: MockLlmStreamUpdate) {
        // Mock implementation
    }
}

struct MockNoOpLlmCallback;

impl MockCallback for MockNoOpLlmCallback {
    fn handle_update_sync(&self, _update: MockLlmStreamUpdate) {
        // No operation performed
    }
}

#[derive(Clone)]
struct MockProgressCallbackWrapper {
    inner: Arc<dyn MockCallback + Send + Sync>
}

impl MockProgressCallbackWrapper {
    pub fn new() -> Self {
        Self {
            inner: Arc::new(MockTaskAwareLlmCallback),
        }
    }

    pub fn new_no_op() -> Self {
        Self {
            inner: Arc::new(MockNoOpLlmCallback),
        }
    }

    pub fn call(&self, update: MockLlmStreamUpdate) {
        self.inner.handle_update_sync(update);
    }

    pub fn as_callback(&self) -> impl Fn(MockLlmStreamUpdate) + Send + Sync + Clone + 'static {
        let inner = Arc::clone(&self.inner);
        move |update: MockLlmStreamUpdate| {
            inner.handle_update_sync(update);
        }
    }
}

fn main() {
    let wrapper = MockProgressCallbackWrapper::new();
    let no_op = MockProgressCallbackWrapper::new_no_op();
    
    println!("Callback wrappers created successfully!");
    
    // Test calling the callback
    wrapper.call(MockLlmStreamUpdate);
    no_op.call(MockLlmStreamUpdate);
    
    // Test creating closures
    let callback_fn = wrapper.as_callback();
    let no_op_fn = no_op.as_callback();
    
    callback_fn(MockLlmStreamUpdate);
    no_op_fn(MockLlmStreamUpdate);
    
    println!("All tests passed!");
}