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

dolphin/core/code_block/explore_block_v2.py

@@ -295,34 +295,121 @@ 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}
-
-        (
-            self.recorder.update(
-                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
-        )
+        
+        # Get saved stage_id for resume
+        saved_stage_id = intervention_vars.get("stage_id")
+        logger.debug(f"Resuming tool call for {input_dict['tool_name']}, saved_stage_id: {saved_stage_id}")
+        
+        # *** 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)
+
+        # *** FIX: Don't call recorder.update() here during resume ***
+        # skill_run() will create the stage with the correct saved_stage_id
+        # Calling update() here would create an extra stage with a new ID
+        # (
+        #     self.recorder.update(
+        #         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
+        # )
+        
+        # *** 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}
+            props = {"intervention": False, "saved_stage_id": saved_stage_id}
             have_answer = False
 
             async for resp in self.skill_run(
@@ -516,11 +603,13 @@ class ExploreBlockV2(BasicCodeBlock):
         intervention_tmp_key = "intervention_explore_block_vars"
 
         try:
+            # Save intervention vars (stage_id will be filled by skill_run after creating the stage)
             intervention_vars = {
                 "prompt": self.context.get_messages().get_messages_as_dict(),
                 "tool_name": stream_item.tool_name,
                 "cur_llm_stream_answer": stream_item.answer,
                 "all_answer": stream_item.answer,
+                "stage_id": None,  # Will be updated by skill_run() after stage creation
             }
 
             self.context.set_variable(intervention_tmp_key, intervention_vars)

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:
@@ -667,6 +668,7 @@ class ToolCallStrategy(ExploreStrategy):
                     f"Tool call {info.name} (id={info.id}) skipped: "
                     f"Stream ended but JSON arguments incomplete or invalid. "
                     f"Raw arguments: '{info.raw_arguments}'"
+                    f"finish_reason: {stream_item.finish_reason}"
                 )
         
         return result

dolphin/core/code_block/judge_block.py

@@ -7,6 +7,9 @@ from dolphin.core.context.context import Context
 from dolphin.core.llm.llm_client import LLMClient
 from dolphin.core.utils.tools import ToolInterrupt
 from dolphin.core.context.var_output import SourceType
+from dolphin.core.logging.logger import get_logger
+
+logger = get_logger()
 
 
 class JudgeBlock(BasicCodeBlock):
@@ -129,6 +132,9 @@ class JudgeBlock(BasicCodeBlock):
 
                 tool_name = intervention_vars["tool_name"]
                 judge_call_info = intervention_vars["judge_call_info"]
+                
+                # *** FIX: Get saved stage_id for resume ***
+                saved_stage_id = intervention_vars.get("stage_id")
 
                 self.recorder.set_output_var(
                     judge_call_info["assign_type"], judge_call_info["output_var"]
@@ -147,16 +153,41 @@ class JudgeBlock(BasicCodeBlock):
                 raw_tool_args = input_dict["tool_args"]
                 new_tool_args = {arg["key"]: arg["value"] for arg in raw_tool_args}
 
-                props = {"intervention": False, "gvp": self.context}
+                # *** FIX: Pass saved_stage_id to skill_run ***
+                props = {"intervention": False, "saved_stage_id": saved_stage_id, "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)
 
@@ -178,6 +209,7 @@ class JudgeBlock(BasicCodeBlock):
                     if self.recorder and hasattr(self.recorder, "set_output_var"):
                         self.recorder.set_output_var(self.assign_type, self.output_var)
 
+                    # Save intervention vars (stage_id will be filled by skill_run after creating the stage)
                     intervention_vars = {
                         "tool_name": tool_name,
                         "judge_call_info": {
@@ -186,6 +218,7 @@ class JudgeBlock(BasicCodeBlock):
                             "output_var": self.output_var,
                             "params": self.params,
                         },
+                        "stage_id": None,  # Will be updated by skill_run() after stage creation
                     }
 
                     try:

dolphin/core/code_block/skill_call_deduplicator.py

@@ -111,14 +111,16 @@ class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
     def __init__(self):
         self.skillcalls: Dict[str, int] = {}
         self.call_results: Dict[str, str] = {}
-        # Cache call_key to avoid duplicate serialization
-        self._call_key_cache: Dict[int, str] = {}
+        # Import polling tools from constants to avoid hardcoding.
+        # These tools are expected to be called repeatedly (polling-style).
+        # Do NOT count these towards duplicate-call termination.
+        from dolphin.core.common.constants import POLLING_TOOLS
+        self._always_allow_duplicate_skills = POLLING_TOOLS
 
     def clear(self):
         """Clear all records"""
         self.skillcalls.clear()
         self.call_results.clear()
-        self._call_key_cache.clear()
 
     def get_history(self) -> list:
         """Get the history of all recorded skill calls.
@@ -153,11 +155,6 @@ class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
 
                 Uses the normalized JSON string of the skill name and arguments as the unique identifier.
         """
-        # Use object id as cache key
-        cache_key = id(skill_call)
-        if cache_key in self._call_key_cache:
-            return self._call_key_cache[cache_key]
-
         skill_name, arguments = self._extract_skill_info(skill_call)
 
         # Normalized parameters: sorting keys, ensuring consistency
@@ -175,7 +172,6 @@ class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
             normalized_args = str(arguments).strip()
 
         call_key = f"{skill_name}:{normalized_args}"
-        self._call_key_cache[cache_key] = call_key
         return call_key
 
     def _extract_skill_info(self, skill_call: Any) -> Tuple[str, Any]:
@@ -200,7 +196,29 @@ class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
             skill_name = str(skill_call)
             arguments = {}
 
-        return skill_name, arguments
+        return skill_name, self._normalize_arguments(arguments)
+
+    @staticmethod
+    def _normalize_arguments(arguments: Any) -> Any:
+        """Normalize arguments to improve deduplication stability.
+
+        Some callers may pass JSON strings (e.g., "{}") instead of dicts.
+        This method converts JSON strings into Python objects when possible.
+        """
+        if arguments is None:
+            return {}
+        if isinstance(arguments, str):
+            raw = arguments.strip()
+            if raw == "":
+                return {}
+            # Fast-path common empty payloads.
+            if raw in ("{}", "[]", "null"):
+                return {} if raw != "[]" else []
+            try:
+                return json.loads(raw)
+            except Exception:
+                return raw
+        return arguments
 
     def add(self, skill_call: Any, result: Optional[str] = None):
         """Add skill call record
@@ -248,6 +266,10 @@ class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
         """
         skill_name, arguments = self._extract_skill_info(skill_call)
 
+        # Polling tools are expected to be invoked repeatedly.
+        if skill_name in self._always_allow_duplicate_skills:
+            return True
+
         # Calls without arguments are not specially handled
         if not arguments:
             return False

dolphin/core/code_block/tool_block.py

@@ -2,10 +2,12 @@ from dolphin.core.code_block.basic_code_block import BasicCodeBlock
 from dolphin.core.utils.tools import ToolInterrupt
 from dolphin.core.common.enums import CategoryBlock, TypeStage
 from dolphin.core.context.context import Context
-from dolphin.core.logging.logger import console
+from dolphin.core.logging.logger import console, get_logger
 from dolphin.core.context.var_output import SourceType
 from typing import Optional, AsyncGenerator, Dict, Any
 
+logger = get_logger()
+
 
 class ToolBlock(BasicCodeBlock):
     def __init__(self, context: Context, debug_infos: Optional[dict] = None):
@@ -52,6 +54,10 @@ class ToolBlock(BasicCodeBlock):
 
                 tool_name = intervention_vars["tool_name"]
                 tool_call_info = intervention_vars["tool_call_info"]
+                
+                # *** FIX: Get saved stage_id for resume ***
+                saved_stage_id = intervention_vars.get("stage_id")
+                
                 self.context.delete_variable("intervention_tool_block_vars")
                 if self.recorder is not None:
                     self.recorder.set_output_var(
@@ -69,29 +75,67 @@ class ToolBlock(BasicCodeBlock):
                 raw_tool_args = input_dict["tool_args"]
                 new_tool_args = {arg["key"]: arg["value"] for arg in raw_tool_args}
 
-                props = {"intervention": False, "gvp": self.context}
-                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),
+                # *** FIX: Pass saved_stage_id to skill_run ***
+                props = {"intervention": False, "saved_stage_id": saved_stage_id, "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")
+
+                # 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()
@@ -103,9 +147,11 @@ class ToolBlock(BasicCodeBlock):
                 # step2: Obtain the tool object and execute the tool call
                 tool_name = tool_call_info["tool_name"]
 
+                # Save intervention vars (stage_id will be filled by skill_run after creating the stage)
                 intervention_vars = {
                     "tool_name": tool_call_info["tool_name"],
                     "tool_call_info": tool_call_info,
+                    "stage_id": None,  # Will be updated by skill_run() after stage creation
                 }
 
                 self.context.set_variable(

dolphin/core/common/constants.py

@@ -144,7 +144,31 @@ SEARCH_TIMEOUT = 10  # seconds for search API calls
 
 SEARCH_RETRY_COUNT = 2  # number of retries for failed search API calls
 
-MAX_SKILL_CALL_TIMES = 100
+MAX_SKILL_CALL_TIMES = 500
+
+# Plan orchestration tools (used for task management in plan mode)
+# These tools should be excluded from subtask contexts to prevent infinite recursion.
+PLAN_ORCHESTRATION_TOOLS = frozenset({
+    "_plan_tasks",      # Create and register subtasks
+    "_check_progress",  # Check task execution status
+    "_get_task_output", # Retrieve task results
+    "_wait",            # Wait for a specified duration
+    "_kill_task",       # Cancel a running task
+    "_retry_task",      # Retry a failed task
+})
+
+# Polling tools that are expected to be called repeatedly (excluded from deduplication)
+# These tools are used to check status/wait for async operations and should not trigger
+# duplicate-call termination in ExploreBlock.
+POLLING_TOOLS = frozenset({
+    "_check_progress",  # Plan mode: check task execution status
+    "_wait",            # Plan mode: wait for a specified duration
+})
+
+# Plan mode: maximum consecutive rounds without task status progress.
+# This only applies when an active plan exists and the agent is not using plan-related tools
+# (e.g., _wait / _check_progress). Set to 0 to disable.
+MAX_PLAN_SILENT_ROUNDS = 50
 
 # Compression constants
 MAX_ANSWER_COMPRESSION_LENGTH = 100

dolphin/core/config/global_config.py

@@ -1017,6 +1017,17 @@ class GlobalConfig:
 
     @staticmethod
     def from_dict(config_dict: dict, base_dir: str = None) -> "GlobalConfig":
+        # Load and apply flags configuration if present
+        if "flags" in config_dict:
+            from dolphin.core import flags
+            flags_config = config_dict.get("flags", {})
+            for flag_name, flag_value in flags_config.items():
+                try:
+                    flags.set_flag(flag_name, bool(flag_value))
+                except Exception as e:
+                    import logging
+                    logging.warning(f"Failed to set flag '{flag_name}': {e}")
+        
         is_new_config_format = "llms" in config_dict and "default" in config_dict
         if is_new_config_format:
             default_llm = config_dict.get("default")
@@ -1228,6 +1239,30 @@ class GlobalConfig:
         result = {
             "default": self.default_llm,
         }
+        
+        # Add flags configuration
+        from dolphin.core import flags
+        from dolphin.core.flags.definitions import DEFAULT_VALUES
+        import logging
+
+        flags_dict = flags.get_all()
+        non_default_flags = {}
+
+        for name, value in flags_dict.items():
+            if name in DEFAULT_VALUES:
+                # Only include flags that differ from their known defaults
+                if value != DEFAULT_VALUES[name]:
+                    non_default_flags[name] = value
+            else:
+                # Unknown flag (possibly user-defined) - include unconditionally with warning
+                logging.warning(
+                    f"Flag '{name}' is not in DEFAULT_VALUES, serializing unconditionally. "
+                    f"Consider adding it to dolphin.core.flags.definitions."
+                )
+                non_default_flags[name] = value
+
+        if non_default_flags:
+            result["flags"] = non_default_flags
 
         # Add fast_llm (if different from default_llm)
         if self.fast_llm and self.fast_llm != self.default_llm: