fix(alert): pass AlertItem to enable/disable across all language SDKs

Problem: enable() and disable() sent only {id, enabled} to the API,
causing "invalid frequency:0" and "invalid indicator id" errors.

Solution: change the signature to accept an AlertItem (obtained from
list()) so all required fields are available without an extra round-trip.

Changes:
- rust/src/alert/context.rs: enable/disable take &AlertItem; add
  internal set_enabled() helper that builds the full request payload
- rust/src/blocking/alert.rs: blocking wrappers accept AlertItem by value
- python/src/alert/: add From<AlertItem> for lb::AlertItem; binding
  passes AlertItem to core
- nodejs/src/alert/: add From<AlertItem> for lb::AlertItem; binding
  passes AlertItem to core
- java/src/alert_context.rs: add read_alert_item() that reads each
  field from the Java object via JNI; no FromJValue needed
- c/src/alert_context/: lb_alert_context_enable/disable accept
  *const CAlertItem; add CAlertItem::to_alert_item() conversion

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: hogan-yuan

c/csrc/include/longbridge.h

@@ -1665,6 +1665,48 @@ typedef struct lb_async_result_t {
 
 typedef void (*lb_async_callback_t)(const struct lb_async_result_t*);
 
+/**
+ * A single alert indicator configuration for a symbol.
+ */
+typedef struct lb_alert_item_t {
+  /**
+   * Unique alert identifier.
+   */
+  const char *id;
+  /**
+   * Identifier of the indicator that triggers this alert.
+   */
+  const char *indicator_id;
+  /**
+   * Whether this alert is currently enabled.
+   */
+  bool enabled;
+  /**
+   * Alert notification frequency code.
+   */
+  int32_t frequency;
+  /**
+   * Scope of the alert (e.g. per-symbol or global).
+   */
+  int32_t scope;
+  /**
+   * Human-readable description text for the alert.
+   */
+  const char *text;
+  /**
+   * Pointer to an array of state codes associated with this alert.
+   */
+  const int32_t *state;
+  /**
+   * Number of elements in the `state` array.
+   */
+  uintptr_t num_state;
+  /**
+   * JSON-serialized map of additional indicator parameter values.
+   */
+  const char *value_map;
+} lb_alert_item_t;
+
 /**
  * HTTP Header
  */
@@ -6700,48 +6742,6 @@ typedef struct lb_exchange_rates_t {
   uintptr_t num_exchanges;
 } lb_exchange_rates_t;
 
-/**
- * A single alert indicator configuration for a symbol.
- */
-typedef struct lb_alert_item_t {
-  /**
-   * Unique alert identifier.
-   */
-  const char *id;
-  /**
-   * Identifier of the indicator that triggers this alert.
-   */
-  const char *indicator_id;
-  /**
-   * Whether this alert is currently enabled.
-   */
-  bool enabled;
-  /**
-   * Alert notification frequency code.
-   */
-  int32_t frequency;
-  /**
-   * Scope of the alert (e.g. per-symbol or global).
-   */
-  int32_t scope;
-  /**
-   * Human-readable description text for the alert.
-   */
-  const char *text;
-  /**
-   * Pointer to an array of state codes associated with this alert.
-   */
-  const int32_t *state;
-  /**
-   * Number of elements in the `state` array.
-   */
-  uintptr_t num_state;
-  /**
-   * JSON-serialized map of additional indicator parameter values.
-   */
-  const char *value_map;
-} lb_alert_item_t;
-
 /**
  * A symbol together with all of its associated alert indicators.
  */
@@ -7878,17 +7878,27 @@ void lb_alert_context_add(const struct lb_alert_context_t *ctx,
 
 /**
  * Enable a price alert.
+ *
+ * `item` must point to a valid [`CAlertItem`] obtained from
+ * [`lb_alert_context_list`]. All fields are read before the function
+ * returns, so the pointer only needs to be valid for the duration of
+ * the call.
  */
 void lb_alert_context_enable(const struct lb_alert_context_t *ctx,
-                             const char *alert_id,
+                             const struct lb_alert_item_t *item,
                              lb_async_callback_t callback,
                              void *userdata);
 
 /**
  * Disable a price alert.
+ *
+ * `item` must point to a valid [`CAlertItem`] obtained from
+ * [`lb_alert_context_list`]. All fields are read before the function
+ * returns, so the pointer only needs to be valid for the duration of
+ * the call.
  */
 void lb_alert_context_disable(const struct lb_alert_context_t *ctx,
-                              const char *alert_id,
+                              const struct lb_alert_item_t *item,
                               lb_async_callback_t callback,
                               void *userdata);
 

c/src/alert_context/context.rs

@@ -65,34 +65,25 @@ pub unsafe extern "C" fn lb_alert_context_add(
     });
 }
 
-/// Enable a price alert.
+/// Update (enable or disable) a price alert.
+///
+/// `item` must point to a valid [`CAlertItem`] obtained from
+/// [`lb_alert_context_list`]. Set `enabled` to `true` to re-enable or
+/// `false` to disable. All fields of `item` are read before the function
+/// returns, so the pointer only needs to be valid for the duration of
+/// the call.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn lb_alert_context_enable(
+pub unsafe extern "C" fn lb_alert_context_update(
     ctx: *const CAlertContext,
-    alert_id: *const c_char,
+    item: *const CAlertItem,
+    enabled: bool,
     callback: CAsyncCallback,
     userdata: *mut c_void,
 ) {
     let ctx_inner = (*ctx).ctx.clone();
-    let id = cstr_to_rust(alert_id);
+    let alert_item = (*item).to_alert_item();
     execute_async(callback, ctx, userdata, async move {
-        ctx_inner.enable(id).await?;
-        Ok(())
-    });
-}
-
-/// Disable a price alert.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn lb_alert_context_disable(
-    ctx: *const CAlertContext,
-    alert_id: *const c_char,
-    callback: CAsyncCallback,
-    userdata: *mut c_void,
-) {
-    let ctx_inner = (*ctx).ctx.clone();
-    let id = cstr_to_rust(alert_id);
-    execute_async(callback, ctx, userdata, async move {
-        ctx_inner.disable(id).await?;
+        ctx_inner.update(&alert_item, enabled).await?;
         Ok(())
     });
 }

c/src/alert_context/types.rs

@@ -55,6 +55,30 @@ impl From<AlertItem> for CAlertItemOwned {
     }
 }
 
+impl CAlertItem {
+    /// Reconstruct a [`longbridge::alert::AlertItem`] from this C struct.
+    ///
+    /// # Safety
+    /// All pointer fields must be valid null-terminated C strings and the
+    /// `state` pointer must point to at least `num_state` valid `i32` values.
+    pub unsafe fn to_alert_item(&self) -> longbridge::alert::AlertItem {
+        use crate::types::cstr_to_rust;
+        let state = std::slice::from_raw_parts(self.state, self.num_state).to_vec();
+        let value_map_str = cstr_to_rust(self.value_map);
+        let value_map = serde_json::from_str(&value_map_str).unwrap_or(serde_json::Value::Null);
+        longbridge::alert::AlertItem {
+            id: cstr_to_rust(self.id),
+            indicator_id: cstr_to_rust(self.indicator_id),
+            enabled: self.enabled,
+            frequency: self.frequency,
+            scope: self.scope,
+            text: cstr_to_rust(self.text),
+            state,
+            value_map,
+        }
+    }
+}
+
 impl ToFFI for CAlertItemOwned {
     type FFIType = CAlertItem;
     fn to_ffi_type(&self) -> Self::FFIType {

java/src/alert_context.rs

@@ -9,9 +9,47 @@ use longbridge::{AlertContext, Config, alert::types::*};
 use crate::{
     async_util,
     error::jni_result,
-    types::{FromJValue, ObjectArray, get_field},
+    types::{ObjectArray, get_field},
 };
 
+/// Read a Java `AlertItem` object into a Rust [`longbridge::alert::AlertItem`].
+fn read_alert_item(
+    env: &mut JNIEnv,
+    item: &JObject,
+) -> jni::errors::Result<longbridge::alert::AlertItem> {
+    let id: String = get_field(env, item, "id")?;
+    let indicator_id: String = get_field(env, item, "indicatorId")?;
+    let enabled: bool = get_field(env, item, "enabled")?;
+    let frequency: i32 = get_field(env, item, "frequency")?;
+    let scope: i32 = get_field(env, item, "scope")?;
+    let text: String = get_field(env, item, "text")?;
+    // state: int[] — read as a Java int array
+    let state = unsafe {
+        let state_obj = env.get_field(item, "state", "[I")?.l()?;
+        if state_obj.is_null() {
+            Vec::new()
+        } else {
+            let arr = jni::objects::JIntArray::from(state_obj);
+            let elements = env
+                .get_array_elements::<jni::sys::jint>(&arr, jni::objects::ReleaseMode::CopyBack)?;
+            std::slice::from_raw_parts(elements.as_ptr(), elements.len()).to_vec()
+        }
+    };
+    // valueMap: JSON string
+    let value_map_str: String = get_field(env, item, "valueMap")?;
+    let value_map = serde_json::from_str(&value_map_str).unwrap_or(serde_json::Value::Null);
+    Ok(longbridge::alert::AlertItem {
+        id,
+        indicator_id,
+        enabled,
+        frequency,
+        scope,
+        text,
+        state,
+        value_map,
+    })
+}
+
 struct ContextObj {
     ctx: AlertContext,
 }
@@ -80,37 +118,20 @@ pub unsafe extern "system" fn Java_com_longbridge_SdkNative_alertContextAdd(
 }
 
 #[unsafe(no_mangle)]
-pub unsafe extern "system" fn Java_com_longbridge_SdkNative_alertContextEnable(
-    mut env: JNIEnv,
-    _class: JClass,
-    context: i64,
-    alert_id: JObject,
-    callback: JObject,
-) {
-    jni_result(&mut env, (), |env| {
-        let context = &*(context as *const ContextObj);
-        let id: String = FromJValue::from_jvalue(env, alert_id.into())?;
-        async_util::execute(env, callback, async move {
-            context.ctx.enable(id).await?;
-            Ok(())
-        })?;
-        Ok(())
-    })
-}
-
-#[unsafe(no_mangle)]
-pub unsafe extern "system" fn Java_com_longbridge_SdkNative_alertContextDisable(
+pub unsafe extern "system" fn Java_com_longbridge_SdkNative_alertContextUpdate(
     mut env: JNIEnv,
     _class: JClass,
     context: i64,
-    alert_id: JObject,
+    item: JObject,
+    enabled: jni::sys::jboolean,
     callback: JObject,
 ) {
     jni_result(&mut env, (), |env| {
         let context = &*(context as *const ContextObj);
-        let id: String = FromJValue::from_jvalue(env, alert_id.into())?;
+        let alert_item = read_alert_item(env, &item)?;
+        let enabled = enabled != 0;
         async_util::execute(env, callback, async move {
-            context.ctx.disable(id).await?;
+            context.ctx.update(&alert_item, enabled).await?;
             Ok(())
         })?;
         Ok(())

nodejs/src/alert/context.rs

@@ -45,17 +45,16 @@ impl AlertContext {
         Ok(())
     }
 
-    /// Enable a previously disabled price alert.
-    #[napi]
-    pub async fn enable(&self, alert_id: String) -> Result<()> {
-        self.ctx.enable(alert_id).await.map_err(ErrorNewType)?;
-        Ok(())
-    }
-
-    /// Disable a price alert without deleting it.
+    /// Update (enable or disable) a price alert.
+    ///
+    /// Pass the [`AlertItem`] obtained from [`list`](Self::list) and set
+    /// `enabled` to `true` to re-enable or `false` to disable.
     #[napi]
-    pub async fn disable(&self, alert_id: String) -> Result<()> {
-        self.ctx.disable(alert_id).await.map_err(ErrorNewType)?;
+    pub async fn update(&self, item: AlertItem, enabled: bool) -> Result<()> {
+        self.ctx
+            .update(&item.into(), enabled)
+            .await
+            .map_err(ErrorNewType)?;
         Ok(())
     }
 

nodejs/src/alert/types.rs

@@ -36,6 +36,21 @@ impl From<lb::AlertItem> for AlertItem {
     }
 }
 
+impl From<AlertItem> for lb::AlertItem {
+    fn from(v: AlertItem) -> Self {
+        Self {
+            id: v.id,
+            indicator_id: v.indicator_id,
+            enabled: v.enabled,
+            frequency: v.frequency,
+            scope: v.scope,
+            text: v.text,
+            state: v.state,
+            value_map: v.value_map,
+        }
+    }
+}
+
 /// Alert items for one security
 #[napi_derive::napi(object)]
 #[derive(Debug, Clone)]

python/src/alert/context.rs

@@ -33,12 +33,10 @@ impl AlertContext {
             .map_err(ErrorNewType)?;
         Ok(())
     }
-    fn enable(&self, alert_id: String) -> PyResult<()> {
-        self.ctx.enable(alert_id).map_err(ErrorNewType)?;
-        Ok(())
-    }
-    fn disable(&self, alert_id: String) -> PyResult<()> {
-        self.ctx.disable(alert_id).map_err(ErrorNewType)?;
+    fn update(&self, item: AlertItem, enabled: bool) -> PyResult<()> {
+        self.ctx
+            .update(item.into(), enabled)
+            .map_err(ErrorNewType)?;
         Ok(())
     }
     fn delete(&self, alert_ids: Vec<String>) -> PyResult<()> {

python/src/alert/types.rs

@@ -49,6 +49,21 @@ impl From<lb::AlertItem> for AlertItem {
     }
 }
 
+impl From<AlertItem> for lb::AlertItem {
+    fn from(v: AlertItem) -> Self {
+        Self {
+            id: v.id,
+            indicator_id: v.indicator_id,
+            enabled: v.enabled,
+            frequency: v.frequency,
+            scope: v.scope,
+            text: v.text,
+            state: v.state,
+            value_map: v.value_map.0,
+        }
+    }
+}
+
 #[pyclass(get_all)]
 #[derive(Debug, Clone)]
 pub(crate) struct AlertSymbolGroup {