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/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/config.cpp

@@ -119,4 +119,29 @@ Config::set_log_path(const std::string& path)
   return *this;
 }
 
+void
+Config::refresh_access_token(int64_t expired_at,
+                             AsyncCallback<NoContext, std::string> callback)
+{
+  lb_config_refresh_access_token(
+    config_,
+    expired_at,
+    [](auto res) {
+      auto callback_ptr =
+        callback::get_async_callback<NoContext, std::string>(res->userdata);
+      Status status(res->error);
+
+      if (status) {
+        std::string access_token = (const char*)res->data;
+
+        (*callback_ptr)(AsyncResult<NoContext, std::string>(
+          NoContext{}, std::move(status), &access_token));
+      } else {
+        (*callback_ptr)(
+          AsyncResult<NoContext, std::string>(NoContext{}, std::move(status), nullptr));
+      }
+    },
+    new AsyncCallback<NoContext, std::string>(callback));
+}
+
 } // namespace longbridge

cpp/src/http_client.cpp

@@ -69,7 +69,7 @@ HttpClient::request(
   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)
 {
   std::vector<lb_http_header_t> c_headers;
   if (headers) {
@@ -88,20 +88,20 @@ HttpClient::request(
     body ? body->c_str() : nullptr,
     [](auto res) {
       auto callback_ptr =
-        callback::get_async_callback<void*, HttpResult>(res->userdata);
+        callback::get_async_callback<NoContext, HttpResult>(res->userdata);
       Status status(res->error);
 
       if (status) {
         const lb_http_result_t* result = (const lb_http_result_t*)res->data;
         HttpResult http_res(lb_http_result_response_body(result));
-        (*callback_ptr)(AsyncResult<void*, HttpResult>(
-          nullptr, std::move(status), &http_res));
+        (*callback_ptr)(AsyncResult<NoContext, HttpResult>(
+          NoContext{}, std::move(status), &http_res));
       } else {
         (*callback_ptr)(
-          AsyncResult<void*, HttpResult>(nullptr, std::move(status), nullptr));
+          AsyncResult<NoContext, HttpResult>(NoContext{}, std::move(status), nullptr));
       }
     },
-    new AsyncCallback<void*, HttpResult>(callback));
+    new AsyncCallback<NoContext, HttpResult>(callback));
 }
 
 } // namespace longbridge