diff --git a/projects/llm_framework/main/src/main.cpp b/projects/llm_framework/main/src/main.cpp
index 1ded545..dd3c6e1 100644
--- a/projects/llm_framework/main/src/main.cpp
+++ b/projects/llm_framework/main/src/main.cpp
@@ -89,9 +89,14 @@ public:
         task_count_ = 1;
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (llm_channel->enstream_) {
             static int count = 0;
             nlohmann::json data_body;
@@ -109,10 +114,15 @@ public:
         }
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         const std::string *next_data = &data;
         int ret;
         std::string tmp_msg1;
@@ -157,10 +167,13 @@ public:
         if (ret == 0) {
             llm_channel->set_output(llm_task_obj->enoutput_);
             llm_channel->set_stream(llm_task_obj->enstream_);
-            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
-            llm_channel->subscriber_work_id("", std::bind(&llm_llm::task_user_data, this, llm_task_obj, llm_channel,
-                                                          std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
+            llm_channel->subscriber_work_id(
+                "",
+                std::bind(&llm_llm::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_[work_id_num] = llm_task_obj;
             send("None", "None", LLM_NO_ERROR, work_id);
             return 0;
diff --git a/projects/llm_framework/main_asr/src/main.cpp b/projects/llm_framework/main_asr/src/main.cpp
index d32024d..ecf0195 100644
--- a/projects/llm_framework/main_asr/src/main.cpp
+++ b/projects/llm_framework/main_asr/src/main.cpp
@@ -292,9 +292,14 @@ public:
             EVENT_TASK_PAUSE, std::bind(&llm_asr::_task_pause, this, std::placeholders::_1, std::placeholders::_2));
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::string tmp_msg1;
         const std::string *next_data = &data;
         if (finish) {
@@ -340,10 +345,15 @@ public:
         return 0;
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::string tmp_msg1;
         const std::string *next_data = &data;
         int ret;
@@ -398,8 +408,14 @@ public:
         event_queue_.enqueue(EVENT_TASK_PAUSE, work_id, "");
     }
 
-    void task_work(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel)
+    void task_work(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         llm_task_obj->kws_awake();
         if ((!audio_url_.empty()) && (llm_task_obj->audio_flage_ == false)) {
             llm_channel->subscriber(audio_url_,
@@ -408,9 +424,15 @@ public:
         }
     }
 
-    void kws_awake(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                   const std::string &object, const std::string &data)
+    void kws_awake(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                   const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::this_thread::sleep_for(std::chrono::milliseconds(llm_task_obj->awake_delay_));
         task_work(llm_task_obj, llm_channel);
     }
@@ -476,10 +498,9 @@ public:
             llm_channel->set_output(llm_task_obj->enoutput_);
             llm_channel->set_stream(llm_task_obj->enstream_);
             llm_task_obj->pause = std::bind(&llm_asr::task_pause, this, work_id, "");
-            SLOGI("llm_task_obj->enoutput_:%d", llm_task_obj->enoutput_);
-            SLOGI("llm_task_obj->enstream_:%d", llm_task_obj->enstream_);
-            llm_task_obj->set_output(std::bind(&llm_asr::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_asr::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
 
             for (const auto input : llm_task_obj->inputs_) {
                 if (input.find("sys") != std::string::npos) {
@@ -489,13 +510,15 @@ public:
                     llm_task_obj->audio_flage_ = true;
                 } else if (input.find("asr") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_asr::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_asr::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 } else if (input.find("kws") != std::string::npos) {
                     llm_task_obj->ensleep_ = true;
                     task_pause(work_id, "");
                     llm_channel->subscriber_work_id(
-                        input, std::bind(&llm_asr::kws_awake, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        input, std::bind(&llm_asr::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                          std::placeholders::_2));
                 }
             }
@@ -534,8 +557,10 @@ public:
             llm_task_obj->inputs_.push_back(data);
         } else if (data.find("kws") != std::string::npos) {
             llm_task_obj->ensleep_ = true;
-            ret = llm_channel->subscriber_work_id(data, std::bind(&llm_asr::kws_awake, this, llm_task_obj, llm_channel,
-                                                                  std::placeholders::_1, std::placeholders::_2));
+            ret                    = llm_channel->subscriber_work_id(
+                data,
+                std::bind(&llm_asr::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                             std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         }
         if (ret) {
diff --git a/projects/llm_framework/main_kws/src/main.cpp b/projects/llm_framework/main_kws/src/main.cpp
index b744029..cb0e7f0 100644
--- a/projects/llm_framework/main_kws/src/main.cpp
+++ b/projects/llm_framework/main_kws/src/main.cpp
@@ -314,16 +314,28 @@ public:
         }
     }
 
-    void task_pause(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel)
+    void task_pause(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                    const std::weak_ptr<llm_channel_obj> llm_channel_weak)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (llm_task_obj->audio_flage_) {
             if (!audio_url_.empty()) llm_channel->stop_subscriber(audio_url_);
             llm_task_obj->audio_flage_ = false;
         }
     }
 
-    void task_work(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel)
+    void task_work(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if ((!audio_url_.empty()) && (llm_task_obj->audio_flage_ == false)) {
             llm_channel->subscriber(audio_url_,
                                     std::bind(&llm_task::sys_pcm_on_data, llm_task_obj.get(), std::placeholders::_1));
@@ -363,10 +375,15 @@ public:
         send("None", "None", LLM_NO_ERROR, work_id);
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::string tmp_msg1;
         const std::string *next_data = &data;
         int ret;
@@ -426,7 +443,8 @@ public:
                     llm_task_obj->audio_flage_ = true;
                 } else if (input.find("kws") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_kws::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_kws::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 }
             }
diff --git a/projects/llm_framework/main_llm/src/main.cpp b/projects/llm_framework/main_llm/src/main.cpp
index 5430be9..078d2f8 100644
--- a/projects/llm_framework/main_llm/src/main.cpp
+++ b/projects/llm_framework/main_llm/src/main.cpp
@@ -152,7 +152,11 @@ public:
                 }
             };
             lLaMa_ = std::make_unique<LLM>();
-            if (!lLaMa_->Init(mode_config_)) return -2;
+            if (!lLaMa_->Init(mode_config_)) {
+                lLaMa_->Deinit();
+                lLaMa_.reset();
+                return -2;
+            }
 
         } catch (...) {
             SLOGE("config false");
@@ -216,6 +220,9 @@ public:
 
     ~llm_task()
     {
+        if (lLaMa_) {
+            lLaMa_->Deinit();
+        }
     }
 };
 
@@ -248,9 +255,14 @@ public:
         repeat_event(1000, std::bind(&llm_llm::_load_config, this));
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         SLOGI("send:%s", data.c_str());
         if (llm_channel->enstream_) {
             static int count = 0;
@@ -271,10 +283,15 @@ public:
         }
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         const std::string *next_data = &data;
         int ret;
         std::string tmp_msg1;
@@ -294,9 +311,15 @@ public:
         llm_task_obj->inference((*next_data));
     }
 
-    void task_asr_data(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                       const std::string &object, const std::string &data)
+    void task_asr_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                       const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                       const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (object.find("stream") != std::string::npos) {
             if (sample_json_str_get(data, "finish") == "true") {
                 llm_task_obj->inference(sample_json_str_get(data, "delta"));
@@ -306,9 +329,15 @@ public:
         }
     }
 
-    void kws_awake(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                   const std::string &object, const std::string &data)
+    void kws_awake(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                   const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         llm_task_obj->lLaMa_->Stop();
     }
 
@@ -341,21 +370,25 @@ public:
             llm_channel->set_output(llm_task_obj->enoutput_);
             llm_channel->set_stream(llm_task_obj->enstream_);
 
-            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
 
             for (const auto input : llm_task_obj->inputs_) {
                 if (input.find("llm") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_llm::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_llm::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 } else if (input.find("asr") != std::string::npos) {
-                    llm_channel->subscriber_work_id(input,
-                                                    std::bind(&llm_llm::task_asr_data, this, llm_task_obj, llm_channel,
-                                                              std::placeholders::_1, std::placeholders::_2));
+                    llm_channel->subscriber_work_id(
+                        input, std::bind(&llm_llm::task_asr_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                         std::placeholders::_2));
                 } else if (input.find("kws") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        input, std::bind(&llm_llm::kws_awake, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        input, std::bind(&llm_llm::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                          std::placeholders::_2));
                 }
             }
@@ -388,12 +421,15 @@ public:
         auto llm_task_obj = llm_task_[work_id_num];
         if (data.find("asr") != std::string::npos) {
             ret = llm_channel->subscriber_work_id(
-                data, std::bind(&llm_llm::task_asr_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
-                                std::placeholders::_2));
+                data,
+                std::bind(&llm_llm::task_asr_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         } else if (data.find("kws") != std::string::npos) {
-            ret = llm_channel->subscriber_work_id(data, std::bind(&llm_llm::kws_awake, this, llm_task_obj, llm_channel,
-                                                                  std::placeholders::_1, std::placeholders::_2));
+            ret = llm_channel->subscriber_work_id(
+                data,
+                std::bind(&llm_llm::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         }
         if (ret) {
diff --git a/projects/llm_framework/main_melotts/src/main.cpp b/projects/llm_framework/main_melotts/src/main.cpp
index af8ab43..6bfa568 100644
--- a/projects/llm_framework/main_melotts/src/main.cpp
+++ b/projects/llm_framework/main_melotts/src/main.cpp
@@ -85,6 +85,7 @@ public:
     task_callback_t out_callback_;
     bool enaudio_;
     int awake_delay_ = 1000;
+    std::string tts_string_stream_buff;
 
     bool parse_config(const nlohmann::json &config_body)
     {
@@ -371,9 +372,14 @@ public:
         repeat_event(1000, std::bind(&llm_tts::_load_config, this));
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::string base64_data;
         int len = encode_base64(data, base64_data);
         if (llm_channel->enstream_) {
@@ -395,12 +401,25 @@ public:
         }
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    bool is_breakpoint(const std::string &cutf8)
+    {
+        if (cutf8 == "，" || cutf8 == "、" || cutf8 == "," || cutf8 == "。" || cutf8 == "." || cutf8 == "!" ||
+            cutf8 == "！" || cutf8 == "?" || cutf8 == "？" || cutf8 == ";" || cutf8 == "；")
+            return true;
+        else
+            return false;
+    }
+
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (data.empty() || (data == "None")) return;
-        static std::string faster_stream_buff;
         nlohmann::json error_body;
         const std::string *next_data = &data;
         bool enbase64                = (object.find("base64") == std::string::npos) ? false : true;
@@ -424,25 +443,24 @@ public:
         }
         std::vector<std::string> tmp_data = llm_task_obj->lexicon_->splitEachChar((*next_data));
         for (auto cutf8 : tmp_data) {
-            if (cutf8 == "，" || cutf8 == "、" || cutf8 == "," || cutf8 == "。" || cutf8 == "." || cutf8 == "!" ||
-                cutf8 == "！" || cutf8 == "?" || cutf8 == "？" || cutf8 == ";" || cutf8 == "；") {
-                faster_stream_buff += cutf8;
-                ret = llm_task_obj->TTS(faster_stream_buff);
-                faster_stream_buff.clear();
+            if (is_breakpoint(cutf8)) {
+                llm_task_obj->tts_string_stream_buff += cutf8;
+                ret = llm_task_obj->TTS(llm_task_obj->tts_string_stream_buff);
+                llm_task_obj->tts_string_stream_buff.clear();
                 if (ret) {
                     error_body["code"]    = -11;
                     error_body["message"] = "Model run failed.";
                     llm_channel->send("None", "None", error_body, llm_channel->work_id_);
                 }
             } else {
-                faster_stream_buff += cutf8;
+                llm_task_obj->tts_string_stream_buff += cutf8;
             }
         }
         if (finish_flage) {
-            if (!faster_stream_buff.empty()) {
-                faster_stream_buff.push_back('.');
-                ret = llm_task_obj->TTS(faster_stream_buff);
-                faster_stream_buff.clear();
+            if (!llm_task_obj->tts_string_stream_buff.empty()) {
+                llm_task_obj->tts_string_stream_buff.push_back('.');
+                ret = llm_task_obj->TTS(llm_task_obj->tts_string_stream_buff);
+                llm_task_obj->tts_string_stream_buff.clear();
                 if (ret) {
                     error_body["code"]    = -11;
                     error_body["message"] = "Model run failed.";
@@ -452,11 +470,18 @@ public:
         }
     }
 
-    void kws_awake(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                   const std::string &object, const std::string &data)
+    void kws_awake(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                   const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (llm_task_obj->superior_flage_) {
             llm_channel->stop_subscriber_work_id(llm_task_obj->superior_id_);
+            llm_task_obj->tts_string_stream_buff.clear();
             if (llm_task_obj->response_format_.find("sys") != std::string::npos) {
                 unit_call("audio", "queue_play_stop", data);
             }
@@ -464,9 +489,10 @@ public:
             if (llm_task_obj->response_format_.find("sys") != std::string::npos) {
                 unit_call("audio", "play_stop", data);
             }
-            llm_channel->subscriber_work_id(llm_task_obj->superior_id_,
-                                            std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel,
-                                                      std::placeholders::_1, std::placeholders::_2));
+            llm_channel->subscriber_work_id(
+                llm_task_obj->superior_id_,
+                std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
         }
     }
 
@@ -498,22 +524,26 @@ public:
             llm_channel->set_stream(llm_task_obj->enstream_);
             SLOGI("llm_task_obj->enoutput_:%d", llm_task_obj->enoutput_);
             SLOGI("llm_task_obj->enstream_:%d", llm_task_obj->enstream_);
-            llm_task_obj->set_output(std::bind(&llm_tts::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_tts::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
             for (const auto input : llm_task_obj->inputs_) {
                 if (input.find("tts") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 } else if ((input.find("llm") != std::string::npos) || (input.find("vlm") != std::string::npos)) {
-                    llm_channel->subscriber_work_id(input,
-                                                    std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel,
-                                                              std::placeholders::_1, std::placeholders::_2));
+                    llm_channel->subscriber_work_id(
+                        input, std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                         std::placeholders::_2));
                     llm_task_obj->superior_id_    = input;
                     llm_task_obj->superior_flage_ = true;
                 } else if (input.find("kws") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        input, std::bind(&llm_tts::kws_awake, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        input, std::bind(&llm_tts::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                          std::placeholders::_2));
                 }
             }
@@ -546,14 +576,17 @@ public:
         auto llm_task_obj = llm_task_[work_id_num];
         if ((data.find("llm") != std::string::npos) || (data.find("vlm") != std::string::npos)) {
             ret = llm_channel->subscriber_work_id(
-                data, std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
-                                std::placeholders::_2));
+                data,
+                std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->superior_id_    = data;
             llm_task_obj->superior_flage_ = true;
             llm_task_obj->inputs_.push_back(data);
         } else if (data.find("kws") != std::string::npos) {
-            ret = llm_channel->subscriber_work_id(data, std::bind(&llm_tts::kws_awake, this, llm_task_obj, llm_channel,
-                                                                  std::placeholders::_1, std::placeholders::_2));
+            ret = llm_channel->subscriber_work_id(
+                data,
+                std::bind(&llm_tts::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         }
         if (ret) {
diff --git a/projects/llm_framework/main_tts/src/main.cpp b/projects/llm_framework/main_tts/src/main.cpp
index 581d056..50e38c0 100644
--- a/projects/llm_framework/main_tts/src/main.cpp
+++ b/projects/llm_framework/main_tts/src/main.cpp
@@ -194,9 +194,14 @@ public:
         repeat_event(1000, std::bind(&llm_tts::_load_config, this));
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         std::string base64_data;
         int len = encode_base64(data, base64_data);
         if (llm_channel->enstream_) {
@@ -241,10 +246,15 @@ public:
         return words;
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (data.empty() || (data == "None")) return;
         static std::string faster_stream_buff;
         nlohmann::json error_body;
@@ -298,9 +308,15 @@ public:
         }
     }
 
-    void kws_awake(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                   const std::string &object, const std::string &data)
+    void kws_awake(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                   const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (llm_task_obj->superior_flage_) {
             llm_channel->stop_subscriber_work_id(llm_task_obj->superior_id_);
             if (llm_task_obj->response_format_.find("sys") != std::string::npos) {
@@ -310,9 +326,10 @@ public:
             if (llm_task_obj->response_format_.find("sys") != std::string::npos) {
                 unit_call("audio", "play_stop", data);
             }
-            llm_channel->subscriber_work_id(llm_task_obj->superior_id_,
-                                            std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel,
-                                                      std::placeholders::_1, std::placeholders::_2));
+            llm_channel->subscriber_work_id(
+                llm_task_obj->superior_id_,
+                std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
         }
     }
 
@@ -344,22 +361,26 @@ public:
             llm_channel->set_stream(llm_task_obj->enstream_);
             SLOGI("llm_task_obj->enoutput_:%d", llm_task_obj->enoutput_);
             SLOGI("llm_task_obj->enstream_:%d", llm_task_obj->enstream_);
-            llm_task_obj->set_output(std::bind(&llm_tts::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_tts::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
             for (const auto input : llm_task_obj->inputs_) {
                 if (input.find("tts") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 } else if ((input.find("llm") != std::string::npos) || (input.find("vlm") != std::string::npos)) {
-                    llm_channel->subscriber_work_id(input,
-                                                    std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel,
-                                                              std::placeholders::_1, std::placeholders::_2));
+                    llm_channel->subscriber_work_id(
+                        input, std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                         std::placeholders::_2));
                     llm_task_obj->superior_id_    = input;
                     llm_task_obj->superior_flage_ = true;
                 } else if (input.find("kws") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        input, std::bind(&llm_tts::kws_awake, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        input, std::bind(&llm_tts::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                          std::placeholders::_2));
                 }
             }
@@ -392,14 +413,17 @@ public:
         auto llm_task_obj = llm_task_[work_id_num];
         if ((data.find("llm") != std::string::npos) || (data.find("vlm") != std::string::npos)) {
             ret = llm_channel->subscriber_work_id(
-                data, std::bind(&llm_tts::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
-                                std::placeholders::_2));
+                data,
+                std::bind(&llm_tts::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->superior_id_    = data;
             llm_task_obj->superior_flage_ = true;
             llm_task_obj->inputs_.push_back(data);
         } else if (data.find("kws") != std::string::npos) {
-            ret = llm_channel->subscriber_work_id(data, std::bind(&llm_tts::kws_awake, this, llm_task_obj, llm_channel,
-                                                                  std::placeholders::_1, std::placeholders::_2));
+            ret = llm_channel->subscriber_work_id(
+                data,
+                std::bind(&llm_tts::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         }
         if (ret) {
diff --git a/projects/llm_framework/main_vlm/src/main.cpp b/projects/llm_framework/main_vlm/src/main.cpp
index 1fbeb5b..62b7801 100644
--- a/projects/llm_framework/main_vlm/src/main.cpp
+++ b/projects/llm_framework/main_vlm/src/main.cpp
@@ -270,9 +270,14 @@ public:
         repeat_event(1000, std::bind(&llm_llm::_load_config, this));
     }
 
-    void task_output(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                     const std::string &data, bool finish)
+    void task_output(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                     const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &data, bool finish)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         SLOGI("send:%s", data.c_str());
         if (llm_channel->enstream_) {
             static int count = 0;
@@ -293,10 +298,15 @@ public:
         }
     }
 
-    void task_user_data(const std::shared_ptr<llm_task> llm_task_obj,
-                        const std::shared_ptr<llm_channel_obj> llm_channel, const std::string &object,
+    void task_user_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                        const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
                         const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         const std::string *next_data = &data;
         int ret;
         std::string tmp_msg1;
@@ -320,9 +330,15 @@ public:
         llm_task_obj->inference((*next_data));
     }
 
-    void task_asr_data(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                       const std::string &object, const std::string &data)
+    void task_asr_data(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                       const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                       const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         if (object.find("stream") != std::string::npos) {
             if (sample_json_str_get(data, "finish") == "true") {
                 llm_task_obj->inference(sample_json_str_get(data, "delta"));
@@ -332,9 +348,15 @@ public:
         }
     }
 
-    void kws_awake(const std::shared_ptr<llm_task> llm_task_obj, const std::shared_ptr<llm_channel_obj> llm_channel,
-                   const std::string &object, const std::string &data)
+    void kws_awake(const std::weak_ptr<llm_task> llm_task_obj_weak,
+                   const std::weak_ptr<llm_channel_obj> llm_channel_weak, const std::string &object,
+                   const std::string &data)
     {
+        auto llm_task_obj = llm_task_obj_weak.lock();
+        auto llm_channel  = llm_channel_weak.lock();
+        if (!(llm_task_obj && llm_channel)) {
+            return;
+        }
         llm_task_obj->lLaMa_->Stop();
     }
 
@@ -367,21 +389,25 @@ public:
             llm_channel->set_output(llm_task_obj->enoutput_);
             llm_channel->set_stream(llm_task_obj->enstream_);
 
-            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, llm_task_obj, llm_channel,
-                                               std::placeholders::_1, std::placeholders::_2));
+            llm_task_obj->set_output(std::bind(&llm_llm::task_output, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                               std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                               std::placeholders::_2));
 
             for (const auto input : llm_task_obj->inputs_) {
                 if (input.find("vlm") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        "", std::bind(&llm_llm::task_user_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        "", std::bind(&llm_llm::task_user_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                      std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                       std::placeholders::_2));
                 } else if (input.find("asr") != std::string::npos) {
-                    llm_channel->subscriber_work_id(input,
-                                                    std::bind(&llm_llm::task_asr_data, this, llm_task_obj, llm_channel,
-                                                              std::placeholders::_1, std::placeholders::_2));
+                    llm_channel->subscriber_work_id(
+                        input, std::bind(&llm_llm::task_asr_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
+                                         std::placeholders::_2));
                 } else if (input.find("kws") != std::string::npos) {
                     llm_channel->subscriber_work_id(
-                        input, std::bind(&llm_llm::kws_awake, this, llm_task_obj, llm_channel, std::placeholders::_1,
+                        input, std::bind(&llm_llm::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                                         std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1,
                                          std::placeholders::_2));
                 }
             }
@@ -414,12 +440,15 @@ public:
         auto llm_task_obj = llm_task_[work_id_num];
         if (data.find("asr") != std::string::npos) {
             ret = llm_channel->subscriber_work_id(
-                data, std::bind(&llm_llm::task_asr_data, this, llm_task_obj, llm_channel, std::placeholders::_1,
-                                std::placeholders::_2));
+                data,
+                std::bind(&llm_llm::task_asr_data, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         } else if (data.find("kws") != std::string::npos) {
-            ret = llm_channel->subscriber_work_id(data, std::bind(&llm_llm::kws_awake, this, llm_task_obj, llm_channel,
-                                                                  std::placeholders::_1, std::placeholders::_2));
+            ret = llm_channel->subscriber_work_id(
+                data,
+                std::bind(&llm_llm::kws_awake, this, std::weak_ptr<llm_task>(llm_task_obj),
+                          std::weak_ptr<llm_channel_obj>(llm_channel), std::placeholders::_1, std::placeholders::_2));
             llm_task_obj->inputs_.push_back(data);
         }
         if (ret) {