kweaver-dolphin 0.1.0__tar.gz → 0.2.0__tar.gz

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kweaver-dolphin
-Version: 0.1.0
+Version: 0.2.0
 Summary: Dolphin Language - An intelligent agent framework
 Author-email: AnyData <contact@anydata.com>
 License: Apache 2.0

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kweaver-dolphin"
-version = "0.1.0"
+version = "0.2.0"
 description = "Dolphin Language - An intelligent agent framework"
 authors = [
     {name = "AnyData", email = "contact@anydata.com"}

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/cli/ui/console.py

@@ -1738,14 +1738,14 @@ class ConsoleUI:
         
         # Block type icons and colors
         block_icons = {
-            "explore": ("🔍", Theme.SECONDARY),
-            "prompt": ("💬", Theme.SUCCESS),
-            "judge": ("⚖️", Theme.WARNING),
-            "assign": ("📝", Theme.PRIMARY),
-            "tool": ("⚡", Theme.ACCENT),
+            "explore": ("[?]", Theme.SECONDARY),
+            "prompt": ("[>]", Theme.SUCCESS),
+            "judge": ("[J]", Theme.WARNING),
+            "assign": ("[=]", Theme.PRIMARY),
+            "tool": ("[*]", Theme.ACCENT),
         }
         
-        icon, color = block_icons.get(block_type.lower(), ("📦", Theme.LABEL))
+        icon, color = block_icons.get(block_type.lower(), ("[X]", Theme.LABEL))
         
         # Build output line
         header = f"{color}{Theme.BOLD}{icon} {block_type.upper()}{Theme.RESET}"

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/agent/base_agent.py

@@ -406,12 +406,34 @@ class BaseAgent(ABC):
                             AgentState.PAUSED, "Agent paused due to tool interrupt"
                         )
                     
+                    # Map interrupt_type: "tool_interrupt" (internal) -> "tool_confirmation" (API)
+                    api_interrupt_type = self._pause_type.value
+                    if run_result.resume_handle:
+                        internal_type = run_result.resume_handle.interrupt_type
+                        if internal_type == "tool_interrupt":
+                            api_interrupt_type = "tool_confirmation"
+                        elif internal_type == "user_interrupt":
+                            api_interrupt_type = "user_interrupt"
+                    
                     # 统一输出格式：status 固定为 "interrupted"，通过 interrupt_type 区分
-                    yield {
+                    interrupt_response = {
                         "status": "interrupted",
                         "handle": run_result.resume_handle,
-                        "interrupt_type": run_result.resume_handle.interrupt_type if run_result.resume_handle else self._pause_type.value,
+                        "interrupt_type": api_interrupt_type,
                     }
+                    
+                    # For ToolInterrupt, include tool data from frame.error (same as step mode)
+                    if run_result.is_tool_interrupted and self._current_frame and self._current_frame.error:
+                        frame_error = self._current_frame.error
+                        if frame_error.get("error_type") == "ToolInterrupt":
+                            interrupt_response["data"] = {
+                                "tool_name": frame_error.get("tool_name", ""),
+                                "tool_description": "",  # Can be added if available
+                                "tool_args": frame_error.get("tool_args", []),
+                                "interrupt_config": frame_error.get("tool_config", {}),
+                            }
+                    
+                    yield interrupt_response
                     return
 
                 elif run_result.is_completed:
@@ -463,11 +485,32 @@ class BaseAgent(ABC):
                             )
                         
                         # 统一输出格式
-                        yield {
+                        # Map interrupt_type: "tool_interrupt" (internal) -> "tool_confirmation" (API)
+                        api_interrupt_type = self._pause_type.value
+                        if step_result.resume_handle:
+                            internal_type = step_result.resume_handle.interrupt_type
+                            if internal_type == "tool_interrupt":
+                                api_interrupt_type = "tool_confirmation"
+                            elif internal_type == "user_interrupt":
+                                api_interrupt_type = "user_interrupt"
+                        
+                        interrupt_response = {
                             "status": "interrupted",
                             "handle": step_result.resume_handle,
-                            "interrupt_type": step_result.resume_handle.interrupt_type if step_result.resume_handle else self._pause_type.value,
+                            "interrupt_type": api_interrupt_type,
                         }
+                        
+                        # For ToolInterrupt, include tool data from frame.error
+                        if step_result.is_tool_interrupted and self._current_frame and self._current_frame.error:
+                            frame_error = self._current_frame.error
+                            if frame_error.get("error_type") == "ToolInterrupt":
+                                interrupt_response["data"] = {
+                                    "tool_name": frame_error.get("tool_name", ""),
+                                    "tool_args": frame_error.get("tool_args", []),
+                                    "tool_config": frame_error.get("tool_config", {}),
+                                }
+                        
+                        yield interrupt_response
                         break
 
                     elif step_result.is_completed:
@@ -568,11 +611,22 @@ class BaseAgent(ABC):
         """Pause logic implemented by subclasses"""
         pass
 
-    async def resume(self, updates: Optional[Dict[str, Any]] = None) -> bool:
+    async def resume(
+        self, 
+        updates: Optional[Dict[str, Any]] = None,
+        resume_handle=None  # External resume handle (for stateless scenarios)
+    ) -> bool:
         """Resume Agent (based on coroutine)
 
         Args:
             updates: Variable updates to inject (used to resume from tool interruption)
+            resume_handle: Optional external resume handle (for web apps/stateless scenarios)
+                          If provided, will override internal _resume_handle
+                          This allows resuming across different requests/processes
+
+        Usage Scenarios:
+            1. Stateful (same process): resume(updates) - uses internal _resume_handle
+            2. Stateless (web apps): resume(updates, resume_handle) - uses external handle
         """
         if self.state != AgentState.PAUSED:
             raise AgentLifecycleException(
@@ -580,9 +634,18 @@ class BaseAgent(ABC):
             )
 
         try:
-            # Resume coroutine execution
-            if self._resume_handle is not None:
+            # Use external handle if provided (for stateless scenarios like web apps)
+            # Otherwise use internal handle (for stateful scenarios like testing)
+            handle_to_use = resume_handle if resume_handle is not None else self._resume_handle
+            
+            if handle_to_use is not None:
+                # Temporarily set internal handle for _on_resume_coroutine to use
+                original_handle = self._resume_handle
+                self._resume_handle = handle_to_use
+                
                 self._current_frame = await self._on_resume_coroutine(updates)
+                
+                # Clear handles after resume
                 self._resume_handle = None
                 self._pause_type = None
 

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/basic_code_block.py

@@ -1133,6 +1133,7 @@ class BasicCodeBlock:
         skill_params_json: Dict[str, Any] = {},
         props=None,
     ):
+        from dolphin.core.utils.tools import ToolInterrupt
         if self.context.is_skillkit_empty():
             self.context.warn(f"skillkit is None, skill_name[{skill_name}]")
             return
@@ -1199,6 +1200,40 @@ class BasicCodeBlock:
             props = {}
         props.update({"gvp": self.context})
         try:
+            # Check for tool interrupt configuration (ToolInterrupt mechanism)
+            # Default: all tool calls support interrupt if tool has interrupt_config
+            # Skip interrupt check if this is a resumed tool call (intervention=False)
+            if props.get('intervention', True):
+                interrupt_config = getattr(skill, 'interrupt_config', None)
+                logger.debug(f"[DEBUG skill_run] skill_name={skill_name}, interrupt_config={interrupt_config}, intervention={props.get('intervention', True)}")
+                
+                if interrupt_config and interrupt_config.get('requires_confirmation'):
+                    logger.debug(f"[DEBUG skill_run] Tool {skill_name} requires confirmation, raising ToolInterrupt")
+                    # Format confirmation message (support parameter interpolation)
+                    message = interrupt_config.get('confirmation_message', 'Tool requires confirmation')
+                    if message and skill_params_json:
+                        try:
+                            message = message.format(**skill_params_json)
+                        except (KeyError, ValueError):
+                            # If parameter interpolation fails, use original message
+                            pass
+                    
+                    # Construct tool arguments list
+                    tool_args = [
+                        {"key": k, "value": v, "type": type(v).__name__}
+                        for k, v in skill_params_json.items()
+                    ]
+                    
+                    # Throw ToolInterrupt (checked before execution)
+                    raise ToolInterrupt(
+                        message=message,
+                        tool_name=skill_name,
+                        tool_args=tool_args,
+                        tool_config=interrupt_config
+                    )
+                else:
+                    logger.debug(f"[DEBUG skill_run] Tool {skill_name} does not require confirmation, proceeding with execution")
+            
             console_skill_call(
                 skill_name, skill_params_json, verbose=self.context.verbose, skill=skill
             )
@@ -1410,6 +1445,12 @@ class BasicCodeBlock:
             if recorder:
                 recorder.update(item=stream_item, raw_output=stream_item.answer)
 
+            # Update tool call detection flags
+            if stream_item.has_tool_call():
+                tool_call_detected = True
+                if stream_item.has_complete_tool_call():
+                    complete_tool_call = stream_item.get_tool_call()
+
             yield stream_item
 
             # If a complete tool call is detected and early-stop is enabled, stop streaming.

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/explore_block.py

@@ -558,10 +558,10 @@ Please reconsider your approach and improve your answer based on the feedback ab
     def _has_pending_tool_call(self) -> bool:
         """Check if there are pending tool calls (interrupt recovery)"""
         intervention_tmp_key = "intervention_explore_block_vars"
-        return (
-            intervention_tmp_key in self.context.get_all_variables().keys()
-            and "tool" in self.context.get_all_variables().keys()
-        )
+        has_intervention = intervention_tmp_key in self.context.get_all_variables().keys()
+        has_tool = "tool" in self.context.get_all_variables().keys()
+        logger.debug(f"[DEBUG _has_pending_tool_call] has_intervention={has_intervention}, has_tool={has_tool}")
+        return has_intervention and has_tool
 
     async def _handle_resumed_tool_call(self):
         """Tools for handling interrupt recovery calls """
@@ -571,17 +571,47 @@ Please reconsider your approach and improve your answer based on the feedback ab
         intervention_vars = self.context.get_var_value(intervention_tmp_key)
         self.context.delete_variable(intervention_tmp_key)
 
-        # Restore complete message context
+        # Restore complete message context to context_manager buckets
         saved_messages = intervention_vars.get("prompt")
         if saved_messages is not None:
+            from dolphin.core.common.enums import MessageRole
+            
+            # *** FIX: Filter out messages that are already in other buckets ***
+            # To avoid duplication, only restore messages generated during the conversation:
+            # - SYSTEM messages are already in SYSTEM bucket (from initial execute)
+            # - USER messages are already in QUERY/HISTORY buckets (initial query and history)
+            # - We only need to restore ASSISTANT and TOOL messages (conversation progress)
+            filtered_messages = [
+                msg for msg in saved_messages 
+                if msg.get("role") in [MessageRole.ASSISTANT.value, MessageRole.TOOL.value]
+            ]
+            
             msgs = Messages()
-            msgs.extend_plain_messages(saved_messages)
-            self.context.set_messages(msgs)
+            msgs.extend_plain_messages(filtered_messages)
+            # Use set_messages_batch to restore to context_manager buckets
+            # This ensures messages are available when to_dph_messages() is called
+            self.context.set_messages_batch(msgs, bucket=BuildInBucket.SCRATCHPAD.value)
 
         input_dict = self.context.get_var_value("tool")
         function_name = input_dict["tool_name"]
         raw_tool_args = input_dict["tool_args"]
         function_params_json = {arg["key"]: arg["value"] for arg in raw_tool_args}
+        
+        # *** FIX: Update the last tool_call message with modified parameters ***
+        # This ensures LLM sees the actual parameters used, not the original ones
+        messages = self.context.get_messages()
+        if messages and len(messages.get_messages()) > 0:
+            last_message = messages.get_messages()[-1]
+            # Check if last message is an assistant message with tool_calls
+            if (hasattr(last_message, 'role') and last_message.role == "assistant" and 
+                hasattr(last_message, 'tool_calls') and last_message.tool_calls):
+                # Find the matching tool_call
+                for tool_call in last_message.tool_calls:
+                    if hasattr(tool_call, 'function') and tool_call.function.name == function_name:
+                        # Update the arguments with modified parameters
+                        import json
+                        tool_call.function.arguments = json.dumps(function_params_json, ensure_ascii=False)
+                        logger.debug(f"[FIX] Updated tool_call arguments from original to modified: {function_params_json}")
 
         if self.recorder:
             self.recorder.update(
@@ -591,9 +621,58 @@ Please reconsider your approach and improve your answer based on the feedback ab
                 skill_type=self.context.get_skill_type(function_name),
                 skill_args=function_params_json,
             )
+        
+        # *** Handle skip action ***
+        skip_tool = self.context.get_var_value("__skip_tool__")
+        skip_message = self.context.get_var_value("__skip_message__")
+        
+        # Clean up skip flags
+        if skip_tool:
+            self.context.delete_variable("__skip_tool__")
+        if skip_message:
+            self.context.delete_variable("__skip_message__")
+        
         self.context.delete_variable("tool")
 
         return_answer = {}
+        
+        # If user chose to skip, don't execute the tool
+        if skip_tool:
+            # Generate friendly skip message
+            params_str = ", ".join([f"{k}={v}" for k, v in function_params_json.items()])
+            default_skip_msg = f"Tool '{function_name}' was skipped by user"
+            if skip_message:
+                skip_response = f"[SKIPPED] {skip_message}"
+            else:
+                skip_response = f"[SKIPPED] {default_skip_msg} (parameters: {params_str})"
+            
+            return_answer["answer"] = skip_response
+            return_answer["think"] = skip_response
+            return_answer["status"] = "completed"
+            
+            if self.recorder:
+                self.recorder.update(
+                    item={"answer": skip_response, "block_answer": skip_response},
+                    stage=TypeStage.SKILL,
+                    source_type=SourceType.EXPLORE,
+                    skill_name=function_name,
+                    skill_type=self.context.get_skill_type(function_name),
+                    skill_args=function_params_json,
+                )
+            
+            yield [return_answer]
+            
+            # Add tool response message with skip indicator
+            tool_call_id = self._extract_tool_call_id()
+            if not tool_call_id:
+                tool_call_id = f"call_{function_name}_{self.times}"
+            
+            self.strategy.append_tool_response_message(
+                self.context, tool_call_id, skip_response, metadata={"skipped": True}
+            )
+            return
+        
+        # Normal execution (not skipped)
         try:
             props = {"intervention": False}
             have_answer = False
@@ -1061,7 +1140,7 @@ Please reconsider your approach and improve your answer based on the feedback ab
 
     def _handle_tool_interrupt(self, e: Exception, tool_name: str):
         """Handling Tool Interruptions"""
-        self.context.info(f"tool interrupt in call {tool_name} tool")
+        self.context.info(f"Tool interrupt in call {tool_name} tool")
         if "※tool" in self.context.get_all_variables().keys():
             self.context.delete_variable("※tool")
 

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/explore_block_v2.py

@@ -295,17 +295,48 @@ class ExploreBlockV2(BasicCodeBlock):
         intervention_vars = self.context.get_var_value(intervention_tmp_key)
         self.context.delete_variable(intervention_tmp_key)
 
-        # restore the complete message context before tool execution
+        # restore the complete message context to context_manager buckets
         saved_messages = intervention_vars.get("prompt")
         if saved_messages is not None:
+            from dolphin.core.common.enums import MessageRole
+            from dolphin.core.context_engineer.config.settings import BuildInBucket
+            
+            # *** FIX: Filter out messages that are already in other buckets ***
+            # To avoid duplication, only restore messages generated during the conversation:
+            # - SYSTEM messages are already in SYSTEM bucket (from initial execute)
+            # - USER messages are already in QUERY/HISTORY buckets (initial query and history)
+            # - We only need to restore ASSISTANT and TOOL messages (conversation progress)
+            filtered_messages = [
+                msg for msg in saved_messages 
+                if msg.get("role") in [MessageRole.ASSISTANT.value, MessageRole.TOOL.value]
+            ]
+            
             msgs = Messages()
-            msgs.extend_plain_messages(saved_messages)
-            self.context.set_messages(msgs)
+            msgs.extend_plain_messages(filtered_messages)
+            # Use set_messages_batch to restore to context_manager buckets
+            # This ensures messages are available when to_dph_messages() is called
+            self.context.set_messages_batch(msgs, bucket=BuildInBucket.SCRATCHPAD.value)
 
         input_dict = self.context.get_var_value("tool")
         function_name = input_dict["tool_name"]
         raw_tool_args = input_dict["tool_args"]
         function_params_json = {arg["key"]: arg["value"] for arg in raw_tool_args}
+        
+        # *** FIX: Update the last tool_call message with modified parameters ***
+        # This ensures LLM sees the actual parameters used, not the original ones
+        messages = self.context.get_messages()
+        if messages and len(messages.get_messages()) > 0:
+            last_message = messages.get_messages()[-1]
+            # Check if last message is an assistant message with tool_calls
+            if (hasattr(last_message, 'role') and last_message.role == "assistant" and 
+                hasattr(last_message, 'tool_calls') and last_message.tool_calls):
+                # Find the matching tool_call
+                for tool_call in last_message.tool_calls:
+                    if hasattr(tool_call, 'function') and tool_call.function.name == function_name:
+                        # Update the arguments with modified parameters
+                        import json
+                        tool_call.function.arguments = json.dumps(function_params_json, ensure_ascii=False)
+                        logger.debug(f"[FIX] Updated tool_call arguments from original to modified: {function_params_json}")
 
         (
             self.recorder.update(
@@ -318,9 +349,59 @@ class ExploreBlockV2(BasicCodeBlock):
             if self.recorder
             else None
         )
+        
+        # *** Handle skip action ***
+        skip_tool = self.context.get_var_value("__skip_tool__")
+        skip_message = self.context.get_var_value("__skip_message__")
+        
+        # Clean up skip flags
+        if skip_tool:
+            self.context.delete_variable("__skip_tool__")
+        if skip_message:
+            self.context.delete_variable("__skip_message__")
+        
         self.context.delete_variable("tool")
 
         return_answer = {}
+        
+        # If user chose to skip, don't execute the tool
+        if skip_tool:
+            # Generate friendly skip message
+            params_str = ", ".join([f"{k}={v}" for k, v in function_params_json.items()])
+            default_skip_msg = f"Tool '{function_name}' was skipped by user"
+            if skip_message:
+                skip_response = f"[SKIPPED] {skip_message}"
+            else:
+                skip_response = f"[SKIPPED] {default_skip_msg} (parameters: {params_str})"
+            
+            return_answer["answer"] = skip_response
+            return_answer["think"] = skip_response
+            return_answer["status"] = "completed"
+            
+            (
+                self.recorder.update(
+                    item={"answer": skip_response, "block_answer": skip_response},
+                    stage=TypeStage.SKILL,
+                    source_type=SourceType.EXPLORE,
+                    skill_name=function_name,
+                    skill_type=self.context.get_skill_type(function_name),
+                    skill_args=function_params_json,
+                )
+                if self.recorder
+                else None
+            )
+            
+            yield [return_answer]
+            
+            # Add tool response message with skip indicator
+            tool_call_id = self._extract_tool_call_id()
+            if not tool_call_id:
+                tool_call_id = f"call_{function_name}_{self.times}"
+            
+            self._append_tool_message(tool_call_id, skip_response, metadata={"skipped": True})
+            return
+        
+        # Normal execution (not skipped)
         try:
             props = {"intervention": False}
             have_answer = False
@@ -480,6 +561,7 @@ class ExploreBlockV2(BasicCodeBlock):
             return
 
         # Add assistant message containing tool calls
+        logger.debug(f"[DEBUG] Tool call detected, preparing to execute: {stream_item.tool_name}")
         tool_call_id = f"call_{stream_item.tool_name}_{self.times}"
         tool_call_openai_format = [
             {
@@ -506,13 +588,16 @@ class ExploreBlockV2(BasicCodeBlock):
             )
             self.deduplicator_skillcall.add(tool_call)
 
+            logger.debug(f"[DEBUG] Calling _execute_tool_call for: {stream_item.tool_name}")
             async for ret in self._execute_tool_call(stream_item, tool_call_id):
                 yield ret
+            logger.debug(f"[DEBUG] _execute_tool_call completed for: {stream_item.tool_name}")
         else:
             await self._handle_duplicate_tool_call(tool_call, stream_item)
 
     async def _execute_tool_call(self, stream_item, tool_call_id: str):
         """Execute tool call"""
+        logger.debug(f"[DEBUG] _execute_tool_call ENTERED for: {stream_item.tool_name}")
         intervention_tmp_key = "intervention_explore_block_vars"
 
         try:

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/explore_strategy.py

@@ -574,11 +574,12 @@ class ToolCallStrategy(ExploreStrategy):
         no_cache: bool = False,
     ) -> Dict[str, Any]:
         """Includes the tools parameter and an optional tool_choice"""
+        tools = skillkit.getSkillsSchema() if skillkit and not skillkit.isEmpty() else []
         llm_params = {
             "messages": messages,
             "model": model,
             "no_cache": no_cache,
-            "tools": skillkit.getSkillsSchema() if skillkit and not skillkit.isEmpty() else [],
+            "tools": tools,
         }
 
         if tool_choice:

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/judge_block.py

@@ -148,15 +148,39 @@ class JudgeBlock(BasicCodeBlock):
                 new_tool_args = {arg["key"]: arg["value"] for arg in raw_tool_args}
 
                 props = {"intervention": False, "gvp": self.context}
+                
+                # *** Handle skip action ***
+                skip_tool = self.context.get_var_value("__skip_tool__")
+                skip_message = self.context.get_var_value("__skip_message__")
+                
+                # Clean up skip flags
+                if skip_tool:
+                    self.context.delete_variable("__skip_tool__")
+                if skip_message:
+                    self.context.delete_variable("__skip_message__")
+                
                 self.context.delete_variable("tool")
 
-                async for resp_item in self.skill_run(
-                    source_type=SourceType.SKILL,
-                    skill_name=tool_name,
-                    skill_params_json=new_tool_args,
-                    props=props,
-                ):
-                    yield resp_item
+                # If user chose to skip, don't execute the tool
+                if skip_tool:
+                    # Generate friendly skip message
+                    params_str = ", ".join([f"{k}={v}" for k, v in new_tool_args.items()])
+                    default_skip_msg = f"Tool '{tool_name}' was skipped by user"
+                    if skip_message:
+                        skip_response = f"[SKIPPED] {skip_message}"
+                    else:
+                        skip_response = f"[SKIPPED] {default_skip_msg} (parameters: {params_str})"
+                    
+                    yield {"answer": skip_response}
+                else:
+                    # Normal execution (not skipped)
+                    async for resp_item in self.skill_run(
+                        source_type=SourceType.SKILL,
+                        skill_name=tool_name,
+                        skill_params_json=new_tool_args,
+                        props=props,
+                    ):
+                        yield resp_item
             else:
                 self.recorder.set_output_var(self.assign_type, self.output_var)
 

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/code_block/tool_block.py

@@ -70,28 +70,65 @@ class ToolBlock(BasicCodeBlock):
                 new_tool_args = {arg["key"]: arg["value"] for arg in raw_tool_args}
 
                 props = {"intervention": False, "gvp": self.context}
+                
+                # *** Handle skip action ***
+                skip_tool = self.context.get_var_value("__skip_tool__")
+                skip_message = self.context.get_var_value("__skip_message__")
+                
+                # Clean up skip flags
+                if skip_tool:
+                    self.context.delete_variable("__skip_tool__")
+                if skip_message:
+                    self.context.delete_variable("__skip_message__")
+                
                 input_dict = self.context.delete_variable("tool")
 
-                resp_item = None
-                async for resp_item in self.skill_run(
-                    source_type=SourceType.SKILL,
-                    skill_name=tool_name,
-                    skill_params_json=new_tool_args,
-                    props=props,
-                ):
-                    yield resp_item
-
-                if self.recorder is not None:
-                    self.recorder.update(
-                        stage=TypeStage.SKILL,
-                        item=resp_item,
-                        skill_name=tool_name,
-                        skill_args=new_tool_args,
-                        skill_type=self.context.get_skill_type(tool_name),
+                # If user chose to skip, don't execute the tool
+                if skip_tool:
+                    # Generate friendly skip message
+                    params_str = ", ".join([f"{k}={v}" for k, v in new_tool_args.items()])
+                    default_skip_msg = f"Tool '{tool_name}' was skipped by user"
+                    if skip_message:
+                        skip_response = f"[SKIPPED] {skip_message}"
+                    else:
+                        skip_response = f"[SKIPPED] {default_skip_msg} (parameters: {params_str})"
+                    
+                    resp_item = {"answer": skip_response}
+                    
+                    if self.recorder is not None:
+                        self.recorder.update(
+                            stage=TypeStage.SKILL,
+                            item=resp_item,
+                            skill_name=tool_name,
+                            skill_args=new_tool_args,
+                            skill_type=self.context.get_skill_type(tool_name),
+                            source_type=SourceType.SKILL,
+                            is_completed=True,
+                        )
+                    
+                    yield {"data": resp_item}
+                else:
+                    # Normal execution (not skipped)
+                    resp_item = None
+                    async for resp_item in self.skill_run(
                         source_type=SourceType.SKILL,
-                        is_completed=True,
-                    )
-                yield {"data": resp_item}
+                        skill_name=tool_name,
+                        skill_params_json=new_tool_args,
+                        props=props,
+                    ):
+                        yield resp_item
+
+                    if self.recorder is not None:
+                        self.recorder.update(
+                            stage=TypeStage.SKILL,
+                            item=resp_item,
+                            skill_name=tool_name,
+                            skill_args=new_tool_args,
+                            skill_type=self.context.get_skill_type(tool_name),
+                            source_type=SourceType.SKILL,
+                            is_completed=True,
+                        )
+                    yield {"data": resp_item}
             else:
                 # step1: First parse, then retrieve the actual values from gvpool when actually calling the function (the actual variable values might be of type dict, list)
                 tool_call_info = self.parse_tool_call()

{kweaver_dolphin-0.1.0 → kweaver_dolphin-0.2.0}/src/dolphin/core/context/context.py

@@ -969,10 +969,13 @@ class Context:
         if bucket is None:
             bucket = BuildInBucket.SCRATCHPAD.value
 
-        # Empty the current bucket
-        self.context_manager.clear_bucket(bucket)
-        # Add new messages
-        self.context_manager.add_bucket(bucket, messages)
+        # Replace bucket content (or create if not exists)
+        if self.context_manager.has_bucket(bucket):
+            # Use replace_bucket_content to directly replace existing bucket
+            self.context_manager.replace_bucket_content(bucket, messages)
+        else:
+            # Create new bucket if it doesn't exist
+            self.context_manager.add_bucket(bucket, messages)
 
         # Mark as dirty
         self.messages_dirty = True