kweaver-dolphin 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

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}"

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
 

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.

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")
 

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:

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:

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)
 

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()

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

dolphin/core/executor/dolphin_executor.py

@@ -484,6 +484,10 @@ class DolphinExecutor:
         if isinstance(e, UserInterrupt):
             frame.status = FrameStatus.WAITING_FOR_INTERVENTION
             frame.wait_reason = WaitReason.USER_INTERRUPT
+            # *** FIX: Update block_pointer to current block before saving snapshot ***
+            # This ensures resume will continue from the interrupted block, not restart from beginning
+            frame.block_pointer = block_pointer
+            self.state_registry.update_frame(frame)  # Save updated pointer
             intervention_snapshot_id = self._save_frame_snapshot(frame)
             frame.error = {
                 "error_type": "UserInterrupt",
@@ -504,12 +508,17 @@ class DolphinExecutor:
         if isinstance(e, ToolInterrupt):
             frame.status = FrameStatus.WAITING_FOR_INTERVENTION
             frame.wait_reason = WaitReason.TOOL_REQUEST
+            # *** FIX: Update block_pointer to current block before saving snapshot ***
+            # This ensures resume will continue from the interrupted block, not restart from beginning
+            frame.block_pointer = block_pointer
+            self.state_registry.update_frame(frame)  # Save updated pointer
             intervention_snapshot_id = self._save_frame_snapshot(frame)
             frame.error = {
                 "error_type": "ToolInterrupt",
                 "message": str(e),
                 "tool_name": getattr(e, "tool_name", ""),
                 "tool_args": getattr(e, "tool_args", []),
+                "tool_config": getattr(e, "tool_config", {}),
                 "at_block": block_pointer,
                 "intervention_snapshot_id": intervention_snapshot_id,
             }

dolphin/core/llm/llm.py

@@ -249,7 +249,6 @@ class LLMModelFactory(LLM):
             finish_reason = None
             # Use ToolCallsParser to handle tool calls parsing
             tool_parser = ToolCallsParser()
-
             timeout = aiohttp.ClientTimeout(
                 total=1800,  # Disable overall timeout (use with caution)
                 sock_connect=30,  # Keep connection timeout
@@ -320,7 +319,7 @@ class LLMModelFactory(LLM):
 
                                     accu_content += delta_content
                                     reasoning_content += delta_reasoning
-                                    
+
                                     # Capture finish_reason
                                     chunk_finish_reason = line_json["choices"][0].get("finish_reason")
                                     if chunk_finish_reason:
@@ -461,7 +460,7 @@ class LLMOpenai(LLM):
                 and delta.reasoning_content is not None
             ):
                 accu_reasoning += delta.reasoning_content
-            
+
             # Capture finish_reason
             chunk_finish_reason = chunk.choices[0].finish_reason
             if chunk_finish_reason:

dolphin/core/llm/llm_client.py

@@ -182,6 +182,7 @@ class LLMClient:
                 sock_connect=30,  # Keep connection timeout
                 sock_read=300,  # Single read timeout (for slow streaming data)
             )
+            print(f"------------------------llm={payload}")
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 async with session.post(
                     model_config.api,

dolphin/core/utils/cache_kv.py

@@ -1,15 +1,79 @@
-import fcntl
 import json
 import os
+import sys
 import threading
 import time
 from typing import List, Dict, Any, Optional
 import uuid
 from dolphin.core.logging.logger import get_logger
 
+# Cross-platform file locking support
+_HAS_FCNTL = False
+_HAS_MSVCRT = False
+
+if sys.platform == 'win32':
+    # Windows: use msvcrt for file locking
+    try:
+        import msvcrt
+        _HAS_MSVCRT = True
+    except ImportError:
+        pass
+else:
+    # Unix/Linux: use fcntl for file locking
+    try:
+        import fcntl
+        _HAS_FCNTL = True
+    except ImportError:
+        pass
+
 logger = get_logger("utils.cache_kv")
 
 
+def _lock_file(f, exclusive=False):
+    """
+    Cross-platform file locking
+    
+    Args:
+        f: File object
+        exclusive: If True, acquire exclusive lock; otherwise shared lock
+    """
+    if _HAS_FCNTL:
+        # Unix/Linux: use fcntl
+        lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
+        fcntl.flock(f.fileno(), lock_type)
+    elif _HAS_MSVCRT:
+        # Windows: use msvcrt
+        # msvcrt.locking doesn't support shared locks, so we use exclusive
+        # Note: msvcrt requires seeking to the start
+        f.seek(0)
+        try:
+            msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1)
+        except OSError:
+            # File might be too short, which is ok for our use case
+            pass
+    # If neither is available, proceed without locking (not ideal but won't crash)
+
+
+def _unlock_file(f):
+    """
+    Cross-platform file unlocking
+    
+    Args:
+        f: File object
+    """
+    if _HAS_FCNTL:
+        # Unix/Linux: use fcntl
+        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+    elif _HAS_MSVCRT:
+        # Windows: use msvcrt
+        f.seek(0)
+        try:
+            msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+        except OSError:
+            pass
+    # If neither is available, nothing to unlock
+
+
 class CacheKV:
     def __init__(
         self, filePath: str, dumpInterval: int = 5, expireTimeByDay: float = 1
@@ -28,8 +92,7 @@ class CacheKV:
 
         try:
             with open(self.filePath, "r", encoding="utf-8") as f:
-                fd = f.fileno()
-                fcntl.flock(fd, fcntl.LOCK_SH)  # Shared lock for reading
+                _lock_file(f, exclusive=False)  # Shared lock for reading
                 try:
                     loaded_cache = json.load(f)
                     for key, value in loaded_cache.items():
@@ -46,7 +109,7 @@ class CacheKV:
                             # Compatible with old formats
                             self.cache[key] = {"value": value, "timestamp": time.time()}
                 finally:
-                    fcntl.flock(fd, fcntl.LOCK_UN)
+                    _unlock_file(f)
         except (json.JSONDecodeError, IOError) as e:
             logger.error(
                 f"Error loading cache file {self.filePath}: {e} try to backup and reset cache"
@@ -77,14 +140,13 @@ class CacheKV:
             temp_path = f"{self.filePath}.tmp.{os.getpid()}.{uuid.uuid4().hex}"
             try:
                 with open(temp_path, "w", encoding="utf-8") as f:
-                    fd = f.fileno()
-                    fcntl.flock(fd, fcntl.LOCK_EX)  # Exclusive lock for writing
+                    _lock_file(f, exclusive=True)  # Exclusive lock for writing
                     try:
                         json.dump(self.cache, f, ensure_ascii=False)
                         f.flush()
-                        os.fsync(fd)  # Ensure data is written to disk
+                        os.fsync(f.fileno())  # Ensure data is written to disk
                     finally:
-                        fcntl.flock(fd, fcntl.LOCK_UN)
+                        _unlock_file(f)
 
                 # Atomic rename
                 os.rename(temp_path, self.filePath)

dolphin/core/utils/tools.py

@@ -332,9 +332,11 @@ class ToolInterrupt(Exception):
         message="The tool was interrupted.",
         tool_name: str = None,
         tool_args: List[Dict] = None,
+        tool_config: Dict = None,
         *args,
         **kwargs,
     ):
         super().__init__(message, *args, **kwargs)
         self.tool_name = tool_name if tool_name else ""
         self.tool_args = tool_args if tool_args else []
+        self.tool_config = tool_config if tool_config else {}

dolphin/sdk/skill/traditional_toolkit.py

@@ -66,6 +66,10 @@ class TriditionalToolkit(Skillkit):
 
             # Add tool type information to the SkillFunction
             openai_function.original_tool = tool
+            
+            # Copy interrupt_config from tool to SkillFunction if it exists
+            if hasattr(tool, 'interrupt_config'):
+                openai_function.interrupt_config = tool.interrupt_config
 
             openai_functions[tool_name] = openai_function
 

{kweaver_dolphin-0.1.0.dist-info → kweaver_dolphin-0.2.0.dist-info}/METADATA

@@ -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.dist-info → kweaver_dolphin-0.2.0.dist-info}/RECORD

@@ -17,7 +17,7 @@ dolphin/cli/multimodal/input_parser.py,sha256=gKbSnO2i_sNYamcYtVB638sLZnDCrp0ZJx
 dolphin/cli/runner/__init__.py,sha256=wUBuFqq_wm5wi8KpJvF3QDEnCWBiqrgi0ihI1EDe6Nw,153
 dolphin/cli/runner/runner.py,sha256=C-3qtWWkK_qHg_I5Qyq9n4bo1Ufp4RIotGuf5-d6aD8,36529
 dolphin/cli/ui/__init__.py,sha256=w1xrgYJ66ehCcdgeHMZWiCBRP_C64j5Alt0HYB0dTxM,228
-dolphin/cli/ui/console.py,sha256=KxUCg8WftmAEmgwLajHgd8GjRPDQ3J9mnIiexXuesf8,112346
+dolphin/cli/ui/console.py,sha256=W1Mg8Lstq6PDX2P4-0ujWTCkNXuimTtmAfwnCQlfDf0,112339
 dolphin/cli/ui/input.py,sha256=qEtyOdNdipWHLWe7aZI1eOtcX7S34vQ_bytXumrZ1S0,11199
 dolphin/cli/ui/layout.py,sha256=Qhjp0a7ZvecYdifZDlO64PTHkSXb_amuWzCtYZYdods,14501
 dolphin/cli/ui/stream_renderer.py,sha256=qo5mIDE_dUxf9otwr34kjCDx9Y9If2sLXZ4twojSKKw,11950
@@ -28,18 +28,18 @@ dolphin/core/__init__.py,sha256=h41bEI_o9djjE4v00cUT8oTdtynsvtmus-mX1XT6TZg,2785
 dolphin/core/interfaces.py,sha256=XvyVO9LB9YbBxRlJXSdcqt7-6lH0GVTYEDYxY_zqQmE,1161
 dolphin/core/agent/__init__.py,sha256=mOligICB_byI5rZFqMvSJN0msodBvravbhSghpboDdU,221
 dolphin/core/agent/agent_state.py,sha256=3YsFJdG21FqoIoHTDMBx01KEJJDRXFToW0vDrzUWMOU,1949
-dolphin/core/agent/base_agent.py,sha256=PMXCq1dQIhipJhHAWI7nQtNT5l_qndxEQDhkK9idxBo,42496
+dolphin/core/agent/base_agent.py,sha256=hlTgEhxWvnWIPhyZvL6RWymZQM9NtSk22AH5W3EhT-g,46259
 dolphin/core/code_block/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dolphin/core/code_block/agent_init_block.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dolphin/core/code_block/assign_block.py,sha256=xbPiQOkFAbrcRDnwkcNN2tfxy7OG8IXPPbjlCM1KJ9I,4124
-dolphin/core/code_block/basic_code_block.py,sha256=Ktqfmz4x5PudaE1gyynAJ4YZ_Vy4EPWODJYVU_e7TZk,74076
-dolphin/core/code_block/explore_block.py,sha256=DG5xRh9hP82ry6bPkb0aCL8G9rKDgTuyb40MaHHVsQI,54246
-dolphin/core/code_block/explore_block_v2.py,sha256=sHhPoG1hVpQ-3QopSn_iX20a5egqFYJllPFDZzEWkCo,27898
-dolphin/core/code_block/explore_strategy.py,sha256=PcgKvNOXh6B2udr2yhHfzCRcUNBSstC6-zTBigcm-g0,22794
-dolphin/core/code_block/judge_block.py,sha256=oOjgHEVLBfMnZP-l16DR13pcZITm2uKQaZM-T4W1t28,9318
+dolphin/core/code_block/basic_code_block.py,sha256=X0dHzsQF3g9tFdgMtgbMtVp9qvN8goXKv5BKLce4-Gk,76438
+dolphin/core/code_block/explore_block.py,sha256=dbQ6X4nIoogOu8Ytk1VEUAmmZVG6de_G66N5uTtjGI8,58495
+dolphin/core/code_block/explore_block_v2.py,sha256=HWHNLWLiVcjphqOv7TNS1qfRpvJDeS1ROfM7pKXvtfM,32432
+dolphin/core/code_block/explore_strategy.py,sha256=MXzJ8NhQyz3bt6PY02YboKjTWH_Vfwdy3UmlFYjDJqI,22816
+dolphin/core/code_block/judge_block.py,sha256=ueMkiOs7vsdrZgrnrwZ6l79FvvnQOwd4pDWPEsRvtag,10525
 dolphin/core/code_block/prompt_block.py,sha256=lFun43lOQP9rbZzoNw2sYhwQCHRenRBZzL6vuXKunvo,1131
 dolphin/core/code_block/skill_call_deduplicator.py,sha256=6btnQU6AIUPnxl2JthYRdsmJkueDyxW9Iw-OIomjiaM,9879
-dolphin/core/code_block/tool_block.py,sha256=8h5XqLSPycUpQWz9BlFl7UBwXOexvgZ1JaQnNCeYU6Y,5360
+dolphin/core/code_block/tool_block.py,sha256=Gh0NeW_Vk1Ue43ymi_FXX8MpEGJ3Br1G_88hHn6M7fs,7214
 dolphin/core/common/__init__.py,sha256=WUsyhGJljLFzpW_YEnkMsNn_Iw3WdqkFyuHa-mMKhNc,455
 dolphin/core/common/constants.py,sha256=tOJ31IupXIYfT8I8rmSh2YhWKitAJTf6iRn99MbxBwo,7348
 dolphin/core/common/enums.py,sha256=9QEzvCb7vbkQns1mtVlswsRZHKVwwvdRqrefSr-S68g,42282
@@ -52,7 +52,7 @@ dolphin/core/config/__init__.py,sha256=7PJH0qB8mTc8Tjuvlum8Y-RdomyaKWZQoA4XVzEd0
 dolphin/core/config/global_config.py,sha256=AiyVw3tOeA5xlsJvQ2O9zU2AEmjeIqYm-LXl_2JLdWY,46392
 dolphin/core/config/ontology_config.py,sha256=sGMkbcfFp5EdNIFazrY7Z2MsahCt0vC7GH_5-VleGcA,3899
 dolphin/core/context/__init__.py,sha256=2CKAzbIol_oZ611KSYLEk-Apyfez9tLXOYT9S6WMhW8,324
-dolphin/core/context/context.py,sha256=NGwYSim5LvqPJZlvjp_fX8fukhjy4fGk-d-lT9zK9Uk,63156
+dolphin/core/context/context.py,sha256=6PV84YAuwZ4OtBDd1auRl6bjEC5egw-czPEee4aPgWo,63376
 dolphin/core/context/context_manager.py,sha256=3yo8sdWkfqq52cwhNIM0OlXPLZSLftTbFHuWBlqjOsE,6288
 dolphin/core/context/var_output.py,sha256=1Xb_JYv5L0f3JhUy8ZxmwF4EQEtn_Czh44s5nXjo2PA,2830
 dolphin/core/context/variable_pool.py,sha256=SgztIgALcIoNAMYf1VM7EzHeNNa2g61oLt5Ta32u81o,13212
@@ -82,7 +82,7 @@ dolphin/core/coroutine/resume_handle.py,sha256=6TyLNlKr99rXKOFBihUcUOr6zOSxjk66b
 dolphin/core/coroutine/step_result.py,sha256=uag0YhE-TbX6YoqtM2kQfWfBuoConH4ti4u_K_zdwxs,4017
 dolphin/core/executor/__init__.py,sha256=nogeHlssz4IPr5HD8nqjcf6ipSJCmQtelfayvg3a_oM,550
 dolphin/core/executor/debug_controller.py,sha256=15N4sFPBiZYK_DiTsrA3f0FdRYrbLdXV0IZ0qvnj9U8,26652
-dolphin/core/executor/dolphin_executor.py,sha256=C0v1j7mN3L_7Ic1dA2IE_HXekR8aLAj4Wni-OhQA6x0,42677
+dolphin/core/executor/dolphin_executor.py,sha256=Eci_MzdHv0r7TFF9chCBzHxblxazJ48JVlQtEoFBkjw,43369
 dolphin/core/executor/executor.py,sha256=xoTf8tBVaWiuv-EmTXY94HW-Llgz2nWJDHtZ0yh5Fxo,25632
 dolphin/core/flags/__init__.py,sha256=9rek6speJJyfzJfy6MqlM4pTrSAB-kmAfrwgu2wCoB0,498
 dolphin/core/flags/definitions.py,sha256=O-15MCZCyC7NVMF0E8cWlr0k8gAyr36Acutb4i8UDNo,1378
@@ -93,9 +93,9 @@ dolphin/core/hook/hook_dispatcher.py,sha256=_V8zZJlgeJUDCgTnYYju1B0wYY7ADj5XXIF4
 dolphin/core/hook/hook_types.py,sha256=xGBhv8RgG21xEF2Z4IFACtKUGWn9-G5RzQTPgS9DPhU,8047
 dolphin/core/hook/isolated_variable_pool.py,sha256=CpIikUIDcl6_0V239oNBYLhsCDQKFITNFtubpAI1JJ4,9046
 dolphin/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dolphin/core/llm/llm.py,sha256=yG5yYZ5hSW1LFB8KgbnvaalJ_vw-fhlk8aJCg0eox9Y,20399
+dolphin/core/llm/llm.py,sha256=l7N4xSoH6Y_Y14Qmbjsr2jTEV-ycC3VrGGCz2yQkHTw,20350
 dolphin/core/llm/llm_call.py,sha256=ccCRW5GxJ8_UiiWVtjuTx7Tattjlp7SbENSW50EbxAU,3408
-dolphin/core/llm/llm_client.py,sha256=OvFOpUirp2fdMCwZDG85ephlqcGZzKOrQqY4AOsu4LE,59090
+dolphin/core/llm/llm_client.py,sha256=-YS5RskVjLF7HS0SlFnUwF-UMYNbtb_qS97fLU9HbBg,59150
 dolphin/core/llm/message_sanitizer.py,sha256=xGBattdBVYHDPHdZLxUmmerZYPNFe8HZwrGI5PycjFQ,4461
 dolphin/core/logging/__init__.py,sha256=ix3t_AONJVUaO2WQ5BeVUx762OBlFFYu8tyZ-8Q0jpU,316
 dolphin/core/logging/logger.py,sha256=FawfEAbgGHDlCsEBxH8zmeoknFNNRLgIlBXTz8dp-JM,18859
@@ -116,8 +116,8 @@ dolphin/core/trajectory/__init__.py,sha256=5FGGDE48K_OMKcca4usSyv1z_hvfaDzearur-
 dolphin/core/trajectory/recorder.py,sha256=xA5ZOyoRxgIgFZkF5EzyNzP0nJexDjDnnC_pDskzg4g,6441
 dolphin/core/trajectory/trajectory.py,sha256=eEYmokzaskeWx0MfSBuMYWrfBouXpt4HwvCl73BGmNI,21577
 dolphin/core/utils/__init__.py,sha256=8IhOF81ct7TYiVoc9SWbyO6YUWaSlcZH2dVcF0qy46Y,176
-dolphin/core/utils/cache_kv.py,sha256=hWGz3j-vtGd317Eo9o2lDBhNdCEef4Eo5TZCUmadUXw,7412
-dolphin/core/utils/tools.py,sha256=Cn0KpG_pqlXzpkud16JRGpY4VO5eG0GMxPtLC2gWowU,9779
+dolphin/core/utils/cache_kv.py,sha256=UnuUKE_1sL0glWJ3qq3TLN4MpKxNqzdw_72sxfUPXig,8968
+dolphin/core/utils/tools.py,sha256=-Ezo7daUFII_VGsPY0WWvLt1SWdXUzir2nEL0UxWISA,9875
 dolphin/lib/__init__.py,sha256=tm_qFRc7NEuWUYYYFq9PKuJ-CXCG8WCjLwYut_3yPYc,2557
 dolphin/lib/debug/__init__.py,sha256=LXMTcUqnSnvEd_aCtSjaxs7PVUSf0pVJ0BiMozGESP0,154
 dolphin/lib/debug/visualizer.py,sha256=zoweYgmbZW2KOoJe3Y63C6-G1uDZi23srUDpxngtWbQ,18024
@@ -190,10 +190,10 @@ dolphin/sdk/runtime/__init__.py,sha256=W90bnFZ_l6ukuZ3l1iBRWN0oPetdNisjj6dxBMk1N
 dolphin/sdk/runtime/env.py,sha256=OU0CEZuVXgdQPeNsYq6BhFETcc-Q2vcAp6jLvOrEsbU,12337
 dolphin/sdk/skill/__init__.py,sha256=zzfHgrxIWxUEFH1HMiwb08U1M1ukHcdNtFqKi3Sg1ug,246
 dolphin/sdk/skill/global_skills.py,sha256=2gebgdAKEgPWGhv1_pliI0uqbbkEMA9ZaphJj7A_eeE,27531
-dolphin/sdk/skill/traditional_toolkit.py,sha256=fYVxX0e8nHr0d9UQwq4FKVsyPmP7VpTB9ufsNzquAcI,9143
-kweaver_dolphin-0.1.0.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-kweaver_dolphin-0.1.0.dist-info/METADATA,sha256=XCZFEnIUXbvnafcjiC8k-N4IStUSw73fwmGQYjSawfk,15420
-kweaver_dolphin-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kweaver_dolphin-0.1.0.dist-info/entry_points.txt,sha256=0xA4Hy1bkr0V7CTaWvswGeHZ0tXdAtCNlGa3ZUDdBg0,1519
-kweaver_dolphin-0.1.0.dist-info/top_level.txt,sha256=vwNhnr4e0NgKRTfM56xcCfo9t2ZebTbbPF38xpBYiq0,27
-kweaver_dolphin-0.1.0.dist-info/RECORD,,
+dolphin/sdk/skill/traditional_toolkit.py,sha256=Yyejm1LCUDVfXb1MCiaiT2tyFsrW0bj0uvKa5VjA8FM,9355
+kweaver_dolphin-0.2.0.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+kweaver_dolphin-0.2.0.dist-info/METADATA,sha256=aOKfCCkkYlH6C-zQBIk8145oFmrxqBT4DrXsbkwcPbw,15420
+kweaver_dolphin-0.2.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+kweaver_dolphin-0.2.0.dist-info/entry_points.txt,sha256=0xA4Hy1bkr0V7CTaWvswGeHZ0tXdAtCNlGa3ZUDdBg0,1519
+kweaver_dolphin-0.2.0.dist-info/top_level.txt,sha256=vwNhnr4e0NgKRTfM56xcCfo9t2ZebTbbPF38xpBYiq0,27
+kweaver_dolphin-0.2.0.dist-info/RECORD,,

{kweaver_dolphin-0.1.0.dist-info → kweaver_dolphin-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any