kweaver-dolphin 0.1.0__py3-none-any.whl

dolphin/core/code_block/judge_block.py

@@ -0,0 +1,220 @@
+import traceback
+from typing import Any, Optional, AsyncGenerator
+
+from dolphin.core.code_block.basic_code_block import BasicCodeBlock
+from dolphin.core.common.enums import CategoryBlock
+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
+
+
+class JudgeBlock(BasicCodeBlock):
+    def __init__(self, context: Context, debug_infos=None):
+        super().__init__(context)
+
+        self.llm_client = LLMClient(self.context)
+        self.debug_info = debug_infos
+
+    async def judge_tool_call(
+        self,
+        judge_str: Optional[str],
+        system_prompt: Optional[str],
+        tools_list: Optional[list[str]],
+        model: Optional[str] = None,
+        history: Optional[bool] = None,
+        ttc_mode: Optional[str] = None,
+    ) -> tuple[Optional[str], Optional[dict]]:
+        """Using LLM's function calling capability for tool selection"""
+        # Save original attributes
+        original_content = self.content
+        original_system_prompt = getattr(self, "system_prompt", None)
+        original_skills = getattr(self, "skills", None)
+        original_model = getattr(self, "model", None)
+        original_history = getattr(self, "history", None)
+        original_ttc_mode = getattr(self, "ttc_mode", None)
+
+        try:
+            # Temporarily set attributes to adapt to llm_chat
+            self.content = judge_str
+            self.system_prompt = system_prompt or ""
+            self.skills = tools_list
+            self.model = model
+            self.history = history
+            self.ttc_mode = ttc_mode
+
+            # Get tool list and skillkit information
+            available_skill_names = [
+                str(name) for name in self.get_skillkit().getSkillNames()
+            ]
+
+            # To ensure the LLM prioritizes using tools, add an explicit system prompt
+            original_system_prompt = self.system_prompt
+            if available_skill_names:
+                tool_instruction = f"You have access to these tools: {', '.join(available_skill_names)}. Please use the appropriate tool if it can help complete the task."
+                if self.system_prompt:
+                    self.system_prompt = f"{self.system_prompt}\n\n{tool_instruction}"
+                else:
+                    self.system_prompt = tool_instruction
+
+            # Call llm_chat with_skill=True to enable early stopping for tool calling
+            func_name: Optional[str] = None
+            func_args: Optional[dict[str, Any]] = None
+
+            async for item in self.llm_chat(
+                "judge", with_skill=True, early_stop_on_tool_call=True
+            ):
+                # Check if a complete tool invocation exists (arguments not being None indicates that parameters have been fully parsed)
+                if isinstance(item, dict) and "tool_call" in item and item["tool_call"]:
+                    assert isinstance(item["tool_call"], dict), (
+                        "tool_call is not a dict"
+                    )
+
+                    tool_call = item["tool_call"]
+                    func_name = tool_call["name"]
+                    func_args = tool_call[
+                        "arguments"
+                    ]  # None indicates incomplete, dict indicates complete parameters
+
+                    # If arguments is not None, it indicates that the tool invocation is complete.
+                    if func_args is not None:
+                        break
+
+            # If no complete tool invocation is detected, use the default value.
+            if func_args is None:
+                func_args = {}
+
+            self.context.debug(
+                f"judge_tool_call[{self.output_var}] [{judge_str}] tool_name[{func_name}] tool_args[{func_args}]"
+            )
+
+            return func_name, func_args
+
+        except Exception as e:
+            raise Exception(f"(Judge Block) judge_tool_call failed: {str(e)}")
+
+        finally:
+            # Restore original attributes
+            self.content = original_content
+            self.system_prompt = original_system_prompt  # Here the state will be restored to the previous state before modification.
+            self.skills = original_skills
+            self.model = original_model
+            self.history = original_history
+            self.ttc_mode = original_ttc_mode
+
+    async def execute(
+        self,
+        content,
+        category: CategoryBlock = CategoryBlock.JUDGE,
+        replace_variables=True,
+    ) -> AsyncGenerator[Any, None]:
+        # Execute the parent class logic
+        async for _ in super().execute(content, category, replace_variables):
+            pass
+
+        self.block_start_log("judge")
+
+        assert self.recorder, "recorder is None"
+
+        try:
+            gvpool_all_keys = self.context.get_all_variables().keys()
+            if (
+                "intervention_judge_block_vars" in gvpool_all_keys
+                and "tool" in gvpool_all_keys
+            ):
+                intervention_vars = self.context.get_var_value(
+                    "intervention_judge_block_vars"
+                )
+                assert intervention_vars is not None, "intervention_vars is None"
+
+                tool_name = intervention_vars["tool_name"]
+                judge_call_info = intervention_vars["judge_call_info"]
+
+                self.recorder.set_output_var(
+                    judge_call_info["assign_type"], judge_call_info["output_var"]
+                )
+
+                self.context.delete_variable("intervention_judge_block_vars")
+
+                input_dict = self.context.get_var_value("tool")
+                assert input_dict is not None, "input_dict is None"
+
+                new_tool_name = input_dict["tool_name"]
+                assert new_tool_name == tool_name, (
+                    "(judge_block) new_tool_name 和中断之前的 tool_name不一致"
+                )
+
+                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}
+                self.context.delete_variable("tool")
+
+                async for resp_item in self.skill_run(
+                    source_type=SourceType.SKILL,
+                    skill_name=tool_name,
+                    skill_params_json=new_tool_args,
+                    props=props,
+                ):
+                    yield resp_item
+            else:
+                self.recorder.set_output_var(self.assign_type, self.output_var)
+
+                # Execute the prompt; determine whether to invoke a tool. If so, invoke the tool; otherwise, directly request the LLM.
+                # Use the LLM chat-based implementation for tool judgment
+                tool_name, tool_args = await self.judge_tool_call(
+                    judge_str=self.content,
+                    system_prompt=self.system_prompt,
+                    tools_list=self.skills,
+                    model=self.model,
+                    history=self.history,
+                    ttc_mode=self.ttc_mode,
+                )
+                self.context.debug(
+                    f"judge_block[{self.output_var}] [{self.content}] tool_name[{tool_name}] tool_args[{tool_args}]"
+                )
+                if tool_name:
+                    # Ensure that output_var has been set (super().execute() should have already set it, but confirm here)
+                    if self.recorder and hasattr(self.recorder, "set_output_var"):
+                        self.recorder.set_output_var(self.assign_type, self.output_var)
+
+                    intervention_vars = {
+                        "tool_name": tool_name,
+                        "judge_call_info": {
+                            "judge_str": self.content,
+                            "assign_type": self.assign_type,
+                            "output_var": self.output_var,
+                            "params": self.params,
+                        },
+                    }
+
+                    try:
+                        self.context.set_variable(
+                            "intervention_judge_block_vars", intervention_vars
+                        )
+
+                        props = {"gvp": self.context}
+
+                        async for resp_item in self.skill_run(
+                            source_type=SourceType.SKILL,
+                            skill_name=tool_name,
+                            skill_params_json=tool_args or {},
+                            props=props,
+                        ):
+                            yield resp_item
+
+                    except ToolInterrupt as e:
+                        raise e
+                    except Exception as e:
+                        raise Exception(
+                            f"Judge block execution[{content}] tool[{tool_name}] failed: {str(e)}"
+                        )
+                else:
+                    async for item in self.llm_chat(lang_mode="judge"):
+                        yield item
+        except ToolInterrupt as e:
+            raise e
+        except Exception as e:
+            raise Exception(
+                f"Judge block execution failed: {str(e)} traceback: {traceback.format_exc()}"
+            )

dolphin/core/code_block/prompt_block.py

@@ -0,0 +1,32 @@
+import traceback
+from typing import Any, AsyncGenerator, Dict
+from dolphin.core.code_block.basic_code_block import BasicCodeBlock
+from dolphin.core.common.enums import CategoryBlock
+from dolphin.core.context.context import Context
+from dolphin.core.llm.llm_client import LLMClient
+
+
+class PromptBlock(BasicCodeBlock):
+    def __init__(self, context: Context, debug_infos=None):
+        super().__init__(context)
+        self.debug_info = debug_infos
+        self.llm_client = LLMClient(self.context)
+        self.debug_info = debug_infos
+
+    async def execute(
+        self,
+        content,
+        category: CategoryBlock = CategoryBlock.PROMPT,
+        replace_variables=True,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        async for _ in super().execute(content, category, replace_variables):
+            pass
+
+        self.block_start_log("prompt")
+        try:
+            async for item in self.llm_chat(lang_mode="prompt"):
+                yield item
+        except Exception as e:
+            raise Exception(
+                f"Prompt execution failed: {str(e)} traceback: {traceback.format_exc()}"
+            )

dolphin/core/code_block/skill_call_deduplicator.py

@@ -0,0 +1,291 @@
+"""Unified skill invocation deduplication interface and implementation
+
+This module provides an abstract base class and default implementation for skill invocation deduplication,
+used to detect and handle duplicate tool calls, preventing infinite loops.
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Dict, Tuple
+
+
+class SkillCallDeduplicator(ABC):
+    """Base class for skill call deduplicator
+
+        Provides a unified interface for detecting duplicate tool calls.
+        Different exploration strategies can use different implementations.
+    """
+    MAX_DUPLICATE_COUNT = 5
+
+    @abstractmethod
+    def add(self, skill_call: Any, result: Optional[str] = None):
+        """Add call record
+
+        Args:
+            skill_call: Skill call information, which can be a dict or tuple
+            result: Optional call result, used for intelligent retry judgment
+        """
+        pass
+
+    @abstractmethod
+    def is_duplicate(self, skill_call: Any) -> bool:
+        """Check if it's a repeated call (exceeding the maximum number of repetitions)
+
+        Args:
+            skill_call: Skill call information
+
+        Returns:
+            bool: Returns True if the number of repetitions exceeds the threshold
+        """
+        pass
+
+    @abstractmethod
+    def clear(self):
+        """Clear all records"""
+        pass
+
+    @abstractmethod
+    def get_call_key(self, skill_call: Any) -> str:
+        """Get the unique identifier of the call, used to determine whether two calls are equivalent.
+
+        Args:
+            skill_call: Information about the skill call
+
+        Returns:
+            str: A normalized call identifier string
+        """
+        pass
+
+    @abstractmethod
+    def get_history(self) -> list:
+        """Get the history of all recorded skill calls.
+
+        Returns:
+            List of skill call dictionaries
+        """
+        pass
+
+
+class NoOpSkillCallDeduplicator(SkillCallDeduplicator):
+    """Empty implementation of skill call deduplicator
+
+        Use when deduplication logic needs to be disabled. This implementation:
+        - Never marks calls as duplicates
+        - Records no call information
+    """
+
+    def add(self, skill_call: Any, result: Optional[str] = None):
+        """Do not record anything"""
+        return
+
+    def is_duplicate(self, skill_call: Any) -> bool:
+        """Never consider it a repeated call"""
+        return False
+
+    def clear(self):
+        """Do nothing"""
+        return
+
+    def get_call_key(self, skill_call: Any) -> str:
+        """Return an empty string as a placeholder"""
+        return ""
+
+    def get_history(self) -> list:
+        """Return empty list as no history is recorded"""
+        return []
+
+
+class DefaultSkillCallDeduplicator(SkillCallDeduplicator):
+    """Default skill call deduplication implementation
+
+        Supports two skill_call formats:
+        1. dict format: {"name": "skill_name", "arguments": {...}}  (used by ToolCallStrategy)
+        2. tuple format: (skill_name, params_dict)  (used by PromptStrategy)
+
+        Features:
+        - Uses normalized JSON as unique identifier
+        - Supports intelligent retry logic (some tools like snapshot allow retries when results are invalid)
+        - Caches call results for retry determination
+    """
+
+    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] = {}
+
+    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.
+
+        Returns:
+            List of skill call dictionaries with name and arguments
+        """
+        history = []
+        for call_key in self.skillcalls.keys():
+            try:
+                # Parse the call_key format: "skill_name:json_args"
+                if ':' in call_key:
+                    name, args_str = call_key.split(':', 1)
+                    try:
+                        args = json.loads(args_str)
+                    except json.JSONDecodeError:
+                        args = args_str
+                    history.append({"name": name, "arguments": args})
+                else:
+                    history.append({"name": call_key, "arguments": {}})
+            except Exception:
+                # If parsing fails, add as-is
+                history.append({"raw": call_key})
+        return history
+
+    def get_call_key(self, skill_call: Any) -> str:
+        """Get the standardized string representation of a skill call.
+
+                Supports two formats:
+                - dict: {"name": "xxx", "arguments": {...}}
+                - tuple: ("xxx", {...})
+
+                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
+        try:
+            if isinstance(arguments, dict):
+                normalized_args = json.dumps(
+                    arguments, sort_keys=True, ensure_ascii=False, separators=(",", ":")
+                )
+            else:
+                normalized_args = json.dumps(
+                    arguments, ensure_ascii=False, separators=(",", ":")
+                )
+        except (TypeError, ValueError):
+            # Fallback to string representation when serialization fails
+            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]:
+        """Extract skill name and parameters from skill_call
+
+        Args:
+            skill_call: skill call information
+
+        Returns:
+            Tuple[str, Any]: (skill name, parameters)
+        """
+        if isinstance(skill_call, dict):
+            # dict format: {"name": "xxx", "arguments": {...}}
+            skill_name = skill_call.get("name", "")
+            arguments = skill_call.get("arguments", {})
+        elif isinstance(skill_call, (list, tuple)) and len(skill_call) >= 2:
+            # tuple/list format: ("xxx", {...})
+            skill_name = skill_call[0]
+            arguments = skill_call[1]
+        else:
+            # Other formats, try stringifying
+            skill_name = str(skill_call)
+            arguments = {}
+
+        return skill_name, arguments
+
+    def add(self, skill_call: Any, result: Optional[str] = None):
+        """Add skill call record
+
+        Args:
+            skill_call: skill call information
+            result: optional call result
+        """
+        key = self.get_call_key(skill_call)
+        self.skillcalls[key] = self.skillcalls.get(key, 0) + 1
+        if result is not None:
+            self.call_results[key] = result
+
+    def is_duplicate(self, skill_call: Any) -> bool:
+        """Check if it's a repeated call (exceeding the maximum number of repetitions)
+
+                Features:
+                - For certain tools (e.g., snapshot), re-calling is allowed if the previous call result is invalid
+
+        Args:
+            skill_call: Skill call information
+
+        Returns:
+            bool: Returns True if the repetition count exceeds the threshold
+        """
+        key = self.get_call_key(skill_call)
+
+        # Smart retry: Certain tools allow retries when the result is invalid
+        if self._should_allow_retry(skill_call, key):
+            return False
+
+        return self.skillcalls.get(key, 0) >= self.MAX_DUPLICATE_COUNT
+
+    def _should_allow_retry(self, skill_call: Any, call_key: str) -> bool:
+        """Determine whether retrying a skill call should be allowed.
+
+        For certain tools (e.g., browser_snapshot), retries are allowed if previous results were invalid.
+
+        Args:
+            skill_call: Information about the skill call
+            call_key: Standardized key for the call
+
+        Returns:
+            bool: Whether retrying is allowed
+        """
+        skill_name, arguments = self._extract_skill_info(skill_call)
+
+        # Calls without arguments are not specially handled
+        if not arguments:
+            return False
+
+        # For snapshot tools, check whether previous results are valid
+        if "snapshot" in skill_name.lower():
+            previous_result = self.call_results.get(call_key)
+            if previous_result is not None:
+                result_str = str(previous_result).strip().lower()
+                # If the previous result is very short or contains error messages, retries are allowed
+                return (
+                    len(result_str) < 50
+                    or "about:blank" in result_str
+                    or "error" in result_str
+                    or "empty" in result_str
+                )
+
+        return False
+
+    def get_duplicate_count(self, skill_call: Any) -> int:
+        """Get the number of repetitions for a skill call
+
+        Args:
+            skill_call: Information about the skill call
+
+        Returns:
+            int: Number of repetitions
+        """
+        key = self.get_call_key(skill_call)
+        return self.skillcalls.get(key, 0)
+
+    def repr_skill_call(self, skill_call: Any) -> str:
+        """Get the string representation of a skill call (for logging)
+
+        Args:
+            skill_call: Information about the skill call
+
+        Returns:
+            str: String representation of the call
+        """
+        return self.get_call_key(skill_call)

dolphin/core/code_block/tool_block.py

@@ -0,0 +1,129 @@
+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.context.var_output import SourceType
+from typing import Optional, AsyncGenerator, Dict, Any
+
+
+class ToolBlock(BasicCodeBlock):
+    def __init__(self, context: Context, debug_infos: Optional[dict] = None):
+        super().__init__(context=context)
+        self.already_append_flag = False
+
+    def parse_tool_call(self):
+        """Parse tool calls, now using the unified parse_block_content method
+
+        Args:
+            content: Tool call content
+
+        Returns:
+            Dictionary containing the parsing results
+        """
+        # Return a compatible format
+        return {
+            "tool_name": self.content,  # The tool name is stored in content.
+            "args": self.params,
+            "assign_type": self.assign_type,
+            "output_var": self.output_var,
+        }
+
+    async def execute(
+        self,
+        content,
+        category: CategoryBlock = CategoryBlock.TOOL,
+        replace_variables=True,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        async for _ in super().execute(content, category, replace_variables):
+            pass
+
+        self.block_start_log("tool")
+        try:
+            gvpool_all_keys = self.context.get_all_variables().keys()
+            if (
+                "intervention_tool_block_vars" in gvpool_all_keys
+                and "tool" in gvpool_all_keys
+            ):
+                intervention_vars = self.context.get_var_value(
+                    "intervention_tool_block_vars"
+                )
+                assert intervention_vars is not None, "intervention_vars is None"
+
+                tool_name = intervention_vars["tool_name"]
+                tool_call_info = intervention_vars["tool_call_info"]
+                self.context.delete_variable("intervention_tool_block_vars")
+                if self.recorder is not None:
+                    self.recorder.set_output_var(
+                        tool_call_info["assign_type"], tool_call_info["output_var"]
+                    )
+
+                input_dict = self.context.get_var_value("tool")
+                assert input_dict is not None, "input_dict is None"
+
+                new_tool_name = input_dict["tool_name"]
+                assert new_tool_name == tool_name, (
+                    "(tool_block) new_tool_name 和中断之前的 tool_name不一致"
+                )
+                tool_obj = self.context.get_skill(tool_name)
+                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}
+                input_dict = self.context.delete_variable("tool")
+
+                resp_item = None
+                async for resp_item in self.skill_run(
+                    source_type=SourceType.SKILL,
+                    skill_name=tool_name,
+                    skill_params_json=new_tool_args,
+                    props=props,
+                ):
+                    yield resp_item
+
+                if self.recorder is not None:
+                    self.recorder.update(
+                        stage=TypeStage.SKILL,
+                        item=resp_item,
+                        skill_name=tool_name,
+                        skill_args=new_tool_args,
+                        skill_type=self.context.get_skill_type(tool_name),
+                        source_type=SourceType.SKILL,
+                        is_completed=True,
+                    )
+                yield {"data": resp_item}
+            else:
+                # step1: First parse, then retrieve the actual values from gvpool when actually calling the function (the actual variable values might be of type dict, list)
+                tool_call_info = self.parse_tool_call()
+                if self.recorder is not None:
+                    self.recorder.set_output_var(
+                        tool_call_info["assign_type"], tool_call_info["output_var"]
+                    )
+
+                # step2: Obtain the tool object and execute the tool call
+                tool_name = tool_call_info["tool_name"]
+
+                intervention_vars = {
+                    "tool_name": tool_call_info["tool_name"],
+                    "tool_call_info": tool_call_info,
+                }
+
+                self.context.set_variable(
+                    "intervention_tool_block_vars", intervention_vars
+                )
+                interventions = self.context.get_var_value("interventions") or []
+                interventions += [intervention_vars]
+                self.context.set_variable("interventions", interventions)
+
+                async for resp_item in self.skill_run(
+                    source_type=SourceType.SKILL,
+                    skill_name=tool_name,
+                    skill_params_json=tool_call_info["args"],
+                ):
+                    yield resp_item
+
+            console("\n", verbose=self.context.is_verbose())
+        except ToolInterrupt as e:
+            raise e
+        except Exception as e:
+            raise Exception(f"Tool block execution failed: {str(e)}")

dolphin/core/common/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""Common 模块 - 核心公共定义"""
+
+from dolphin.core.common.constants import *
+from dolphin.core.common.enums import MessageRole, SkillType, KnowledgePoint, SingleMessage, ToolCallInfo
+from dolphin.core.common.types import *
+from dolphin.core.common.exceptions import DolphinException
+
+__all__ = [
+    "MessageRole",
+    "SkillType",
+    "DolphinException",
+    "KnowledgePoint",
+    "SingleMessage",
+    "ToolCallInfo",
+]
+