quantnodes 3.0.0__py3-none-any.whl

QuantNodes/agent/permission/models.py

@@ -0,0 +1,59 @@
+# coding=utf-8
+"""
+权限系统数据模型
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional
+import fnmatch
+
+
+class Action(Enum):
+    """权限动作"""
+    ALLOW = "allow"
+    DENY = "deny"
+    ASK = "ask"
+
+
+@dataclass(frozen=True)
+class PermissionRule:
+    """权限规则：(permission, pattern, action)"""
+    permission: str
+    pattern: str
+    action: Action
+
+    def matches(self, permission: str, target: str) -> bool:
+        perm_match = fnmatch.fnmatch(permission, self.permission)
+        target_match = fnmatch.fnmatch(target, self.pattern)
+        return perm_match and target_match
+
+
+@dataclass
+class PermissionRequest:
+    """权限请求"""
+    id: str
+    session_id: str
+    tool: str
+    permission: str
+    patterns: List[str]
+    always_patterns: List[str] = field(default_factory=list)
+    metadata: dict = field(default_factory=dict)
+
+
+@dataclass
+class PermissionReply:
+    """权限回复"""
+    response: str
+    message: Optional[str] = None
+
+
+Ruleset = List[PermissionRule]
+
+
+class PermissionDeniedError(Exception):
+    pass
+
+
+class PermissionRejectedError(Exception):
+    pass

QuantNodes/agent/permission/service.py

@@ -0,0 +1,133 @@
+# coding=utf-8
+"""
+权限服务
+"""
+
+import asyncio
+from typing import Dict, Callable, Awaitable
+from dataclasses import dataclass
+
+from .models import (
+    Action, PermissionRule, PermissionRequest, PermissionReply, Ruleset,
+    PermissionDeniedError, PermissionRejectedError
+)
+from .evaluate import evaluate
+
+
+@dataclass
+class PendingRequest:
+    """待处理的权限请求"""
+    info: PermissionRequest
+    deferred: asyncio.Future
+
+
+class PermissionService:
+    """权限管理服务
+
+    职责：
+    1. 管理权限规则集
+    2. 处理工具执行前的权限检查
+    3. 管理用户审批流程
+    4. 持久化已批准的规则
+    """
+
+    def __init__(self, ruleset: Ruleset | None = None):
+        self._ruleset = ruleset or []
+        self._approved: Ruleset = []
+        self._pending: Dict[str, PendingRequest] = {}
+        self._reply_handler: Callable[[PermissionRequest], Awaitable[PermissionReply]] | None = None
+
+    def set_reply_handler(self, handler: Callable[[PermissionRequest], Awaitable[PermissionReply]]):
+        """设置回复处理器（用于 UI 集成）"""
+        self._reply_handler = handler
+
+    def add_rule(self, rule: PermissionRule) -> None:
+        """添加规则"""
+        self._ruleset.append(rule)
+
+    def add_approved(self, rule: PermissionRule) -> None:
+        """添加已批准的规则"""
+        self._approved.append(rule)
+
+    async def check(
+        self,
+        tool: str,
+        permission: str,
+        patterns: list[str],
+        always_patterns: list[str] | None = None,
+        metadata: dict | None = None,
+    ) -> bool:
+        """检查权限
+
+        Args:
+            tool: 工具名称
+            permission: 权限类别
+            patterns: 目标模式列表
+            always_patterns: 可永久允许的模式
+            metadata: 附加信息
+
+        Returns:
+            True if allowed, False if denied
+
+        Raises:
+            PermissionDeniedError: 如果权限被拒绝
+            PermissionRejectedError: 如果用户拒绝
+        """
+        always_patterns = always_patterns or []
+        metadata = metadata or {}
+
+        for pattern in patterns:
+            rule = evaluate(
+                permission,
+                pattern,
+                self._ruleset,
+                self._approved,
+            )
+
+            if rule.action == Action.DENY:
+                raise PermissionDeniedError(
+                    f"Permission denied: {permission} on {pattern}"
+                )
+
+            if rule.action == Action.ALLOW:
+                continue
+
+            if self._reply_handler is None:
+                raise PermissionDeniedError(
+                    f"No reply handler configured, permission denied: {permission} on {pattern}"
+                )
+
+            request = PermissionRequest(
+                id=f"{tool}_{pattern}",
+                session_id="",
+                tool=tool,
+                permission=permission,
+                patterns=patterns,
+                always_patterns=always_patterns,
+                metadata=metadata,
+            )
+
+            reply = await self._reply_handler(request)
+
+            if reply.response == "reject":
+                raise PermissionRejectedError(
+                    reply.message or f"User rejected: {permission} on {pattern}"
+                )
+
+            if reply.response == "always":
+                for p in always_patterns:
+                    self._approved.append(PermissionRule(
+                        permission=permission,
+                        pattern=p,
+                        action=Action.ALLOW,
+                    ))
+
+        return True
+
+    def get_disabled_tools(self) -> set[str]:
+        """获取被禁用的工具列表"""
+        disabled = set()
+        for rule in self._ruleset:
+            if rule.pattern == "*" and rule.action == Action.DENY:
+                disabled.add(rule.permission)
+        return disabled

QuantNodes/agent/providers/__init__.py

@@ -0,0 +1,11 @@
+# coding=utf-8
+"""
+LLM Provider适配层
+
+LLMProvider基类 / QuantNodes适配器
+"""
+
+from .base import LLMProvider, LLMResponse, ToolCallRequest
+from .quantnodes import QuantNodesLLMProvider
+
+__all__ = ["LLMProvider", "LLMResponse", "ToolCallRequest", "QuantNodesLLMProvider"]

QuantNodes/agent/providers/base.py

@@ -0,0 +1,102 @@
+# coding=utf-8
+"""
+LLM Provider基类
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Callable, Awaitable
+
+
+@dataclass
+class ToolCallRequest:
+    """工具调用请求（来自LLM响应）"""
+    id: str
+    name: str
+    arguments: Dict[str, Any]
+
+
+@dataclass
+class LLMResponse:
+    """LLM响应"""
+    content: str | None
+    tool_calls: List[ToolCallRequest] = field(default_factory=list)
+    finish_reason: str = "stop"
+    usage: Dict[str, int] = field(default_factory=dict)
+    error: str | None = None
+
+    @property
+    def has_tool_calls(self) -> bool:
+        return len(self.tool_calls) > 0
+
+    @property
+    def should_execute_tools(self) -> bool:
+        if not self.has_tool_calls:
+            return False
+        return self.finish_reason == "tool_calls"
+
+
+class LLMProvider(ABC):
+    """LLM Provider基类"""
+
+    def __init__(self, api_key: str | None = None, api_base: str | None = None):
+        self.api_key = api_key
+        self.api_base = api_base
+
+    @staticmethod
+    def _enforce_role_alternation(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """合并连续相同角色的消息，确保角色交替"""
+        if not messages:
+            return messages
+
+        merged: List[Dict[str, Any]] = []
+        for msg in messages:
+            role = msg.get("role")
+            if (
+                merged
+                and role != "system"
+                and merged[-1].get("role") == role
+                and role in ("user", "assistant")
+            ):
+                prev = merged[-1]
+                prev_content = prev.get("content") or ""
+                curr_content = msg.get("content") or ""
+                if isinstance(prev_content, str) and isinstance(curr_content, str):
+                    prev["content"] = (prev_content + "\n\n" + curr_content).strip()
+                else:
+                    merged[-1] = dict(msg)
+            else:
+                merged.append(dict(msg))
+
+        return merged
+
+    @abstractmethod
+    async def chat(
+        self,
+        messages: List[Dict[str, Any]],
+        tools: List[Dict[str, Any]] | None = None,
+        model: str | None = None,
+        max_tokens: int = 102400,
+        temperature: float = 0.7,
+        tool_choice: str | Dict[str, Any] | None = None,
+    ) -> LLMResponse:
+        """发送聊天请求"""
+        pass
+
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, Any]],
+        tools: List[Dict[str, Any]] | None = None,
+        model: str | None = None,
+        max_tokens: int = 102400,
+        temperature: float = 0.7,
+        on_content_delta: Callable[[str], Awaitable[None]] | None = None,
+    ) -> LLMResponse:
+        """流式聊天（默认非流式实现）"""
+        response = await self.chat(
+            messages=messages, tools=tools, model=model,
+            max_tokens=max_tokens, temperature=temperature
+        )
+        if on_content_delta and response.content:
+            await on_content_delta(response.content)
+        return response