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

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,7 +153,8 @@ 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__")
@@ -202,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": {
@@ -210,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,7 +75,8 @@ 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}
+                # *** 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__")
@@ -81,7 +88,7 @@ class ToolBlock(BasicCodeBlock):
                 if skip_message:
                     self.context.delete_variable("__skip_message__")
                 
-                input_dict = self.context.delete_variable("tool")
+                self.context.delete_variable("tool")
 
                 # If user chose to skip, don't execute the tool
                 if skip_tool:
@@ -140,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:

dolphin/core/context/context.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import json
+import time
 from datetime import datetime
 from typing import Dict, List, Optional, Any, Union, TYPE_CHECKING
 
@@ -104,6 +105,18 @@ class Context:
         # User interrupt event (injected by Agent layer for cooperative cancellation)
         self._interrupt_event: Optional[asyncio.Event] = None
 
+        # Plan Mode support (unified architecture)
+        self._plan_enabled: bool = False
+        self._plan_id: Optional[str] = None
+        self.task_registry: Optional["TaskRegistry"] = None
+
+        # Nesting level tracking (to prevent infinite recursion in plan mode)
+        # Incremented when fork() is called
+        self._nesting_level: int = 0
+
+        # Output event buffer (for UI/SDK consumption)
+        self._output_events: List[Dict[str, Any]] = []
+
     def set_skillkit_hook(self, skillkit_hook: "SkillkitHook"):
         """Set skillkit_hook"""
         self.skillkit_hook = skillkit_hook
@@ -471,7 +484,7 @@ class Context:
         return result_skillset
 
     def _inject_detail_skill_if_needed(self, skillset: Skillset):
-        """Auto-inject _get_result_detail if any skill uses omitting modes (SUMMARY/REFERENCE)"""
+        """Auto-inject _get_cached_result_detail if any skill uses omitting modes (SUMMARY/REFERENCE)"""
         try:
             from dolphin.core.skill.context_retention import ContextRetentionMode
             from dolphin.lib.skillkits.system_skillkit import SystemFunctions
@@ -494,16 +507,16 @@ class Context:
         if should_inject:
             # Check if already exists in skillset
             has_detail_skill = any(
-                "_get_result_detail" in s.get_function_name() 
+                "_get_cached_result_detail" in s.get_function_name()
                 for s in skills
             )
             
             if not has_detail_skill:
                 # Try to get the skill from SystemFunctions
                 # We try different name variations just in case
-                detail_skill = SystemFunctions.getSkill("_get_result_detail")
+                detail_skill = SystemFunctions.getSkill("_get_cached_result_detail")
                 if not detail_skill:
-                    detail_skill = SystemFunctions.getSkill("system_functions._get_result_detail")
+                    detail_skill = SystemFunctions.getSkill("system_functions._get_cached_result_detail")
                 
                 # If still not found (e.g. SystemFunctions not initialized with it), we can pick it manually if possible
                 # But typically SystemFunctions singleton has it.
@@ -512,7 +525,7 @@ class Context:
                 else:
                     # Fallback: look through SystemFunctions.getSkills() manually
                     for s in SystemFunctions.getSkills():
-                        if "_get_result_detail" in s.get_function_name():
+                        if "_get_cached_result_detail" in s.get_function_name():
                             skillset.addSkill(s)
                             break
 
@@ -1425,6 +1438,10 @@ class Context:
             "session_id": self.session_id,
             "cur_agent": self.cur_agent.getName() if self.cur_agent else None,
             "max_answer_len": self.max_answer_len,
+            "plan_enabled": self._plan_enabled,
+            "plan_id": self._plan_id,
+            "task_registry": self.task_registry.to_dict() if self.task_registry else None,
+            "nesting_level": self._nesting_level,
         }
 
         # Export skill set status
@@ -1522,6 +1539,19 @@ class Context:
                 "max_answer_len", MAX_ANSWER_CONTENT_LENGTH
             )
 
+            # Restore plan state
+            self._plan_enabled = runtime_state.get("plan_enabled", False)
+            self._plan_id = runtime_state.get("plan_id")
+            
+            task_registry_data = runtime_state.get("task_registry")
+            if task_registry_data:
+                from dolphin.core.task_registry import TaskRegistry
+                self.task_registry = TaskRegistry.from_dict(task_registry_data)
+            else:
+                self.task_registry = None
+
+            self._nesting_level = runtime_state.get("nesting_level", 0)
+
             # Resume the current agent (to be handled in the calling function above)
             # The restoration of self.cur_agent requires external coordination
 
@@ -1581,3 +1611,136 @@ class Context:
         """Clear the interrupt status (called when resuming execution)."""
         if self._interrupt_event is not None:
             self._interrupt_event.clear()
+
+    # === Output Events API ===
+
+    def write_output(self, event_type: "str | OutputEventType", data: Dict[str, Any]) -> None:
+        """Record an output event for UI/SDK consumers.
+
+        Args:
+            event_type: Event type (OutputEventType enum or string for backward compatibility)
+            data: Event payload data
+
+        Notes:
+            - This is an in-memory buffer only (process-local).
+            - Consumers can call drain_output_events() to fetch and clear.
+            - Prefer using OutputEventType enum for type safety.
+        """
+        from dolphin.core.task_registry import OutputEventType
+
+        # Convert enum to string for backward compatibility
+        event_type_str = event_type.value if isinstance(event_type, OutputEventType) else event_type
+
+        event = {
+            "event_type": event_type_str,
+            "data": data,
+            "timestamp_ms": int(time.time() * 1000),
+        }
+        self._output_events.append(event)
+
+    def drain_output_events(self) -> List[Dict[str, Any]]:
+        """Drain and clear buffered output events."""
+        events = self._output_events
+        self._output_events = []
+        return events
+
+    # === Plan Mode API ===
+
+    async def enable_plan(self, plan_id: Optional[str] = None) -> None:
+        """Enable plan mode (lazy initialization).
+
+        This method can be called multiple times for replan scenarios.
+
+        Args:
+            plan_id: Optional plan identifier (auto-generated if not provided)
+
+        Behavior:
+            - First call: Creates TaskRegistry
+            - Subsequent calls (replan): Generates new plan_id, resets TaskRegistry
+        """
+        import uuid
+        from dolphin.core.task_registry import TaskRegistry
+
+        if not self._plan_enabled:
+            self._plan_enabled = True
+            self.task_registry = TaskRegistry()
+            logger.info("Plan mode enabled")
+        else:
+            # Replan: cancel running tasks and reset registry
+            if self.task_registry:
+                cancelled = await self.task_registry.cancel_all_running()
+                if cancelled > 0:
+                    logger.info(f"Replan: cancelled {cancelled} running tasks")
+                await self.task_registry.reset()
+            logger.info("Plan mode replan triggered")
+
+        self._plan_id = plan_id or str(uuid.uuid4())
+        logger.debug(f"Plan ID: {self._plan_id}")
+
+    async def disable_plan(self) -> None:
+        """Disable plan mode and cleanup resources."""
+        if self.task_registry:
+            await self.task_registry.cancel_all_running()
+            self.task_registry = None
+        self._plan_enabled = False
+        self._plan_id = None
+        logger.info("Plan mode disabled")
+
+    def is_plan_enabled(self) -> bool:
+        """Check if plan mode is enabled.
+
+        Returns:
+            True if plan mode is enabled, False otherwise
+        """
+        return self._plan_enabled
+
+    async def has_active_plan(self) -> bool:
+        """Check if there is an active plan with non-terminal tasks.
+
+        Returns:
+            True if plan is enabled, has tasks, and not all tasks are done
+        """
+        if not self._plan_enabled:
+            return False
+        if not self.task_registry or not await self.task_registry.has_tasks():
+            return False
+        return not await self.task_registry.is_all_done()
+
+    def get_plan_id(self) -> Optional[str]:
+        """Get the current plan ID.
+
+        Returns:
+            Plan ID string, or None if plan mode is not enabled
+        """
+        return self._plan_id
+
+    def fork(self, task_id: str) -> "COWContext":
+        """Create a Copy-On-Write child context for subtask isolation.
+
+        Args:
+            task_id: Task identifier for the child context
+
+        Returns:
+            COWContext instance that isolates writes
+
+        Raises:
+            RuntimeError: If nesting level exceeds maximum allowed depth (3 levels)
+
+        Note:
+            Maximum nesting depth is enforced to prevent memory overflow from
+            deeply nested subtasks (e.g., subtask creates subtask creates subtask...).
+        """
+        MAX_NESTING_LEVEL = 3
+
+        if self._nesting_level >= MAX_NESTING_LEVEL:
+            raise RuntimeError(
+                f"Maximum subtask nesting depth ({MAX_NESTING_LEVEL}) exceeded. "
+                f"Current level: {self._nesting_level}. "
+                "Deeply nested subtasks can cause memory overflow. "
+                "Consider flattening your task structure or breaking it into sequential steps."
+            )
+
+        from dolphin.core.context.cow_context import COWContext
+        child = COWContext(self, task_id)
+        child._nesting_level = self._nesting_level + 1
+        return child