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

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
 
@@ -969,10 +982,13 @@ class Context:
         if bucket is None:
             bucket = BuildInBucket.SCRATCHPAD.value
 
-        # Empty the current bucket
-        self.context_manager.clear_bucket(bucket)
-        # Add new messages
-        self.context_manager.add_bucket(bucket, messages)
+        # Replace bucket content (or create if not exists)
+        if self.context_manager.has_bucket(bucket):
+            # Use replace_bucket_content to directly replace existing bucket
+            self.context_manager.replace_bucket_content(bucket, messages)
+        else:
+            # Create new bucket if it doesn't exist
+            self.context_manager.add_bucket(bucket, messages)
 
         # Mark as dirty
         self.messages_dirty = True
@@ -1422,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
@@ -1519,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
 
@@ -1578,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

dolphin/core/context/cow_context.py

@@ -0,0 +1,392 @@
+"""Copy-On-Write Context for Subtask Isolation.
+
+This module provides isolated context for subtasks in plan mode.
+
+Logging conventions:
+- DEBUG: Variable operations (set/delete/merge), initialization details
+- INFO: Significant events (merge completion with summary)
+- WARNING: Unexpected but recoverable situations
+- ERROR: Critical failures requiring attention
+"""
+
+import copy
+from typing import Any, Dict, Optional, Set
+
+from dolphin.core.common.types import SourceType, Var
+from dolphin.core.context.context import Context
+from dolphin.core.context_engineer.core.context_manager import ContextManager
+from dolphin.core.logging.logger import get_logger
+from dolphin.core.skill.skillset import Skillset
+from dolphin.core.context.variable_pool import VariablePool
+
+logger = get_logger("cow_context")
+
+
+class _TrackingVariablePool(VariablePool):
+    """A VariablePool that tracks COWContext writes/deletes.
+
+    This ensures that callers who bypass COWContext.set_variable()/delete_variable()
+    and directly mutate `context.variable_pool` still participate in copy-on-write
+    semantics and can be merged back to the parent context.
+    """
+
+    def __init__(self, owner: "COWContext"):
+        super().__init__()
+        self._owner = owner
+
+    def set_var(self, name, value):
+        super().set_var(name, value)
+        tracked_value = value.value if isinstance(value, Var) else value
+        self._owner.writes[name] = tracked_value
+        self._owner.deletes.discard(name)
+
+    def set_var_output(
+        self, name, value, source_type: SourceType = SourceType.OTHER, skill_info=None
+    ):
+        super().set_var_output(name, value, source_type=source_type, skill_info=skill_info)
+        # Track the user-facing value for merging behavior consistency.
+        self._owner.writes[name] = value
+        self._owner.deletes.discard(name)
+
+    def delete_var(self, name):
+        super().delete_var(name)
+        self._owner.deletes.add(name)
+        self._owner.writes.pop(name, None)
+
+
+class COWContext(Context):
+    """Copy-On-Write Context for subtask isolation.
+
+    Contract:
+    - Variables: COW isolation (read-through + local writes).
+    - Messages: isolated (subtask-local).
+    - Interrupt/output: delegated to parent for unified control and UI routing.
+    - Output events are tagged with task_id for UI routing.
+    """
+
+    def __init__(self, parent: Context, task_id: str):
+        """Initialize COWContext with parent and task ID.
+
+        Args:
+            parent: Parent context to delegate to
+            task_id: Task identifier for event tagging
+        """
+        super().__init__(
+            config=parent.config,
+            global_skills=parent.global_skills,
+            memory_manager=parent.memory_manager,
+            global_types=parent.global_types,
+            skillkit_hook=getattr(parent, "skillkit_hook", None),
+            context_manager=ContextManager(),
+            verbose=parent.verbose,
+            is_cli=parent.is_cli,
+        )
+
+        self.parent = parent
+        self.task_id = task_id
+        self.writes: Dict[str, Any] = {}
+        self.deletes: Set[str] = set()
+
+        # Create a new isolated VariablePool to prevent direct mutations to parent's pool.
+        # This ensures COW isolation even if code bypasses set_variable() and directly
+        # calls context.variable_pool.set_var().
+        self._parent_pool = parent.variable_pool  # Keep reference for read-through
+        self.variable_pool = _TrackingVariablePool(self)  # New empty pool for local writes (tracked)
+
+        # Isolate messages/buckets for subtask execution.
+        self.messages = {}
+        self.messages_dirty = True
+
+        # Keep IDs aligned for observability.
+        self.user_id = parent.user_id
+        self.session_id = parent.session_id
+        self.cur_agent = parent.cur_agent
+
+        # Share the interrupt event for cooperative cancellation.
+        self._interrupt_event = parent.get_interrupt_event()
+
+        # Subtasks must NOT be considered "plan-enabled" to avoid infinite loops.
+        self._plan_enabled = False
+        # Keep plan_id aligned for observability, while still disabling plan mode APIs.
+        self._plan_id = parent.get_plan_id()
+        self.task_registry = None
+
+        # Filter out orchestration-only tools (e.g., PlanSkillkit) from subtask toolset.
+        # Create a new isolated Skillset instead of referencing parent's skillkit directly
+        # to prevent permission escalation via context.skillkit.getSkills()
+        self._calc_all_skills()
+        self.all_skills = self._filter_subtask_skills(self.all_skills)
+        # Create a new Skillset that contains only filtered skills
+        # This ensures context.get_skill() and context.skillkit.getSkills() both respect filtering
+        filtered_skillkit = Skillset()
+        for skill in self.all_skills.getSkills():
+            filtered_skillkit.addSkill(skill)
+        self.skillkit = filtered_skillkit
+
+        # Inherit last-session configs where safe.
+        self._last_model_name = getattr(parent, "_last_model_name", None)
+        self._last_explore_mode = getattr(parent, "_last_explore_mode", None)
+        self._last_system_prompt = getattr(parent, "_last_system_prompt", None)
+        self._last_skills = None
+
+        logger.debug(f"COWContext initialized for task: {task_id}")
+
+    @staticmethod
+    def _filter_subtask_skills(skillset: Skillset) -> Skillset:
+        """Filter out skillkits that should not be exposed to subtasks."""
+        filtered = Skillset()
+        for skill in skillset.getSkills():
+            owner = None
+            if hasattr(skill, "get_owner_skillkit"):
+                owner = skill.get_owner_skillkit()
+            if owner is not None:
+                should_exclude = getattr(owner, "should_exclude_from_subtask", None)
+                if callable(should_exclude):
+                    try:
+                        if bool(should_exclude()):
+                            continue
+                    except Exception:
+                        # Fail-open: do not exclude if the hook misbehaves.
+                        pass
+            filtered.addSkill(skill)
+        return filtered
+
+    def get_variable(self, key: str, default_value: Any = None) -> Any:
+        """Get a variable (check local layer first, then parent).
+
+        Args:
+            key: Variable key
+            default_value: Default value if not found
+
+        Returns:
+            Variable value, or default_value if deleted or not found
+
+        Note:
+            Container types (list, dict, set) are deep-copied to prevent
+            accidental mutation of parent context's data through in-place operations
+            like list.append() or dict.update().
+        """
+        if key in self.deletes:
+            return default_value
+        # Check local variable_pool first (for compatibility with direct variable_pool.set_var()).
+        # NOTE: Variable values can legitimately be None, so use a sentinel to distinguish
+        # "missing key" vs "stored None".
+        sentinel = object()
+        local_value = self.variable_pool.get_var_value(key, sentinel)
+        if local_value is not sentinel:
+            return self._safe_copy_if_mutable(local_value, key)
+        # Check writes dict (explicit set_variable() calls)
+        if key in self.writes:
+            return self._safe_copy_if_mutable(self.writes[key], key)
+        # Fall back to parent context (keeps compatibility logic such as flags).
+        parent_value = self.parent.get_var_value(key, default_value)
+        return self._safe_copy_if_mutable(parent_value, key)
+
+    @staticmethod
+    def _safe_copy_if_mutable(value: Any, key: str) -> Any:
+        """Deep copy mutable container types to prevent accidental mutation.
+
+        Args:
+            value: Variable value
+            key: Variable key (for error reporting)
+
+        Returns:
+            Deep copy if value is a mutable container (list/dict/set or custom object),
+            original value otherwise.
+
+        Raises:
+            TypeError: If a mutable object cannot be deep-copied, ensuring isolation.
+
+        Note:
+            Isolation is guaranteed by deepcopy. If an object is not deepcopy-able,
+            it cannot be safely used in a COWContext as mutation would leak to parent.
+        """
+        if value is None:
+            return None
+
+        # Fast path for immutable primitives: return as-is
+        if isinstance(value, (str, int, float, bool, bytes)):
+            return value
+
+        # Mutable types (containers and custom objects): try deepcopy
+        try:
+            return copy.deepcopy(value)
+        except Exception as e:
+            # Item 3: Fail-fast for non-deepcopyable objects to ensure isolation.
+            logger.warning(
+                f"Isolation failure for variable '{key}': Object of type {type(value).__name__} is not deepcopyable. "
+                "Explicitly raising TypeError to prevent silent parent context corruption."
+            )
+            raise TypeError(
+                f"Cannot safely isolate variable '{key}': "
+                f"Object of type {type(value).__name__} is not deepcopyable. "
+                "Ensure task variables are serializable (e.g., data classes, dicts, primitives)."
+            ) from e
+
+    def get_var_value(self, key: str, default_value: Any = None) -> Any:
+        """Get variable value (alias for get_variable for Context compatibility).
+
+        Args:
+            key: Variable key
+            default_value: Default value if not found
+
+        Returns:
+            Variable value
+        """
+        return self.get_variable(key, default_value)
+
+    def set_variable(self, key: str, value: Any):
+        """Set a variable in the local layer only (copy-on-write).
+
+        Args:
+            key: Variable key
+            value: Variable value
+
+        Note:
+            This does NOT modify parent's variable_pool, ensuring isolation.
+            Use merge_to_parent() to propagate changes after task completion.
+            Updates both self.writes (tracking) and self.variable_pool (isolation).
+        """
+        self.writes[key] = value
+        self.deletes.discard(key)
+        # Update local variable_pool to catch both set_variable() and variable_pool.set_var() paths
+        self.variable_pool.set_var(key, value)
+        logger.debug(f"COWContext[{self.task_id}] set variable: {key}")
+
+    def delete_variable(self, key: str):
+        """Delete a variable in the local layer (tombstone, copy-on-write).
+
+        Args:
+            key: Variable key to delete
+
+        Note:
+            This does NOT modify parent's variable_pool, ensuring isolation.
+            The delete is recorded as a tombstone in self.deletes.
+        """
+        self.deletes.add(key)
+        self.writes.pop(key, None)
+        # Delete from local variable_pool to ensure isolation
+        self.variable_pool.delete_var(key)
+        logger.debug(f"COWContext[{self.task_id}] deleted variable: {key}")
+
+    def get_local_changes(self) -> Dict[str, Any]:
+        """Return all local writes.
+
+        Returns:
+            Dictionary of local variable writes
+        """
+        return self.writes.copy()
+
+    def clear_local_changes(self):
+        """Clear local writes and deletes to release memory.
+
+        Note:
+            This should be called after merge_to_parent() to free memory held by
+            intermediate variables. Useful for long-running subtasks that generate
+            many temporary variables (e.g., web scraping loops).
+
+        Warning:
+            Do NOT call this before merge_to_parent() unless you want to discard changes.
+        """
+        self.writes.clear()
+        self.deletes.clear()
+        # Also clear the local variable pool
+        if hasattr(self.variable_pool, 'clear'):
+            self.variable_pool.clear()
+        logger.debug(f"COWContext[{self.task_id}] cleared local changes to release memory")
+
+    def merge_to_parent(self, keys: Optional[Set[str]] = None):
+        """Merge local variable writes and deletes back to parent.
+
+        Args:
+            keys: Optional set of keys to merge (if None, merge all)
+
+        Note:
+            Merges both writes (set operations) and deletes (delete operations).
+        """
+        if keys:
+            # Selective merge
+            merged_count = 0
+            deleted_count = 0
+            for key in keys:
+                if key in self.deletes:
+                    self.parent.delete_variable(key)
+                    deleted_count += 1
+                elif key in self.writes:
+                    self.parent.set_variable(key, self.writes[key])
+                    merged_count += 1
+            logger.debug(
+                f"COWContext[{self.task_id}] merged {merged_count} variables, "
+                f"deleted {deleted_count} variables to parent"
+            )
+        else:
+            # Full merge
+            # First apply deletes
+            for key in self.deletes:
+                self.parent.delete_variable(key)
+            # Then apply writes
+            for key, value in self.writes.items():
+                self.parent.set_variable(key, value)
+            logger.debug(
+                f"COWContext[{self.task_id}] merged {len(self.writes)} variables, "
+                f"deleted {len(self.deletes)} variables to parent"
+            )
+
+    def check_user_interrupt(self) -> None:
+        """Delegate interrupt checks to parent."""
+        return self.parent.check_user_interrupt()
+
+    def write_output(self, event_type: str, data: Dict[str, Any]) -> None:
+        """Tag output events with task_id and forward to parent."""
+        payload = dict(data)
+        payload.setdefault("task_id", self.task_id)
+        payload.setdefault("plan_id", self.parent.get_plan_id())
+        return self.parent.write_output(event_type, payload)
+
+    def get_plan_id(self) -> Optional[str]:
+        """Expose parent plan_id for event tagging/observability."""
+        return self.parent.get_plan_id()
+
+    def enable_plan(self, plan_id: Optional[str] = None) -> None:
+        """Prevent nested plan orchestration in subtasks.
+
+        Raises:
+            RuntimeError: Always raises to prevent nested planning.
+
+        Note:
+            This is intentionally a hard error rather than a soft warning.
+            Subtasks should execute their assigned work, not create sub-plans.
+            The error message is designed to help models understand the constraint.
+        """
+        raise RuntimeError(
+            "Plan orchestration is not supported inside a subtask context. "
+            "Subtasks should focus on executing their assigned work directly. "
+            "If you need to break down the subtask further, return the breakdown "
+            "as part of your answer for the parent to orchestrate."
+        )
+
+    def __getattr__(self, name: str):
+        """Delegate unknown attributes to parent with special handling for skillkit.
+
+        Args:
+            name: Attribute name
+
+        Returns:
+            Attribute value from parent, or filtered skillkit for security
+
+        Raises:
+            AttributeError: If attribute not found in parent
+
+        Note:
+            Special handling for 'skillkit' attribute to prevent subtasks from
+            bypassing PLAN_ORCHESTRATION_TOOLS filtering by directly accessing
+            parent's skillkit via attribute delegation.
+        """
+        # Intercept skillkit access to return filtered version
+        if name == "skillkit":
+            # Return the filtered skillkit stored in __init__
+            # This prevents subtasks from accessing parent's unfiltered skillkit
+            return object.__getattribute__(self, name)
+
+        # Delegate all other attributes to parent
+        return getattr(self.parent, name)

dolphin/core/executor/dolphin_executor.py

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

dolphin/core/flags/definitions.py

@@ -16,13 +16,13 @@ Scope: Executor, DebugController
 """
 
 # =========== Disable LLM Cache ===========
-DISABLE_LLM_CACHE = "disable_llm_cache"
+DISABLE_LLM_CACHE = "llm_cache"
 """Disable LLM cache
 Scope: LLMClient
 """
 
 # =========== Multiple Tool Calls Support ===========
-ENABLE_PARALLEL_TOOL_CALLS = "enable_parallel_tool_calls"
+ENABLE_PARALLEL_TOOL_CALLS = "parallel_tool_calls"
 """Enable multiple tool calls support
 
 When enabled: