fix(alert): resolve merge conflicts with main

- blocking/alert.rs: keep update() replacing enable/disable
- python/alert/types.rs: add manual FromPyObject impl for AlertItem
  (needed since skip_from_py_object prevents auto-derivation)
  and adopt skip_from_py_object for AlertSymbolGroup/AlertList from main
- c/csrc/include/longbridge.h: accept auto-merged version

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

Author: hogan-yuan

CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-# [Unreleased]
+# [4.0.6]
 
 ## Added
 
@@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **All languages:** `QuoteContext` gains `short_positions`, `option_volume`, `option_volume_daily`, and `update_pinned`.
 - **All languages:** `ContentContext` gains `topic_detail`, `list_topic_replies`, and `create_topic_reply`.
 - **Rust:** `Config::header(key, value)` builder method for injecting custom HTTP/WebSocket headers.
+- **All languages (Rust, Python, Node.js, Java, C, C++):** Restore `Config::refresh_access_token` (and `refresh_access_token_blocking` in Rust). Refreshes the access token via the Longbridge token-refresh API. Only available with **Legacy API Key** authentication (`Config::from_apikey`); not supported in OAuth 2.0 mode.
 
 ## Changed
 

Cargo.toml

@@ -3,20 +3,20 @@ resolver = "3"
 members = ["rust", "python", "nodejs", "java", "c"]
 
 [workspace.package]
-version = "4.0.5"
+version = "4.0.6"
 edition = "2024"
 
 [profile.release]
 lto = true
 
 [workspace.dependencies]
-longbridge-geo = { path = "rust/crates/geo", version = "4.0.5" }
-longbridge-wscli = { path = "rust/crates/wsclient", version = "4.0.5" }
-longbridge-httpcli = { path = "rust/crates/httpclient", version = "4.0.5" }
-longbridge-proto = { path = "rust/crates/proto", version = "4.0.5" }
-longbridge-candlesticks = { path = "rust/crates/candlesticks", version = "4.0.5" }
-longbridge-oauth = { path = "rust/crates/oauth", version = "4.0.5" }
-longbridge = { path = "rust", version = "4.0.5" }
+longbridge-geo = { path = "rust/crates/geo", version = "4.0.6" }
+longbridge-wscli = { path = "rust/crates/wsclient", version = "4.0.6" }
+longbridge-httpcli = { path = "rust/crates/httpclient", version = "4.0.6" }
+longbridge-proto = { path = "rust/crates/proto", version = "4.0.6" }
+longbridge-candlesticks = { path = "rust/crates/candlesticks", version = "4.0.6" }
+longbridge-oauth = { path = "rust/crates/oauth", version = "4.0.6" }
+longbridge = { path = "rust", version = "4.0.6" }
 
 tokio = "1.47.1"
 tokio-tungstenite = "0.27.0"

c/csrc/include/longbridge.h

@@ -7877,31 +7877,19 @@ void lb_alert_context_add(const struct lb_alert_context_t *ctx,
                           void *userdata);
 
 /**
- * Enable a price alert.
+ * Update (enable or disable) a price alert.
  *
  * `item` must point to a valid [`CAlertItem`] obtained from
- * [`lb_alert_context_list`]. All fields are read before the function
+ * [`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.
  */
-void lb_alert_context_enable(const struct lb_alert_context_t *ctx,
+void lb_alert_context_update(const struct lb_alert_context_t *ctx,
                              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 struct lb_alert_item_t *item,
-                              lb_async_callback_t callback,
-                              void *userdata);
-
 /**
  * Delete price alerts. alert_ids: array of alert ID strings, num_ids: count.
  */
@@ -8087,6 +8075,26 @@ void lb_config_disable_print_quote_packages(struct lb_config_t *config);
  */
 void lb_config_set_log_path(struct lb_config_t *config, const char *log_path);
 
+/**
+ * Gets a new `access_token`
+ *
+ * This function is only available when using **Legacy API Key**
+ * authentication (i.e. `lb_config_from_apikey`). It is not supported for
+ * OAuth 2.0 mode.
+ *
+ * @param config      Config object
+ * @param expired_at  Unix timestamp for token expiry. Pass `0` to use the
+ *                    default (90 days from now).
+ * @param callback    Callback function; on success `res->data` is a
+ *                    `const char*` access token (valid only within the
+ *                    callback body).
+ * @param userdata    Opaque pointer forwarded to the callback
+ */
+void lb_config_refresh_access_token(struct lb_config_t *config,
+                                    int64_t expired_at,
+                                    lb_async_callback_t callback,
+                                    void *userdata);
+
 /**
  * Free the config object
  */

c/src/config.rs

@@ -1,11 +1,17 @@
-use std::{ffi::CStr, os::raw::c_char, ptr};
+use std::{
+    ffi::{CStr, c_void},
+    os::raw::c_char,
+    ptr,
+};
 
 use longbridge::Config;
+use time::OffsetDateTime;
 
 use crate::{
+    async_call::{CAsyncCallback, execute_async},
     error::{CError, set_error},
     oauth::COAuth,
-    types::{CLanguage, CPushCandlestickMode},
+    types::{CLanguage, CPushCandlestickMode, CString},
 };
 
 /// Configuration options for Longbridge SDK
@@ -175,6 +181,40 @@ pub unsafe extern "C" fn lb_config_set_log_path(config: *mut CConfig, log_path:
     (*config).0.set_log_path(path);
 }
 
+/// Gets a new `access_token`
+///
+/// This function is only available when using **Legacy API Key**
+/// authentication (i.e. `lb_config_from_apikey`). It is not supported for
+/// OAuth 2.0 mode.
+///
+/// @param config      Config object
+/// @param expired_at  Unix timestamp for token expiry. Pass `0` to use the
+///                    default (90 days from now).
+/// @param callback    Callback function; on success `res->data` is a
+///                    `const char*` access token (valid only within the
+///                    callback body).
+/// @param userdata    Opaque pointer forwarded to the callback
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn lb_config_refresh_access_token(
+    config: *mut CConfig,
+    expired_at: i64,
+    callback: CAsyncCallback,
+    userdata: *mut c_void,
+) {
+    let config = &mut (*config).0;
+    execute_async::<c_void, _, _>(callback, std::ptr::null(), userdata, async move {
+        let token: CString = config
+            .refresh_access_token(if expired_at == 0 {
+                None
+            } else {
+                Some(OffsetDateTime::from_unix_timestamp(expired_at).unwrap())
+            })
+            .await?
+            .into();
+        Ok(token)
+    });
+}
+
 /// Free the config object
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn lb_config_free(config: *mut CConfig) {

cpp/include/alert_context.hpp

@@ -45,12 +45,10 @@ class AlertContext {
   void add(const std::string& symbol, AlertCondition condition,
            const std::string& trigger_value, AlertFrequency frequency,
            AsyncCallback<AlertContext, void> callback) const;
-  /// Enable a price alert by alert_id.
-  void enable(const std::string& alert_id,
+  /// Update (enable or disable) a price alert.
+  /// Set item.enabled before calling to choose the new state.
+  void update(const AlertItem& item,
               AsyncCallback<AlertContext, void> callback) const;
-  /// Disable a price alert by alert_id.
-  void disable(const std::string& alert_id,
-               AsyncCallback<AlertContext, void> callback) const;
 };
 
 } // namespace alert

cpp/include/async_result.hpp

@@ -47,4 +47,9 @@ struct AsyncResult
 template<typename Ctx, typename T>
 using AsyncCallback = std::function<void(AsyncResult<Ctx, T>)>;
 
+/// Placeholder context type for async operations that have no meaningful
+/// context (analogous to `()` in Rust).
+struct NoContext
+{};
+
 } // namespace longbridge

cpp/include/config.hpp

@@ -89,6 +89,18 @@ class Config
 
   /// Set the log file path
   Config& set_log_path(const std::string& path);
+
+  /// Gets a new `access_token`
+  ///
+  /// This method is only available when using **Legacy API Key**
+  /// authentication (i.e. `Config::from_apikey`). It is not supported for
+  /// OAuth 2.0 mode.
+  ///
+  /// @param expired_at  Unix timestamp for token expiry. Pass `0` to use the
+  ///                    default (90 days from now).
+  /// @param callback    Callback invoked with the new access token string.
+  void refresh_access_token(int64_t expired_at,
+                            AsyncCallback<NoContext, std::string> callback);
 };
 
 } // namespace longbridge

cpp/include/http_client.hpp

@@ -69,7 +69,7 @@ class HttpClient
                const std::string& path,
                const std::optional<std::map<std::string, std::string>>& headers,
                const std::optional<std::string>& body,
-               AsyncCallback<void*, HttpResult> callback);
+               AsyncCallback<NoContext, HttpResult> callback);
 };
 
 }

cpp/include/oauth.hpp

@@ -54,7 +54,7 @@ class OAuthBuilder
   /// @param open_url  Called with the authorization URL during the auth flow
   /// @param callback  Invoked on completion; result data is `OAuth*`
   void build(std::function<void(const std::string&)> open_url,
-             AsyncCallback<void*, OAuth> callback);
+             AsyncCallback<NoContext, OAuth> callback);
 };
 
 } // namespace longbridge

cpp/src/alert_context.cpp

@@ -8,8 +8,7 @@ void lb_alert_context_retain(const lb_alert_context_t*);
 void lb_alert_context_release(const lb_alert_context_t*);
 void lb_alert_context_list(const lb_alert_context_t*, lb_async_callback_t, void*);
 void lb_alert_context_add(const lb_alert_context_t*, const char*, lb_alert_condition_t, const char*, lb_alert_frequency_t, lb_async_callback_t, void*);
-void lb_alert_context_enable(const lb_alert_context_t*, const char*, lb_async_callback_t, void*);
-void lb_alert_context_disable(const lb_alert_context_t*, const char*, lb_async_callback_t, void*);
+void lb_alert_context_update(const lb_alert_context_t*, const lb_alert_item_t*, lb_async_callback_t, void*);
 }
 
 namespace longbridge {
@@ -50,20 +49,21 @@ void AlertContext::add(const std::string& symbol, AlertCondition condition,
         }, new AsyncCallback<AlertContext, void>(callback));
 }
 
-void AlertContext::enable(const std::string& alert_id,
+void AlertContext::update(const AlertItem& item,
                           AsyncCallback<AlertContext, void> callback) const {
-    lb_alert_context_enable(ctx_, alert_id.c_str(),
-        [](auto res) {
-            auto cb = callback::get_async_callback<AlertContext, void>(res->userdata);
-            AlertContext fctx((const lb_alert_context_t*)res->ctx);
-            Status status(res->error);
-            (*cb)(AsyncResult<AlertContext, void>(fctx, std::move(status), nullptr));
-        }, new AsyncCallback<AlertContext, void>(callback));
-}
-
-void AlertContext::disable(const std::string& alert_id,
-                           AsyncCallback<AlertContext, void> callback) const {
-    lb_alert_context_disable(ctx_, alert_id.c_str(),
+    // Build a lb_alert_item_t from the C++ AlertItem to pass to the C layer.
+    std::vector<int32_t> state_copy = item.state;
+    lb_alert_item_t c_item{};
+    c_item.id            = item.id.c_str();
+    c_item.indicator_id  = item.indicator_id.c_str();
+    c_item.enabled       = item.enabled;
+    c_item.frequency     = item.frequency;
+    c_item.scope         = item.scope;
+    c_item.text          = item.text.c_str();
+    c_item.state         = state_copy.data();
+    c_item.num_state     = state_copy.size();
+    c_item.value_map     = item.value_map.c_str();
+    lb_alert_context_update(ctx_, &c_item,
         [](auto res) {
             auto cb = callback::get_async_callback<AlertContext, void>(res->userdata);
             AlertContext fctx((const lb_alert_context_t*)res->ctx);