test: cover async next callback failures

Signed-off-by: Will Killian <wkillian@nvidia.com>

Author: willkill07

crates/ffi/nemo_relay.h

@@ -2649,6 +2649,9 @@ NemoRelayStatus nemo_relay_async_next_invoke(const struct NemoRelayAsyncNext *ne
 
 /**
  * Invoke the next execution layer and report its result through a callback.
+ *
+ * A non-`Ok` return means invocation was not scheduled and `callback` is
+ * never invoked; the caller owns any state it allocated for `user_data`.
  */
 NemoRelayStatus nemo_relay_async_next_invoke_callback(const struct NemoRelayAsyncNext *next,
                                                       const char *invocation_json,

crates/ffi/src/callable.rs

@@ -328,6 +328,9 @@ pub unsafe extern "C" fn nemo_relay_async_next_invoke(
 }
 
 /// Invoke the next execution layer and report its result through a callback.
+///
+/// A non-`Ok` return means invocation was not scheduled and `callback` is
+/// never invoked; the caller owns any state it allocated for `user_data`.
 #[allow(clippy::missing_safety_doc)] // The shared C ABI safety contract applies.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn nemo_relay_async_next_invoke_callback(

crates/ffi/tests/unit/callable_private_tests.rs

@@ -298,4 +298,33 @@ fn async_next_callback_reports_tool_llm_and_stream_results() {
         assert_eq!(runtime.block_on(receiver).unwrap().unwrap(), expected);
         unsafe { nemo_relay_async_next_release(next_ref) };
     }
+
+    let next = Arc::new(NemoRelayAsyncNext {
+        inner: AsyncNextInner::Tool(Arc::new(|_value| {
+            Box::pin(async { Err(FlowError::Internal("next failed".into())) })
+        })),
+        runtime: runtime.handle().clone(),
+    });
+    let next_ref = Arc::into_raw(next);
+    let invocation = CString::new("{}").unwrap();
+    let (sender, receiver) = tokio::sync::oneshot::channel::<std::result::Result<Json, String>>();
+    assert_eq!(
+        unsafe {
+            nemo_relay_async_next_invoke_callback(
+                next_ref,
+                invocation.as_ptr(),
+                send_next_result,
+                Box::into_raw(Box::new(sender)).cast(),
+            )
+        },
+        NemoRelayStatus::Ok
+    );
+    assert!(
+        runtime
+            .block_on(receiver)
+            .unwrap()
+            .unwrap_err()
+            .contains("next failed")
+    );
+    unsafe { nemo_relay_async_next_release(next_ref) };
 }