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

dolphin/core/llm/llm.py

@@ -249,7 +249,6 @@ class LLMModelFactory(LLM):
             finish_reason = None
             # Use ToolCallsParser to handle tool calls parsing
             tool_parser = ToolCallsParser()
-
             timeout = aiohttp.ClientTimeout(
                 total=1800,  # Disable overall timeout (use with caution)
                 sock_connect=30,  # Keep connection timeout
@@ -320,7 +319,7 @@ class LLMModelFactory(LLM):
 
                                     accu_content += delta_content
                                     reasoning_content += delta_reasoning
-                                    
+
                                     # Capture finish_reason
                                     chunk_finish_reason = line_json["choices"][0].get("finish_reason")
                                     if chunk_finish_reason:
@@ -461,7 +460,7 @@ class LLMOpenai(LLM):
                 and delta.reasoning_content is not None
             ):
                 accu_reasoning += delta.reasoning_content
-            
+
             # Capture finish_reason
             chunk_finish_reason = chunk.choices[0].finish_reason
             if chunk_finish_reason:

dolphin/core/llm/llm_client.py

@@ -182,6 +182,7 @@ class LLMClient:
                 sock_connect=30,  # Keep connection timeout
                 sock_read=300,  # Single read timeout (for slow streaming data)
             )
+            print(f"------------------------llm={payload}")
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 async with session.post(
                     model_config.api,

dolphin/core/runtime/runtime_instance.py

@@ -1,4 +1,5 @@
 from enum import Enum
+import logging
 import time
 from typing import List, Optional, TYPE_CHECKING
 import uuid
@@ -6,6 +7,8 @@ import uuid
 from dolphin.core.common.enums import Messages, SkillInfo, Status, TypeStage
 from dolphin.core.common.constants import estimate_tokens_from_chars
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from dolphin.core.agent.base_agent import BaseAgent
     from dolphin.core.code_block.basic_code_block import BasicCodeBlock
@@ -292,6 +295,7 @@ class ProgressInstance(RuntimeInstance):
         self.context = context
         self.stages: List[StageInstance] = []
         self.flags = flags
+        self._next_stage_id: Optional[str] = None  # ✅ NEW: for interrupt resume
 
     def add_stage(
         self,
@@ -306,6 +310,7 @@ class ProgressInstance(RuntimeInstance):
         input_content: str = "",
         input_messages: Optional[Messages] = None,
         interrupted: bool = False,
+        stage_id: Optional[str] = None,  # ✅ NEW: support custom stage_id for resume
     ):
         pop_last_stage = False
         if len(self.stages) > 0 and self.stages[-1].llm_empty_answer():
@@ -325,6 +330,15 @@ class ProgressInstance(RuntimeInstance):
             interrupted=interrupted,
             flags=self.flags,
         )
+        
+        # ✅ NEW: Override ID if custom stage_id is provided (for interrupt resume)
+        # Priority: explicit stage_id parameter > _next_stage_id temporary variable
+        if stage_id is not None:
+            stage_instance.id = stage_id
+        elif self._next_stage_id is not None:
+            stage_instance.id = self._next_stage_id
+            self._next_stage_id = None  # Clear after use (one-time only)
+        
         self.add_stage_instance(stage_instance, pop_last_stage)
 
     def add_stage_instance(
@@ -333,6 +347,7 @@ class ProgressInstance(RuntimeInstance):
         stage_instance.set_parent(self)
         if pop_last_stage:
             self.stages.pop()
+        
         self.stages.append(stage_instance)
 
         # Register stage instance to runtime_graph if available
@@ -376,6 +391,22 @@ class ProgressInstance(RuntimeInstance):
         # Check if we need to create a new stage (when stage type changes)
         last_stage = self.stages[-1]
 
+        # *** FIX: If _next_stage_id is set and doesn't match last stage, create new stage ***
+        # This handles resume cases where we need to create a stage with a specific ID
+        if self._next_stage_id is not None and self._next_stage_id != last_stage.id:
+            logger.debug(f"_next_stage_id ({self._next_stage_id}) != last_stage.id ({last_stage.id}), creating new stage for resume")
+            self.add_stage(
+                stage=stage if stage is not None else last_stage.stage,
+                answer=answer,
+                think=think,
+                raw_output=raw_output,
+                status=status,
+                skill_info=skill_info,
+                block_answer=block_answer,
+                input_messages=input_messages,
+            )
+            return
+
         # Create new stage if stage type is changing (and it's not None)
         if stage is not None and stage != last_stage.stage:
             self.add_stage(

dolphin/core/skill/context_retention.py

@@ -54,7 +54,7 @@ class SummaryContextStrategy(ContextRetentionStrategy):
         # Provide reference_id so LLM can fetch full content if needed
         ref_hint = ""
         if reference_id:
-            ref_hint = f"\n[For full content, call _get_result_detail('{reference_id}')]"
+            ref_hint = f"\n[For full content, call _get_cached_result_detail('{reference_id}', scope='skill')]"
         
         omitted = len(result) - head_chars - tail_chars
         # Ensure we don't have negative omission if rounding puts us over
@@ -114,8 +114,8 @@ class ReferenceContextStrategy(ContextRetentionStrategy):
         hint = config.reference_hint or "Full result stored"
         return (f"[{hint}]\n"
                 f"Original length: {len(result)} chars\n"
-                f"Get full content: _get_result_detail('{reference_id}')\n"
-                f"Get range: _get_result_detail('{reference_id}', offset=0, limit=2000)")
+                f"Get full content: _get_cached_result_detail('{reference_id}', scope='skill')\n"
+                f"Get range: _get_cached_result_detail('{reference_id}', scope='skill', offset=0, limit=2000)")
 
 
 # Strategy mapping

dolphin/core/task_registry.py

@@ -0,0 +1,404 @@
+"""Task Registry for Plan Mode.
+
+This module provides task state management for unified plan architecture.
+
+Logging conventions:
+- DEBUG: Task registration, status updates, cancellations
+- INFO: Registry lifecycle events (reset, mode changes)
+- WARNING: Invalid operations (unknown task, missing registry)
+- ERROR: Critical failures in task management
+"""
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from dolphin.core.logging.logger import get_logger
+
+logger = get_logger("task_registry")
+
+
+class OutputEventType(str, Enum):
+    """Output event types for UI/SDK consumers.
+
+    These events are emitted via Context.write_output() and can be consumed
+    by UI components or SDK integrations for real-time updates.
+    """
+    TASK_STARTED = "task_started"
+    TASK_COMPLETED = "task_completed"
+    TASK_FAILED = "task_failed"
+    TASK_CANCELLED = "task_cancelled"
+    TASK_PROGRESS = "task_progress"
+    PLAN_CREATED = "plan_created"
+    PLAN_UPDATED = "plan_updated"
+    PLAN_FINISHED = "plan_finished"
+
+
+class TaskStatus(str, Enum):
+    """Task status values."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    SKIPPED = "skipped"
+
+
+class PlanExecMode(str, Enum):
+    """Execution mode for plan orchestration."""
+    PARALLEL = "parallel"
+    SEQUENTIAL = "sequential"
+
+    @staticmethod
+    def from_str(mode: str) -> "PlanExecMode":
+        """Convert a string (seq/para/sequential/parallel) to PlanExecMode."""
+        if not mode:
+            return PlanExecMode.PARALLEL
+        
+        mode = mode.lower().strip()
+        if mode in ("seq", "sequential"):
+            return PlanExecMode.SEQUENTIAL
+        if mode in ("para", "parallel"):
+            return PlanExecMode.PARALLEL
+        
+        raise ValueError(f"Invalid execution mode: {mode}. Must be 'seq' or 'para'.")
+
+
+@dataclass
+class Task:
+    """Task metadata and state."""
+    id: str
+    name: str
+    prompt: str
+
+    # Runtime fields
+    status: TaskStatus = TaskStatus.PENDING
+    answer: Optional[str] = None
+    think: Optional[str] = None
+    block_answer: Optional[str] = None
+    error: Optional[str] = None
+    started_at: Optional[float] = None
+    duration: Optional[float] = None
+    attempt: int = 0
+
+    # Reserved for Phase 2
+    depends_on: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert Task to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "prompt": self.prompt,
+            "status": self.status.value,
+            "answer": self.answer,
+            "think": self.think,
+            "block_answer": self.block_answer,
+            "error": self.error,
+            "started_at": self.started_at,
+            "duration": self.duration,
+            "attempt": self.attempt,
+            "depends_on": self.depends_on,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Task":
+        """Create Task from dictionary."""
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            prompt=data["prompt"],
+            status=TaskStatus(data["status"]),
+            answer=data.get("answer"),
+            think=data.get("think"),
+            block_answer=data.get("block_answer"),
+            error=data.get("error"),
+            started_at=data.get("started_at"),
+            duration=data.get("duration"),
+            attempt=data.get("attempt", 0),
+            depends_on=data.get("depends_on", []),
+        )
+
+
+class TaskRegistry:
+    """Persistent task state registry.
+
+    Notes:
+    - Stores only serializable task state.
+    - Runtime handles (asyncio.Task) are kept outside for correctness and recoverability.
+    - Thread-safe via asyncio.Lock.
+    """
+
+    def __init__(self):
+        self.tasks: Dict[str, Task] = {}
+        self._lock = asyncio.Lock()
+
+        # Config fields (set by PlanSkillkit._plan_tasks)
+        self.exec_mode: PlanExecMode = PlanExecMode.PARALLEL
+        self.max_concurrency: int = 5
+
+        # Runtime handles (not persisted)
+        self.running_asyncio_tasks: Dict[str, asyncio.Task] = {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert TaskRegistry to dictionary."""
+        return {
+            "tasks": {task_id: task.to_dict() for task_id, task in self.tasks.items()},
+            "exec_mode": self.exec_mode.value,
+            "max_concurrency": self.max_concurrency,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TaskRegistry":
+        """Create TaskRegistry from dictionary."""
+        registry = cls()
+        registry.tasks = {
+            task_id: Task.from_dict(task_data)
+            for task_id, task_data in data.get("tasks", {}).items()
+        }
+        registry.exec_mode = PlanExecMode(data.get("exec_mode", PlanExecMode.PARALLEL.value))
+        registry.max_concurrency = data.get("max_concurrency", 5)
+        return registry
+
+    async def add_task(self, task: Task):
+        """Register a new task."""
+        async with self._lock:
+            self.tasks[task.id] = task
+            logger.debug(f"Task registered: {task.id} ({task.name})")
+
+    async def get_task(self, task_id: str) -> Optional[Task]:
+        """Retrieve a task by ID (thread-safe)."""
+        async with self._lock:
+            return self.tasks.get(task_id)
+
+    async def get_all_tasks(self) -> List[Task]:
+        """Return all tasks (thread-safe)."""
+        async with self._lock:
+            return list(self.tasks.values())
+
+    async def get_pending_tasks(self) -> List[Task]:
+        """Return tasks that are pending (thread-safe)."""
+        async with self._lock:
+            return [t for t in self.tasks.values() if t.status == TaskStatus.PENDING]
+
+    async def get_ready_tasks(self) -> List[Task]:
+        """Return tasks that are ready to be started (thread-safe).
+
+        Phase 1 (no dependency scheduling):
+        - All PENDING tasks are considered ready.
+
+        Phase 2 (reserved):
+        - Check depends_on and only return tasks whose dependencies are completed.
+        """
+        async with self._lock:
+            return [task for task in self.tasks.values() if task.status == TaskStatus.PENDING]
+
+    async def get_running_tasks(self) -> List[Task]:
+        """Return tasks that are running (thread-safe)."""
+        async with self._lock:
+            return [t for t in self.tasks.values() if t.status == TaskStatus.RUNNING]
+
+    async def get_completed_tasks(self) -> List[Task]:
+        """Return tasks that are completed (thread-safe)."""
+        async with self._lock:
+            return [t for t in self.tasks.values() if t.status == TaskStatus.COMPLETED]
+
+    async def get_failed_tasks(self) -> List[Task]:
+        """Return tasks that have failed (thread-safe)."""
+        async with self._lock:
+            return [t for t in self.tasks.values() if t.status == TaskStatus.FAILED]
+
+    async def has_tasks(self) -> bool:
+        """Return whether any tasks are registered (thread-safe)."""
+        async with self._lock:
+            return bool(self.tasks)
+
+    async def reset(self):
+        """Reset task state (used for replan).
+
+        Clears:
+        - All tasks
+        - Running asyncio task handles (cancels them first)
+
+        Preserves:
+        - exec_mode (will be overwritten by next _plan_tasks call)
+        - max_concurrency (will be overwritten by next _plan_tasks call)
+
+        Note:
+            This is an async method to ensure proper locking for concurrent safety.
+        """
+        async with self._lock:
+            # Cancel all running asyncio tasks to prevent background leaks during replan
+            for task_id, asyncio_task in self.running_asyncio_tasks.items():
+                if not asyncio_task.done():
+                    asyncio_task.cancel()
+                    logger.debug(f"Cancelled orphaned task {task_id} during registry reset")
+
+            self.tasks.clear()
+            self.running_asyncio_tasks.clear()
+            logger.info("TaskRegistry reset (replan)")
+
+    async def is_all_done(self) -> bool:
+        """Return whether all tasks have reached a terminal state (thread-safe)."""
+        async with self._lock:
+            terminal = {TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED, TaskStatus.SKIPPED}
+            return all(task.status in terminal for task in self.tasks.values())
+
+    async def update_status(
+        self,
+        task_id: str,
+        status: TaskStatus,
+        **kwargs
+    ):
+        """Update task status and related fields.
+
+        Args:
+            task_id: Task identifier
+            status: New status
+            **kwargs: Additional fields to update (answer, think, block_answer, error, started_at, etc.)
+
+        Note:
+            Terminal states (COMPLETED, FAILED, CANCELLED, SKIPPED) cannot be transitioned.
+            This prevents race conditions during task cancellation or completion.
+        """
+        async with self._lock:
+            task = self.tasks.get(task_id)
+            if not task:
+                logger.warning(f"Cannot update status for unknown task: {task_id}")
+                return
+
+            # Validate state transitions: terminal states cannot be changed
+            # Note: FAILED is excluded from terminal states to allow retries
+            terminal_states = {TaskStatus.COMPLETED, TaskStatus.CANCELLED, TaskStatus.SKIPPED}
+            if task.status in terminal_states:
+                logger.warning(
+                    f"Cannot transition task {task_id} from terminal state {task.status.value} to {status.value}"
+                )
+                return
+
+            task.status = status
+
+            # Update additional fields
+            for key, value in kwargs.items():
+                if hasattr(task, key):
+                    setattr(task, key, value)
+
+            # Compute duration for terminal states
+            if status in (TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED):
+                if task.started_at and not task.duration:
+                    task.duration = time.time() - task.started_at
+
+            logger.debug(f"Task {task_id} status updated: {status.value}")
+
+    async def get_status_counts(self) -> Dict[str, int]:
+        """Return count per status (thread-safe)."""
+        async with self._lock:
+            counts = {status.value: 0 for status in TaskStatus}
+            for task in self.tasks.values():
+                counts[task.status.value] += 1
+            return counts
+
+    async def get_progress_signature(self) -> tuple:
+        """Compute a signature representing the current task progress state (thread-safe).
+
+        Returns:
+            A tuple of (task_id, status) pairs sorted by task_id.
+            This signature changes whenever any task changes status.
+
+        Usage:
+            Used by ExploreBlock to detect whether tasks have made progress.
+            If the signature is the same across multiple rounds, it indicates
+            the plan is stalled (no status changes).
+
+        Example:
+            >>> registry.get_progress_signature()
+            (('task_1', 'running'), ('task_2', 'pending'))
+        """
+        async with self._lock:
+            tasks = list(self.tasks.values())
+            return tuple(
+                (t.id, getattr(t.status, "value", str(t.status)))
+                for t in sorted(tasks, key=lambda x: x.id)
+            )
+
+    async def get_all_status(self) -> str:
+        """Return a formatted status summary (for _check_progress, thread-safe).
+
+        Returns:
+            A multi-line string with task status, including error details for failed tasks.
+        """
+        async with self._lock:
+            lines = []
+            now = time.time()
+            for task in self.tasks.values():
+                if task.status == TaskStatus.RUNNING and task.started_at:
+                    duration_str = f"{now - task.started_at:.1f}s+"
+                else:
+                    duration_str = f"{task.duration:.1f}s" if task.duration else "N/A"
+
+                icon_map = {
+                    TaskStatus.PENDING: "⏳",
+                    TaskStatus.RUNNING: "🔄",
+                    TaskStatus.COMPLETED: "✅",
+                    TaskStatus.FAILED: "❌",
+                    TaskStatus.CANCELLED: "🚫",
+                    TaskStatus.SKIPPED: "⏭️",
+                }
+                icon = icon_map.get(task.status, "?")
+                status_label = task.status.value
+
+                # Item 3 Optimization: Check if task is in the process of being cancelled
+                if task.status == TaskStatus.RUNNING and task.id in self.running_asyncio_tasks:
+                    asyncio_task = self.running_asyncio_tasks[task.id]
+                    # Check if cancelling (Python 3.11+) or if it's already done but status not updated
+                    is_cancelling = False
+                    if hasattr(asyncio_task, "cancelling"):
+                        is_cancelling = asyncio_task.cancelling() > 0
+                    
+                    if is_cancelling:
+                        icon = "⏳🚫"
+                        status_label = "cancelling..."
+
+                base_line = f"{icon} {task.id}: {task.name} [{status_label}] ({duration_str})"
+
+                # For failed tasks, include error details to enable self-correction
+                if task.status == TaskStatus.FAILED and task.error:
+                    error_preview = task.error[:150]  # Limit error length
+                    if len(task.error) > 150:
+                        error_preview += "..."
+                    base_line += f"\n    Error: {error_preview}"
+
+                lines.append(base_line)
+
+            return "\n".join(lines)
+
+    async def cancel_all_running(self) -> int:
+        """Cancel all running asyncio tasks and update their status.
+
+        Returns:
+            Number of tasks cancelled
+
+        Note:
+            This method both cancels the asyncio.Task objects and updates
+            the Task status to CANCELLED to keep state synchronized.
+        """
+        async with self._lock:
+            cancelled = 0
+            for task_id, asyncio_task in list(self.running_asyncio_tasks.items()):
+                if not asyncio_task.done():
+                    asyncio_task.cancel()
+                    cancelled += 1
+                    # Update task status to CANCELLED
+                    # This ensures Registry state matches actual execution state
+                    task = self.tasks.get(task_id)
+                    if task:
+                        task.status = TaskStatus.CANCELLED
+                        # Compute duration if task was started
+                        if task.started_at and not task.duration:
+                            task.duration = time.time() - task.started_at
+                    logger.debug(f"Cancelled running task: {task_id}")
+
+            self.running_asyncio_tasks.clear()
+            return cancelled

dolphin/core/utils/cache_kv.py

@@ -1,15 +1,79 @@
-import fcntl
 import json
 import os
+import sys
 import threading
 import time
 from typing import List, Dict, Any, Optional
 import uuid
 from dolphin.core.logging.logger import get_logger
 
+# Cross-platform file locking support
+_HAS_FCNTL = False
+_HAS_MSVCRT = False
+
+if sys.platform == 'win32':
+    # Windows: use msvcrt for file locking
+    try:
+        import msvcrt
+        _HAS_MSVCRT = True
+    except ImportError:
+        pass
+else:
+    # Unix/Linux: use fcntl for file locking
+    try:
+        import fcntl
+        _HAS_FCNTL = True
+    except ImportError:
+        pass
+
 logger = get_logger("utils.cache_kv")
 
 
+def _lock_file(f, exclusive=False):
+    """
+    Cross-platform file locking
+    
+    Args:
+        f: File object
+        exclusive: If True, acquire exclusive lock; otherwise shared lock
+    """
+    if _HAS_FCNTL:
+        # Unix/Linux: use fcntl
+        lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
+        fcntl.flock(f.fileno(), lock_type)
+    elif _HAS_MSVCRT:
+        # Windows: use msvcrt
+        # msvcrt.locking doesn't support shared locks, so we use exclusive
+        # Note: msvcrt requires seeking to the start
+        f.seek(0)
+        try:
+            msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1)
+        except OSError:
+            # File might be too short, which is ok for our use case
+            pass
+    # If neither is available, proceed without locking (not ideal but won't crash)
+
+
+def _unlock_file(f):
+    """
+    Cross-platform file unlocking
+    
+    Args:
+        f: File object
+    """
+    if _HAS_FCNTL:
+        # Unix/Linux: use fcntl
+        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+    elif _HAS_MSVCRT:
+        # Windows: use msvcrt
+        f.seek(0)
+        try:
+            msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+        except OSError:
+            pass
+    # If neither is available, nothing to unlock
+
+
 class CacheKV:
     def __init__(
         self, filePath: str, dumpInterval: int = 5, expireTimeByDay: float = 1
@@ -28,8 +92,7 @@ class CacheKV:
 
         try:
             with open(self.filePath, "r", encoding="utf-8") as f:
-                fd = f.fileno()
-                fcntl.flock(fd, fcntl.LOCK_SH)  # Shared lock for reading
+                _lock_file(f, exclusive=False)  # Shared lock for reading
                 try:
                     loaded_cache = json.load(f)
                     for key, value in loaded_cache.items():
@@ -46,7 +109,7 @@ class CacheKV:
                             # Compatible with old formats
                             self.cache[key] = {"value": value, "timestamp": time.time()}
                 finally:
-                    fcntl.flock(fd, fcntl.LOCK_UN)
+                    _unlock_file(f)
         except (json.JSONDecodeError, IOError) as e:
             logger.error(
                 f"Error loading cache file {self.filePath}: {e} try to backup and reset cache"
@@ -77,14 +140,13 @@ class CacheKV:
             temp_path = f"{self.filePath}.tmp.{os.getpid()}.{uuid.uuid4().hex}"
             try:
                 with open(temp_path, "w", encoding="utf-8") as f:
-                    fd = f.fileno()
-                    fcntl.flock(fd, fcntl.LOCK_EX)  # Exclusive lock for writing
+                    _lock_file(f, exclusive=True)  # Exclusive lock for writing
                     try:
                         json.dump(self.cache, f, ensure_ascii=False)
                         f.flush()
-                        os.fsync(fd)  # Ensure data is written to disk
+                        os.fsync(f.fileno())  # Ensure data is written to disk
                     finally:
-                        fcntl.flock(fd, fcntl.LOCK_UN)
+                        _unlock_file(f)
 
                 # Atomic rename
                 os.rename(temp_path, self.filePath)

dolphin/core/utils/tools.py

@@ -332,9 +332,11 @@ class ToolInterrupt(Exception):
         message="The tool was interrupted.",
         tool_name: str = None,
         tool_args: List[Dict] = None,
+        tool_config: Dict = None,
         *args,
         **kwargs,
     ):
         super().__init__(message, *args, **kwargs)
         self.tool_name = tool_name if tool_name else ""
         self.tool_args = tool_args if tool_args else []
+        self.tool_config = tool_config if tool_config else {}

dolphin/lib/__init__.py

@@ -24,7 +24,6 @@ if TYPE_CHECKING:
         MemorySkillkit,
         MCPSkillkit,
         OntologySkillkit,
-        PlanActSkillkit,
         CognitiveSkillkit,
         VMSkillkit,
         NoopSkillkit,
@@ -61,7 +60,6 @@ _module_lookup = {
     "MemorySkillkit": "dolphin.lib.skillkits",
     "MCPSkillkit": "dolphin.lib.skillkits",
     "OntologySkillkit": "dolphin.lib.skillkits",
-    "PlanActSkillkit": "dolphin.lib.skillkits",
     "CognitiveSkillkit": "dolphin.lib.skillkits",
     "VMSkillkit": "dolphin.lib.skillkits",
     "NoopSkillkit": "dolphin.lib.skillkits",