kweaver-dolphin 0.1.0__py3-none-any.whl

dolphin/lib/skill_results/strategies.py

@@ -0,0 +1,328 @@
+"""Strategy Module
+Provides an abstract interface and concrete implementations for data processing strategies (a unified model based on category)
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from dolphin.lib.skill_results.result_reference import ResultReference
+
+from dolphin.core.logging.logger import get_logger
+
+logger = get_logger("skill_results")
+
+
+class BaseStrategy(ABC):
+    """Base class for unified strategies.
+
+    - Use category to distinguish usage scenarios (e.g., 'llm', 'app', 'export', etc.)
+    - Subclasses must set the class attribute category and implement process()
+    """
+
+    # Subclasses should override to specify a concrete category, such as 'llm' or 'app'
+    category: str = "generic"
+
+    def get_category(self) -> str:
+        return getattr(self, "category", "generic")
+
+    def supports(self, category: str) -> bool:
+        return self.get_category() == category
+
+    @abstractmethod
+    def process(self, result_reference: "ResultReference", **kwargs) -> Any:
+        """Execute strategy processing and return final data (different categories may return different structures)"""
+        raise NotImplementedError
+
+
+# ======================== LLM Category Strategy (category='llm') ========================
+
+
+class BaseLLMStrategy(BaseStrategy):
+    """Base class for LLM strategies, providing general data transformation methods"""
+
+    category = "llm"
+
+    def _convert_to_string(self, data: Any) -> str:
+        """Convert data to string format"""
+        if isinstance(data, str):
+            return data
+        elif isinstance(data, (dict, list)):
+            return json.dumps(data, ensure_ascii=False, indent=2)
+        else:
+            return str(data)
+
+
+class DefaultLLMStrategy(BaseLLMStrategy):
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> str:
+        try:
+            full_result = result_reference.get_full_result()
+            if full_result is None:
+                return "数据不存在"
+
+            return self._convert_to_string(full_result)
+        except Exception as e:
+            logger.error(f"默认LLM策略处理failed: {e}")
+            return f"数据处理failed: {str(e)}"
+
+
+class SummaryLLMStrategy(BaseLLMStrategy):
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> str:
+        try:
+            full_result = result_reference.get_full_result()
+            if full_result is None:
+                return "数据不存在"
+
+            max_tokens = kwargs.get("max_tokens", 2000)
+            max_chars = max_tokens * 4
+
+            result_str = self._convert_to_string(full_result)
+            if len(result_str) <= max_chars:
+                return result_str
+
+            return self._generate_summary(result_str, max_chars)
+        except Exception as e:
+            logger.error(f"摘要LLM策略处理failed: {e}")
+            return f"摘要生成failed: {str(e)}"
+
+    def _generate_summary(self, text: str, max_chars: int) -> str:
+        if len(text) <= max_chars:
+            return text
+        start_chars = int(max_chars * 0.6)
+        end_chars = int(max_chars * 0.2)
+        start_part = text[:start_chars]
+        end_part = text[-end_chars:] if end_chars > 0 else ""
+
+        return f"{start_part}\n\n... (内容已截断) ...\n\n{end_part}"
+
+
+class TruncateLLMStrategy(BaseLLMStrategy):
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> str:
+        try:
+            full_result = result_reference.get_full_result()
+            if full_result is None:
+                return "数据不存在"
+
+            max_tokens = kwargs.get("max_tokens", 2000)
+            max_chars = max_tokens * 4
+
+            result_str = self._convert_to_string(full_result)
+            if len(result_str) <= max_chars:
+                return result_str
+
+            truncated = result_str[:max_chars]
+            return (
+                f"{truncated}\n\n... (内容已截断，总长度: {len(result_str)} 字符) ..."
+            )
+        except Exception as e:
+            logger.error(f"截取LLM策略处理failed: {e}")
+            return f"数据截取failed: {str(e)}"
+
+
+# ====================== APP Category Strategy (category='app') ======================
+
+
+class DefaultAppStrategy(BaseStrategy):
+    category = "app"
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> Dict[str, Any]:
+        try:
+            full_result = result_reference.get_full_result()
+            return full_result
+        except Exception as e:
+            logger.error(f"默认APP策略处理failed: {e}")
+            return {
+                "error": f"数据处理failed: {str(e)}",
+                "reference_id": result_reference.reference_id,
+            }
+
+
+class PaginationAppStrategy(BaseStrategy):
+    category = "app"
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> Dict[str, Any]:
+        try:
+            full_result = result_reference.get_full_result()
+            metadata = result_reference.get_metadata()
+            if full_result is None:
+                return {
+                    "error": "数据不存在",
+                    "reference_id": result_reference.reference_id,
+                }
+
+            page = kwargs.get("page", 1)
+            page_size = kwargs.get("page_size", 20)
+
+            if isinstance(full_result, list):
+                return self._paginate_list(
+                    full_result,
+                    page,
+                    page_size,
+                    metadata,
+                    result_reference.reference_id,
+                )
+            elif isinstance(full_result, dict):
+                return self._paginate_dict(
+                    full_result,
+                    page,
+                    page_size,
+                    metadata,
+                    result_reference.reference_id,
+                )
+            else:
+                return {
+                    "data": full_result,
+                    "metadata": metadata,
+                    "reference_id": result_reference.reference_id,
+                    "strategy": "pagination",
+                    "pagination": {
+                        "page": 1,
+                        "page_size": 1,
+                        "total_pages": 1,
+                        "total_items": 1,
+                    },
+                }
+        except Exception as e:
+            logger.error(f"分页APP策略处理failed: {e}")
+            return {
+                "error": f"分页处理failed: {str(e)}",
+                "reference_id": result_reference.reference_id,
+            }
+
+    def _paginate_list(
+        self,
+        data: List[Any],
+        page: int,
+        page_size: int,
+        metadata: Dict[str, Any],
+        reference_id: str,
+    ) -> Dict[str, Any]:
+        total_items = len(data)
+        total_pages = (total_items + page_size - 1) // page_size
+        page = max(1, min(page, total_pages))
+        start_idx = (page - 1) * page_size
+        end_idx = start_idx + page_size
+        page_data = data[start_idx:end_idx]
+        return {
+            "data": page_data,
+            "metadata": metadata,
+            "reference_id": reference_id,
+            "strategy": "pagination",
+            "pagination": {
+                "page": page,
+                "page_size": page_size,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "has_next": page < total_pages,
+                "has_prev": page > 1,
+            },
+        }
+
+    def _paginate_dict(
+        self,
+        data: Dict[str, Any],
+        page: int,
+        page_size: int,
+        metadata: Dict[str, Any],
+        reference_id: str,
+    ) -> Dict[str, Any]:
+        items = list(data.items())
+        total_items = len(items)
+        total_pages = (total_items + page_size - 1) // page_size
+        page = max(1, min(page, total_pages))
+        start_idx = (page - 1) * page_size
+        end_idx = start_idx + page_size
+        page_items = items[start_idx:end_idx]
+        page_data = dict(page_items)
+        return {
+            "data": page_data,
+            "metadata": metadata,
+            "reference_id": reference_id,
+            "strategy": "pagination",
+            "pagination": {
+                "page": page,
+                "page_size": page_size,
+                "total_pages": total_pages,
+                "total_items": total_items,
+                "has_next": page < total_pages,
+                "has_prev": page > 1,
+            },
+        }
+
+
+class PreviewAppStrategy(BaseStrategy):
+    category = "app"
+
+    def process(self, result_reference: "ResultReference", **kwargs) -> Dict[str, Any]:
+        try:
+            full_result = result_reference.get_full_result()
+            metadata = result_reference.get_metadata()
+            if full_result is None:
+                return {
+                    "error": "数据不存在",
+                    "reference_id": result_reference.reference_id,
+                }
+
+            max_size = kwargs.get("max_size", 1000)
+            max_items = kwargs.get("max_items", 10)
+
+            preview_data = self._generate_preview(full_result, max_size, max_items)
+            return {
+                "preview": preview_data,
+                "metadata": metadata,
+                "reference_id": result_reference.reference_id,
+                "strategy": "preview",
+                "type": type(full_result).__name__,
+                "truncated": self._is_truncated(full_result, preview_data, max_size),
+            }
+        except Exception as e:
+            logger.error(f"预览APP策略处理failed: {e}")
+            return {
+                "error": f"预览处理failed: {str(e)}",
+                "reference_id": result_reference.reference_id,
+            }
+
+    def _generate_preview(self, data: Any, max_size: int, max_items: int) -> Any:
+        """Generate preview data"""
+        if isinstance(data, str):
+            if len(data) <= max_size:
+                return data
+            return data[:max_size] + "..."
+
+        elif isinstance(data, list):
+            if len(data) <= max_items:
+                return data
+            return data[:max_items] + ["..."]
+
+        elif isinstance(data, dict):
+            items = list(data.items())
+            if len(items) <= max_items:
+                return data
+            preview_dict = dict(items[:max_items])
+            preview_dict["..."] = f"还有 {len(items) - max_items} 项"
+            return preview_dict
+
+        else:
+            result_str = str(data)
+            if len(result_str) <= max_size:
+                return data
+            return self._truncate_preview(data, max_size)
+
+    def _is_truncated(self, original: Any, preview: Any, max_size: int) -> bool:
+        """Determine if truncated"""
+        if isinstance(original, str):
+            return len(original) > max_size
+        elif isinstance(original, (list, dict)):
+            return len(str(original)) > max_size
+        return False
+
+    def _truncate_preview(self, data: Any, max_size: int) -> str:
+        """Truncate Preview"""
+        result_str = str(data)
+        if len(result_str) <= max_size:
+            return result_str
+        return result_str[:max_size] + "..."

dolphin/lib/skill_results/strategy_registry.py

@@ -0,0 +1,150 @@
+"""Strategy Registrator
+Provides registration, lookup, and management functions for strategies
+"""
+
+from typing import Dict, Optional, List, TYPE_CHECKING
+
+from .strategies import (
+    BaseStrategy,
+    DefaultLLMStrategy,
+    SummaryLLMStrategy,
+    TruncateLLMStrategy,
+    DefaultAppStrategy,
+    PaginationAppStrategy,
+    PreviewAppStrategy,
+)
+
+if TYPE_CHECKING:
+    pass
+
+from dolphin.core.logging.logger import get_logger
+
+logger = get_logger("skill_results")
+
+
+class StrategyRegistry:
+    """Strategy Registrator
+        - Default support category: 'llm', 'app', and other categories can be extended
+        - Multiple named strategies can exist under each category
+        - Supports registration, lookup, execution, and other operations
+    """
+
+    def __init__(self):
+        # Strategies organized by category
+        self._strategies: Dict[str, Dict[str, BaseStrategy]] = {}
+        self._default_strategies: Dict[str, str] = {}
+
+        # Register default policy
+        self._register_default_strategies()
+
+    def _register_default_strategies(self):
+        """Register default strategy"""
+        # LLM
+        self.register("default", DefaultLLMStrategy(), category="llm")
+        self.register("summary", SummaryLLMStrategy(), category="llm")
+        self.register("truncate", TruncateLLMStrategy(), category="llm")
+
+        # App
+        self.register("default", DefaultAppStrategy(), category="app")
+        self.register("pagination", PaginationAppStrategy(), category="app")
+        self.register("preview", PreviewAppStrategy(), category="app")
+
+        # Set default policy
+        self._default_strategies = {
+            "llm": "default",
+            "app": "default",
+        }
+
+    def register(
+        self, name: str, strategy: BaseStrategy, category: Optional[str] = None
+    ) -> None:
+        """Register strategy
+                - name: Strategy name
+                - strategy: Strategy instance
+                - category: Strategy category, if None then use the strategy's own category
+        """
+        if category is None:
+            category = strategy.get_category()
+
+        if category not in self._strategies:
+            self._strategies[category] = {}
+
+        self._strategies[category][name] = strategy
+        logger.debug(f"注册策略: {category}:{name} -> {strategy.__class__.__name__}")
+
+    def get_strategy(self, name: str, category: str) -> Optional[BaseStrategy]:
+        """Get strategy
+                - name: Strategy name, supports 'llm:summary' / 'app/pagination' format
+                - category: Strategy category
+        """
+        # Parse the category information in name
+        if ":" in name:
+            category, name = name.split(":", 1)
+        elif "/" in name:
+            category, name = name.split("/", 1)
+
+        # If category is a wildcard, try all supported categories
+        if category == "*":
+            for k in ("llm", "app"):
+                if k in self._strategies and name in self._strategies[k]:
+                    return self._strategies[k][name]
+            return None
+
+        # If category is a list, try each category
+        if isinstance(category, (list, tuple)):
+            for k in category:
+                if k in self._strategies and name in self._strategies[k]:
+                    return self._strategies[k][name]
+            return None
+
+        # If category is a wildcard, try all supported categories
+        # if category in ("llm", "app"):
+        if category in self._strategies and name in self._strategies[category]:
+            return self._strategies[category][name]
+
+        return None
+
+    def get_default_strategy(self, category: str) -> Optional[BaseStrategy]:
+        """Get default policy"""
+        if category not in self._default_strategies:
+            return None
+
+        default_name = self._default_strategies[category]
+        return self.get_strategy(default_name, category)
+
+    def list_strategies(self, category: Optional[str] = None) -> Dict[str, List[str]]:
+        """List all strategies"""
+        if category is None:
+            return {
+                cat: list(strategies.keys())
+                for cat, strategies in self._strategies.items()
+            }
+        elif category in self._strategies:
+            return {category: list(self._strategies[category].keys())}
+        else:
+            return {}
+
+    def has_strategy(self, name: str, category: str) -> bool:
+        """Check if the specified policy exists"""
+        return self.get_strategy(name, category) is not None
+
+    def remove_strategy(self, name: str, category: str) -> bool:
+        """Remove Strategy"""
+        if category in self._strategies and name in self._strategies[category]:
+            del self._strategies[category][name]
+            logger.debug(f"移除策略: {category}:{name}")
+            return True
+        return False
+
+    def clear(self) -> None:
+        """Clear all strategies"""
+        self._strategies.clear()
+        self._default_strategies.clear()
+        logger.debug("清空所有策略")
+
+    def __len__(self) -> int:
+        """Return total number of strategies"""
+        return sum(len(strategies) for strategies in self._strategies.values())
+
+    def __repr__(self) -> str:
+        return f"StrategyRegistry(strategies={len(self)}, categories={list(self._strategies.keys())})"

dolphin/lib/skillkits/__init__.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+"""Skillkits 模块 - 内置 Skillkits"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from dolphin.lib.skillkits.search_skillkit import SearchSkillkit
+    from dolphin.lib.skillkits.sql_skillkit import SQLSkillkit
+    from dolphin.lib.skillkits.memory_skillkit import MemorySkillkit
+    from dolphin.lib.skillkits.mcp_skillkit import MCPSkillkit
+    from dolphin.lib.skillkits.ontology_skillkit import OntologySkillkit
+    from dolphin.lib.skillkits.plan_act_skillkit import PlanActSkillkit
+    from dolphin.lib.skillkits.cognitive_skillkit import CognitiveSkillkit
+    from dolphin.lib.skillkits.vm_skillkit import VMSkillkit
+    from dolphin.lib.skillkits.noop_skillkit import NoopSkillkit
+    from dolphin.lib.skillkits.resource_skillkit import ResourceSkillkit
+    from dolphin.lib.skillkits.system_skillkit import SystemFunctionsSkillKit
+    from dolphin.lib.skillkits.agent_skillkit import AgentSkillKit
+    from dolphin.lib.skillkits.env_skillkit import EnvSkillkit
+
+_module_lookup = {
+    "SearchSkillkit": "dolphin.lib.skillkits.search_skillkit",
+    "SQLSkillkit": "dolphin.lib.skillkits.sql_skillkit",
+    "MemorySkillkit": "dolphin.lib.skillkits.memory_skillkit",
+    "MCPSkillkit": "dolphin.lib.skillkits.mcp_skillkit",
+    "OntologySkillkit": "dolphin.lib.skillkits.ontology_skillkit",
+    "PlanActSkillkit": "dolphin.lib.skillkits.plan_act_skillkit",
+    "CognitiveSkillkit": "dolphin.lib.skillkits.cognitive_skillkit",
+    "VMSkillkit": "dolphin.lib.skillkits.vm_skillkit",
+    "NoopSkillkit": "dolphin.lib.skillkits.noop_skillkit",
+    "ResourceSkillkit": "dolphin.lib.skillkits.resource_skillkit",
+    "SystemFunctionsSkillKit": "dolphin.lib.skillkits.system_skillkit",
+    "AgentSkillKit": "dolphin.lib.skillkits.agent_skillkit",
+    "EnvSkillkit": "dolphin.lib.skillkits.env_skillkit",
+}
+
+def __getattr__(name):
+    if name in _module_lookup:
+        import importlib
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = list(_module_lookup.keys())

dolphin/lib/skillkits/agent_skillkit.py

@@ -0,0 +1,155 @@
+from typing import List, Any
+
+from dolphin.core.skill.skillkit import Skillkit
+from dolphin.core.skill.skill_function import SkillFunction
+from dolphin.core.agent.base_agent import BaseAgent
+
+
+class AgentSkillKit(Skillkit):
+    """
+    AgentSkillKit acts as a bridge between Agent and Skill system
+    Converts a single Agent into a callable skill
+    """
+
+    def __init__(self, agent: BaseAgent, agentName: str = None):
+        """
+        Initialize AgentSkillKit with an agent
+
+        Args:
+            agent (BaseAgent): BaseAgent instance to wrap as a skill
+            agentName (str, optional): Name for the agent skill. If None, uses agent.get_name()
+        """
+        super().__init__()
+        self.agent = agent
+        self.agentName = agentName or agent.get_name()
+
+        # Create the agent execution functions
+        self._createAgentSkills()
+
+    def set_context(self, context):
+        self.agent.set_context(context)
+
+    def _createAgentSkills(self):
+        """
+        Create OpenAI functions for agent execution
+        """
+        # Get agent description for function documentation
+        agentDesc = self.agent.get_description()
+
+        # Create async execution function
+        async def arunAgent(query_str: str = None, **kwargs) -> Any:
+            """
+            Execute the agent asynchronously
+
+            Args:
+                query_str (str, optional): Query or task description to pass to the agent
+                **kwargs: Additional arguments to pass to the agent
+
+            Returns:
+                Agent execution result
+            """
+            lastResult = None
+            # Use query_str if provided, otherwise use query, with query_str taking priority
+            queryParam = query_str
+
+            # Prepare arguments for agent.arun()
+            agentArgs = kwargs.copy()
+            if queryParam is not None:
+                agentArgs["query"] = queryParam
+
+            await self.agent.initialize()
+            async for result in self.agent.arun(**agentArgs):
+                lastResult = result
+
+            #return variables and last stage answer
+            result = {}
+            if isinstance(lastResult, dict):
+                for k, v in lastResult.items():
+                    if not k.startswith("_"):
+                        result[k] = v
+                    elif k == "_progress":
+                        if len(v) > 1:
+                            result.update(v[-1])
+            return result
+
+        # Update function names and docstrings dynamically
+        arunAgent.__name__ = f"{self.agentName}"
+
+        # Use agent description if available, otherwise use default description
+        if agentDesc:
+            arunAgent.__doc__ = f"""
+        {agentDesc}
+        
+        Args:
+            query_str (str, optional): Query or task description to pass to the agent
+            query (str, optional): Alternative parameter name for backward compatibility
+            **kwargs: Additional arguments to pass to the agent
+            
+        Returns:
+            Agent execution result
+        """
+        else:
+            arunAgent.__doc__ = f"""
+        Execute agent '{self.agentName}' asynchronously
+        
+        Args:
+            query_str (str, optional): Query or task description to pass to the agent
+            query (str, optional): Alternative parameter name for backward compatibility
+            **kwargs: Additional arguments to pass to the agent
+            
+        Returns:
+            Agent execution result
+        """
+
+        # Store function references
+        self.arunAgentFunc = arunAgent
+
+    def getName(self) -> str:
+        """
+        Get the skillkit name
+
+        Returns:
+            Skillkit name
+        """
+        return f"agent_skillkit_{self.agentName}"
+
+    def _createSkills(self) -> List[SkillFunction]:
+        """
+        Create the skills (OpenAI functions) for this agent
+
+        Returns:
+            List of SkillFunction objects
+        """
+        skills = []
+
+        # Add async execution function (with arun_ prefix for backward compatibility)
+        skills.append(SkillFunction(self.arunAgentFunc))
+
+        return skills
+
+    def getAgent(self) -> BaseAgent:
+        """
+        Get the wrapped agent
+
+        Returns:
+            BaseAgent instance
+        """
+        return self.agent
+
+    def getAgentName(self) -> str:
+        """
+        Get the agent name
+
+        Returns:
+            Agent name string
+        """
+        return self.agentName
+
+    def __str__(self) -> str:
+        """
+        String representation of the AgentSkillKit
+
+        Returns:
+            Description string
+        """
+        return f"AgentSkillKit(agent={self.agentName})"