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

dolphin/cli/runner/runner.py

@@ -36,6 +36,22 @@ from dolphin.cli.interrupt.handler import InterruptToken
 from dolphin.cli.ui.layout import LayoutManager
 
 
+def _print_flags_status():
+    """Print current status of all feature flags."""
+    all_flags = flags.get_all()
+    for flag_name, flag_value in sorted(all_flags.items()):
+        state = "Enabled" if flag_value else "Disabled"
+        console(f"[Flag] {flag_name}: {state}")
+
+
+def _should_print_flags_status(args: Args) -> bool:
+    """Return whether feature flags should be printed to console."""
+    if flags.is_enabled(flags.DEBUG_MODE):
+        return True
+    log_level = str(getattr(args, "logLevel", "") or "").upper()
+    return log_level == "DEBUG"
+
+
 async def initializeEnvironment(args: Args):
     """Initialize Dolphin environment
     
@@ -51,6 +67,10 @@ async def initializeEnvironment(args: Args):
     globalConfigPath = args.config if args.config else "./config/global.yaml"
     globalConfig = GlobalConfig.from_yaml(globalConfigPath)
     
+    # Print flags status after loading config (flags may be set by config file)
+    if _should_print_flags_status(args):
+        _print_flags_status()
+    
     env = Env(
         globalConfig=globalConfig,
         agentFolderPath=args.folder,

dolphin/cli/ui/console.py

@@ -1347,6 +1347,15 @@ class ConsoleUI:
             elif v is None:
                 val_display = f"{Theme.NULL_VALUE}null{Theme.RESET}"
                 lines.append(f"  {Theme.PARAM_KEY}{display_key}{Theme.RESET}:{padding} {val_display}")
+            # Special case for tasks list in PlanSkillkit
+            elif key_lower == "tasks" and isinstance(v, list) and v and isinstance(v[0], dict):
+                lines.append(f"  {Theme.PARAM_KEY}{display_key}{Theme.RESET}:{padding}")
+                for i, task in enumerate(v[:10]):
+                    task_id = task.get("id", f"task_{i+1}")
+                    task_name = task.get("name", "Unnamed Task")
+                    lines.append(f"    {Theme.MUTED}•{Theme.RESET} [{Theme.SUCCESS}{task_id}{Theme.RESET}] {Theme.PARAM_VALUE}{task_name}{Theme.RESET}")
+                if len(v) > 10:
+                    lines.append(f"    {self._format_hidden_lines_hint(len(v) - 10, prefix=' ')}")
             else:
                 # Complex types: use existing json highlighter
                 val_display = self._highlight_json(v, indent=0, max_depth=1)
@@ -1738,14 +1747,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}"
@@ -2250,7 +2259,7 @@ class ConsoleUI:
                 print(f"     {Theme.MUTED}… +{len(details) - 10} more{Theme.RESET}")
 
     # ─────────────────────────────────────────────────────────────
-    # Plan-Specific Renderer (Unique Style for plan_act)
+    # Plan Renderer (Codex-style)
     # ─────────────────────────────────────────────────────────────
     
     def _get_visual_width(self, text: str) -> int:
@@ -2275,7 +2284,7 @@ class ConsoleUI:
         return width
 
     # ─────────────────────────────────────────────────────────────
-    # Plan-Specific Renderer (Unique Style for plan_act)
+    # Plan Renderer (Codex-style)
     # ─────────────────────────────────────────────────────────────
     
     def plan_update(
@@ -2289,10 +2298,10 @@ class ConsoleUI:
         verbose: Optional[bool] = None
     ) -> None:
         """
-        Render a complete plan update in a unique style for plan_act.
+        Render a complete plan update in a plan-focused visual style.
         
-        This is a specialized renderer that replaces the generic skill_call box
-        with a distinctive plan-focused visual design.
+        This renderer is intended for plan orchestration tools (e.g., plan_skillkit)
+        and can be used by callers who want a dedicated plan visualization.
         
         Args:
             tasks: List of tasks with 'content', 'status'
@@ -2756,10 +2765,15 @@ if __name__ == "__main__":
     
     # Demo skill call
     ui.skill_call_start(
-        "_plan_act",
+        "_plan_tasks",
         {
-            "planningMode": "create",
-            "taskList": "1. Load Excel file\n2. Analyze structure\n3. Generate insights"
+            "exec_mode": "seq",
+            "max_concurrency": 3,
+            "tasks": [
+                {"id": "task_1", "name": "Load Excel file", "prompt": "Load the Excel file"},
+                {"id": "task_2", "name": "Analyze structure", "prompt": "Analyze the file structure"},
+                {"id": "task_3", "name": "Generate insights", "prompt": "Generate key insights"},
+            ],
         }
     )
     
@@ -2767,11 +2781,15 @@ if __name__ == "__main__":
     time.sleep(0.5)
     
     ui.skill_call_end(
-        "_plan_act",
+        "_plan_tasks",
         {
             "status": "success",
-            "tasks": ["Task 1", "Task 2", "Task 3"],
-            "nextStep": "Execute Task 1"
+            "tasks": [
+                {"id": "task_1", "name": "Load Excel file"},
+                {"id": "task_2", "name": "Analyze structure"},
+                {"id": "task_3", "name": "Generate insights"},
+            ],
+            "next_step": "Execute task_1",
         },
         duration_ms=156.3
     )

dolphin/cli/utils/helpers.py

@@ -115,6 +115,10 @@ def setupFlagsFromArgs(args: Args) -> None:
     
     Args:
         args: Parsed CLI arguments
+        
+    Note:
+        Flags status may be printed after config is loaded in initializeEnvironment()
+        when running in debug/verbose logging modes.
     """
     from dolphin.core import flags
     
@@ -129,7 +133,3 @@ def setupFlagsFromArgs(args: Args) -> None:
             boolValue = bool(flagValue)
         
         flags.set_flag(flagName, boolValue)
-        # Cleaner flag output
-        state = "Enabled" if boolValue else "Disabled"
-        console(f"[Flag] {flagName}: {state}")
-

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)
+                    frame_error = getattr(self._current_frame, "error", None) if self._current_frame else None
+                    if run_result.is_tool_interrupted and 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

@@ -90,8 +90,12 @@ class BasicCodeBlock:
         self.recorder: Optional[Recorder] = None
         # tool_choice support (auto|none|required|provider-specific)
         self.tool_choice: Optional[str] = None
-        # Whether to enable skill deduplication (used only in explore blocks, enabled by default)
-        self.enable_skill_deduplicator: bool = True
+        # Whether to enable skill deduplication (used only in explore blocks)
+        # Default is False to avoid incorrectly blocking legitimate repeated detection/polling tool calls.
+        # Recent observations show that deduplication can prematurely stop valid polling scenarios
+        # (e.g., repeatedly checking task status until completion).
+        # Set to True explicitly via /explore/(enable_skill_deduplicator=true) when needed.
+        self.enable_skill_deduplicator: bool = False
         self.skills = None
         self.system_prompt = ""
 
@@ -115,6 +119,26 @@ class BasicCodeBlock:
             if context:
                 context.set_skillkit_hook(self.skillkit_hook)
 
+    @staticmethod
+    def _normalize_bool_param(value: Any, default: bool) -> bool:
+        """Normalize boolean-like params from DPH parsing.
+
+        DPH params may be parsed as strings such as "true"/"false".
+        """
+        if isinstance(value, bool):
+            return value
+        if value is None:
+            return default
+        if isinstance(value, (int, float)):
+            return bool(value)
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"true", "1", "yes", "y", "on"}:
+                return True
+            if normalized in {"false", "0", "no", "n", "off"}:
+                return False
+        return default
+
     def validate(self, content):
         """Verify the correctness of the content
         :param content: The content to be verified
@@ -658,11 +682,11 @@ class BasicCodeBlock:
         self._validate_skills()
 
         self.ttc_mode = params_dict.get("ttc_mode", None)
-        self.no_cache = params_dict.get("no_cache", False)
+        self.no_cache = self._normalize_bool_param(params_dict.get("no_cache", False), False)
         self.flags = params_dict.get("flags", "")
         # 是否启用技能调用去重（仅 explore 块会实际使用该参数）
-        self.enable_skill_deduplicator = params_dict.get(
-            "enable_skill_deduplicator", True
+        self.enable_skill_deduplicator = self._normalize_bool_param(
+            params_dict.get("enable_skill_deduplicator", False), False
         )
 
         # 处理输出格式参数
@@ -1133,6 +1157,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
@@ -1149,23 +1174,79 @@ class BasicCodeBlock:
             return
 
         # Create initial SKILL stage to track skill execution start
-        assert self.recorder, "recorder is None"
-        self.recorder.getProgress().add_stage(
-            agent_name=skill_name,
-            stage=TypeStage.SKILL,
-            status=Status.PROCESSING,
-            skill_info=SkillInfo.build(
-                skill_type=SkillType.TOOL,
-                skill_name=skill_name,
-                skill_args=skill_params_json,
-            ),
-            input_content=str(skill_params_json),
-            interrupted=False,
-        )
+        # Only create new stage if this is a new tool call (intervention=True)
+        # For resumed tool calls (intervention=False), update the existing stage using saved_stage_id
+        if props is None:
+            props = {}
+        
+        is_resumed_call = not props.get('intervention', True)
+        saved_stage_id = props.get('saved_stage_id')
+        
+        if not is_resumed_call:
+            # First-time call: create new Stage
+            assert self.recorder, "recorder is None"
+            self.recorder.getProgress().add_stage(
+                agent_name=skill_name,
+                stage=TypeStage.SKILL,
+                status=Status.PROCESSING,
+                skill_info=SkillInfo.build(
+                    skill_type=SkillType.TOOL,
+                    skill_name=skill_name,
+                    skill_args=skill_params_json,
+                ),
+                input_content=str(skill_params_json),
+                interrupted=False,
+            )
+            
+            # ✅ FIX: Save the newly created Stage ID to intervention_vars for potential interrupt
+            # This must be done AFTER creating the stage, not before
+            # Determine the correct intervention_vars key based on source_type
+            progress = self.recorder.getProgress()
+            if len(progress.stages) > 0:
+                new_stage_id = progress.stages[-1].id
+                
+                # Map source_type to intervention_vars key
+                # Priority: judge_block > tool_block (both use SourceType.SKILL) > explore_block
+                var_key = None
+                intervention_vars = None
+                
+                if source_type == SourceType.EXPLORE:
+                    var_key = "intervention_explore_block_vars"
+                    intervention_vars = self.context.get_var_value(var_key)
+                elif source_type == SourceType.SKILL:
+                    # Check judge block first (also uses SourceType.SKILL)
+                    judge_vars = self.context.get_var_value("intervention_judge_block_vars")
+                    if judge_vars is not None:
+                        var_key = "intervention_judge_block_vars"
+                        intervention_vars = judge_vars
+                    else:
+                        var_key = "intervention_tool_block_vars"
+                        intervention_vars = self.context.get_var_value(var_key)
+                
+                # Update the intervention_vars with the correct Stage ID
+                if intervention_vars is not None and var_key is not None:
+                    intervention_vars["stage_id"] = new_stage_id
+                    self.context.set_variable(var_key, intervention_vars)
 
-        # notify app
-        async for result in self.yield_message(answer="", think=""):
-            yield result
+            # notify app
+            async for result in self.yield_message(answer="", think=""):
+                yield result
+        else:
+            # *** FIX: Resumed call - Set _next_stage_id to use saved ID ***
+            # Don't create stage here; let the normal flow handle it
+            # This avoids creating extra stages and ensures consistency
+            assert self.recorder, "recorder is None"
+            
+            if saved_stage_id:
+                # Set _next_stage_id so the next add_stage() call will use this ID
+                progress = self.recorder.getProgress()
+                progress._next_stage_id = saved_stage_id
+                logger.debug(f"Resumed tool call for {skill_name}, set _next_stage_id = {saved_stage_id}")
+            else:
+                logger.debug(f"Resumed tool call for {skill_name}, no saved_stage_id provided")
+            
+            # NOTE: Do NOT call yield_message() in resume branch!
+            # The resumed tool execution will create the stage naturally through recorder.update()
 
         agent_as_skill = self.context.get_agent_skill(skill)
         if agent_as_skill is not None:
@@ -1195,10 +1276,39 @@ class BasicCodeBlock:
         have_answer = False
         cur_agent = self.context.get_cur_agent()
 
-        if props is None:
-            props = {}
+        # props already initialized above, just update it
         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)
+                
+                if interrupt_config and interrupt_config.get('requires_confirmation'):
+                    # 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
+                    )
+            
             console_skill_call(
                 skill_name, skill_params_json, verbose=self.context.verbose, skill=skill
             )
@@ -1274,13 +1384,33 @@ class BasicCodeBlock:
             if agent_as_skill is not None:
                 self.context.set_cur_agent(cur_agent)
 
-            yield self.recorder.update(
+            # *** FIX: Update stage status to COMPLETED ***
+            # This updates the stage status and triggers set_variable() to update _progress in context
+            self.recorder.update(
                 item=result,
                 source_type=SourceType.SKILL,
                 skill_name=skill_name,
                 skill_args=skill_params_json,
                 is_completed=True,
             )
+            
+            # *** FIX: Yield completion update in a format that explore_block_v2 recognizes ***
+            # Use a nested structure that matches the check in explore_block_v2.py line 422-427
+            # This prevents explore_block_v2 from calling recorder.update() again
+            if self.context:
+                progress_var = self.context.get_var_value("_progress")
+                completion_data = {
+                    "answer": {
+                        "answer": result.get("output") if isinstance(result, dict) else str(result),
+                        "think": "",
+                    },
+                    "_status": "running",
+                    "_progress": progress_var if progress_var else []
+                }
+                yield completion_data
+            else:
+                yield result
+            
             if agent_as_skill is not None:
                 console_agent_skill_exit(skill_name, verbose=self.context.verbose)
         except ToolInterrupt as e:
@@ -1410,6 +1540,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.
@@ -1829,7 +1965,7 @@ class BasicCodeBlock:
                         f"[_load_dynamic_tools] self.skills does not exist on {type(self).__name__}"
                     )
 
-                self.context.debug(f"✓ Dynamically loaded tool: {tool_name}")
+                self.context.debug(f"[OK] Dynamically loaded tool: {tool_name}")
 
             except Exception as e:
                 tool_name = (
@@ -1837,7 +1973,7 @@ class BasicCodeBlock:
                     if isinstance(tool_def, dict)
                     else "unknown"
                 )
-                self.context.error(f"✗ Failed to load dynamic tool {tool_name}: {e}")
+                self.context.error(f"[ERROR] Failed to load dynamic tool {tool_name}: {e}")
                 import traceback
 
                 self.context.debug(f"Error traceback: {traceback.format_exc()}")