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

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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kweaver-dolphin"
-version = "0.2.0"
+version = "0.2.2"
 description = "Dolphin Language - An intelligent agent framework"
 authors = [
     {name = "AnyData", email = "contact@anydata.com"}
@@ -82,26 +82,13 @@ search = "dolphin.lib.skillkits.search_skillkit:SearchSkillkit"
 sql = "dolphin.lib.skillkits.sql_skillkit:SQLSkillkit"
 memory = "dolphin.lib.skillkits.memory_skillkit:MemorySkillkit"
 ontology = "dolphin.lib.skillkits.ontology_skillkit:OntologySkillkit"
-plan_act = "dolphin.lib.skillkits.plan_act_skillkit:PlanActSkillkit"
+plan = "dolphin.lib.skillkits.plan_skillkit:PlanSkillkit"
 cognitive = "dolphin.lib.skillkits.cognitive_skillkit:CognitiveSkillkit"
 vm = "dolphin.lib.skillkits.vm_skillkit:VMSkillkit"
 noop = "dolphin.lib.skillkits.noop_skillkit:NoopSkillkit"
 mcp = "dolphin.lib.skillkits.mcp_skillkit:MCPSkillkit"
 resource = "dolphin.lib.skillkits.resource_skillkit:ResourceSkillkit"
-env_skillkit = "dolphin.lib.skillkits.env_skillkit:EnvSkillkit"
-
-# Legacy entry points (for backward compatibility)
-[project.entry-points."DolphinLanguageSDK.skillkits"]
-search = "DolphinLanguageSDK.skill.installed.search_skillkit:SearchSkillkit"
-sql = "DolphinLanguageSDK.skill.installed.sql_skillkit:SQLSkillkit"
-memory = "DolphinLanguageSDK.skill.installed.memory_skillkit:MemorySkillkit"
-ontology = "DolphinLanguageSDK.skill.installed.ontology_skillkit:OntologySkillkit"
-plan_act = "DolphinLanguageSDK.skill.installed.plan_act_skillkit:PlanActSkillkit"
-cognitive = "DolphinLanguageSDK.skill.installed.cognitive_skillkit:CognitiveSkillkit"
-vm = "DolphinLanguageSDK.skill.installed.vm_skillkit:VMSkillkit"
-noop = "DolphinLanguageSDK.skill.installed.noop_skillkit:NoopSkillkit"
-mcp = "DolphinLanguageSDK.skill.installed.mcp_skillkit:MCPSkillkit"
-resource_skillkit = "DolphinLanguageSDK.skill.installed.resource_skillkit:ResourceSkillkit"
+env = "dolphin.lib.skillkits.env_skillkit:EnvSkillkit"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{kweaver_dolphin-0.2.0 → kweaver_dolphin-0.2.2}/src/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,

{kweaver_dolphin-0.2.0 → kweaver_dolphin-0.2.2}/src/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)
@@ -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
     )

{kweaver_dolphin-0.2.0 → kweaver_dolphin-0.2.2}/src/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}")
-

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

@@ -423,8 +423,8 @@ class BaseAgent(ABC):
                     }
                     
                     # 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
+                    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", ""),

{kweaver_dolphin-0.2.0 → kweaver_dolphin-0.2.2}/src/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
         )
 
         # 处理输出格式参数
@@ -1150,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:
@@ -1196,8 +1276,7 @@ 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)
@@ -1205,10 +1284,8 @@ class BasicCodeBlock:
             # 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:
@@ -1231,8 +1308,6 @@ class BasicCodeBlock:
                         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
@@ -1309,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:
@@ -1849,6 +1944,21 @@ class BasicCodeBlock:
                     )
                     continue
 
+                # SDK automatically adds interrupt_config to ALL dynamically loaded tools
+                # This ensures dynamic tools require user confirmation for safety
+                # Dynamic tools do not need to provide interrupt_config themselves
+                tool_description = tool_def.get("description", tool_name)
+                auto_interrupt_config = {
+                    "requires_confirmation": True,
+                    "confirmation_message": (
+                        f"即将调用「{tool_name}」工具，是否确认执行？"
+                    )
+                }
+                tool_instance.interrupt_config = auto_interrupt_config
+                self.context.debug(
+                    f"[_load_dynamic_tools] Auto-applied interrupt protection to dynamic tool: {tool_name}"
+                )
+
                 # Add tool instance to skillkit
                 current_skillkit.addSkill(tool_instance)
                 loaded_count += 1
@@ -1870,7 +1980,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 = (
@@ -1878,7 +1988,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()}")