@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/agent/tools/permissions.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-from pathlib import Path
-from typing import Optional
-
-from onecode.agent.tools.errors import ToolPermissionError
-
-
-class PermissionResult(str, Enum):
-    ALLOW = "allow"
-    DENY = "deny"
-    ASK = "ask"
-
-
-def _resolve_path(p: str | Path) -> Path:
-    return Path(p).expanduser().resolve()
-
-
-def _is_within(child: Path, parent: Path) -> bool:
-    try:
-        child.relative_to(parent)
-        return True
-    except ValueError:
-        return False
-
-
-@dataclass
-class ToolPermissionContext:
-    deny_names: frozenset[str] = field(default_factory=frozenset)
-    deny_prefixes: tuple[str, ...] = ()
-    workspace_root: Optional[Path] = None
-    additional_working_directories: tuple[Path, ...] = ()
-
-    @classmethod
-    def from_iterables(
-        cls,
-        deny_names: list[str] | None = None,
-        deny_prefixes: list[str] | None = None,
-        *,
-        workspace_root: str | Path | None = None,
-        additional_working_directories: list[str | Path] | None = None,
-    ) -> ToolPermissionContext:
-        return cls(
-            deny_names=frozenset(name.lower() for name in (deny_names or [])),
-            deny_prefixes=tuple(prefix.lower() for prefix in (deny_prefixes or [])),
-            workspace_root=_resolve_path(workspace_root) if workspace_root else None,
-            additional_working_directories=tuple(
-                _resolve_path(p) for p in (additional_working_directories or [])
-            ),
-        )
-
-    def blocks_tool(self, tool_name: str) -> bool:
-        lowered = tool_name.lower()
-        return lowered in self.deny_names or any(
-            lowered.startswith(prefix) for prefix in self.deny_prefixes
-        )
-
-    def allowed_roots(self) -> tuple[Path, ...]:
-        roots: list[Path] = []
-        if self.workspace_root is not None:
-            roots.append(self.workspace_root)
-        roots.extend(self.additional_working_directories)
-        return tuple(roots)
-
-    def ensure_path_allowed(self, path: str | Path) -> Path:
-        resolved = _resolve_path(path)
-        roots = self.allowed_roots()
-        if not roots:
-            return resolved
-        if any(_is_within(resolved, root) for root in roots):
-            return resolved
-        roots_str = ", ".join(str(r) for r in roots)
-        raise ToolPermissionError(
-            f"path is outside allowed working directories: {resolved} (allowed: {roots_str})"
-        )

package/onecode/agent/tools/protocol.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Literal, Optional
-
-
-@dataclass(frozen=True)
-class ToolCall:
-    name: str
-    input: dict[str, Any]
-    tool_use_id: Optional[str] = None
-
-
-@dataclass(frozen=True)
-class ToolResult:
-    name: str
-    output: Any
-    is_error: bool = False
-    tool_use_id: Optional[str] = None
-    content_type: Literal["text", "json"] = "json"

package/onecode/agent/tools/registry.py

@@ -1,210 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Any, Callable, Iterable, Mapping
-
-from onecode.agent.tools.errors import ToolInputError, ToolPermissionError
-from onecode.agent.tools.protocol import ToolCall, ToolResult
-from onecode.agent.tools.schema_validation import validate_json_schema
-
-
-@dataclass(frozen=True)
-class ToolSpec:
-    name: str
-    description: str
-    input_schema: Mapping[str, Any]
-    aliases: tuple[str, ...] = ()
-    is_read_only: bool = False
-    is_destructive: bool = False
-    max_result_size_chars: int = 20_000
-
-
-class Tool(ABC):
-    @abstractmethod
-    def spec(self) -> ToolSpec: ...
-
-    @abstractmethod
-    def run(self, tool_input: dict[str, Any]) -> ToolResult: ...
-
-    async def run_async(
-        self, tool_input: dict[str, Any],
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> ToolResult:
-        return self.run(tool_input)
-
-
-class ToolRegistry:
-    def __init__(
-        self,
-        tools: Iterable[Tool] | None = None,
-    ) -> None:
-        self._tools: list[Tool] = []
-        self._by_name: dict[str, Tool] = {}
-        if tools:
-            for tool in tools:
-                self.register(tool)
-
-    def register(self, tool: Tool) -> None:
-        spec = tool.spec()
-        key = spec.name.lower()
-        if key in self._by_name:
-            raise ValueError(f"duplicate tool name: {spec.name}")
-        self._tools.append(tool)
-        self._by_name[key] = tool
-        for alias in spec.aliases:
-            alias_key = alias.lower()
-            if alias_key in self._by_name:
-                raise ValueError(f"duplicate tool alias: {alias}")
-            self._by_name[alias_key] = tool
-
-    def list_specs(self) -> list[ToolSpec]:
-        return [tool.spec() for tool in self._tools]
-
-    def get(self, name: str) -> Tool | None:
-        return self._by_name.get(name.lower())
-
-    def make_openai_schemas(self, exclude: set[str] | None = None) -> list[dict]:
-        """Build OpenAI-style function schemas for every registered tool.
-
-        When *exclude* is provided, tools whose names appear in it are
-        omitted entirely so the LLM never sees (and never attempts) tools
-        that the current agent's permissions would deny at runtime.
-        """
-        exclude = exclude or set()
-        schemas = []
-        for spec in self.list_specs():
-            if spec.name in exclude:
-                continue
-            schemas.append({
-                "type": "function",
-                "function": {
-                    "name": spec.name,
-                    "description": spec.description,
-                    "parameters": dict(spec.input_schema),
-                },
-            })
-        return schemas
-
-    async def dispatch_async(
-        self,
-        call: ToolCall,
-        cancel_check: Callable[[], bool] | None = None,
-    ) -> ToolResult:
-        tool = self.get(call.name)
-        if tool is None:
-            return ToolResult(
-                name=call.name,
-                output={"error": f"unknown tool: {call.name}"},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        try:
-            spec = tool.spec()
-            validate_json_schema(call.input, spec.input_schema, tool_name=call.name)
-            result = await tool.run_async(call.input, cancel_check=cancel_check)
-            max_chars = spec.max_result_size_chars
-            if max_chars > 0 and isinstance(result.output, str) and len(result.output) > max_chars:
-                result = ToolResult(
-                    name=result.name,
-                    output=result.output[:max_chars]
-                    + f"\n\n[Output truncated to {max_chars} characters]",
-                    is_error=result.is_error,
-                    tool_use_id=result.tool_use_id or call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            if result.tool_use_id is None:
-                return ToolResult(
-                    name=result.name,
-                    output=result.output,
-                    is_error=result.is_error,
-                    tool_use_id=call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            return result
-        except ToolInputError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except ToolPermissionError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except Exception as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-
-    def dispatch(
-        self,
-        call: ToolCall,
-    ) -> ToolResult:
-        tool = self.get(call.name)
-        if tool is None:
-            return ToolResult(
-                name=call.name,
-                output={"error": f"unknown tool: {call.name}"},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        try:
-            spec = tool.spec()
-
-            # Schema validation
-            validate_json_schema(call.input, spec.input_schema, tool_name=call.name)
-
-            # Execute
-            result = tool.run(call.input)
-
-            # Enforce max result size — truncate oversized output so the
-            # context window is not flooded by a single tool result.
-            max_chars = spec.max_result_size_chars
-            if max_chars > 0 and isinstance(result.output, str) and len(result.output) > max_chars:
-                result = ToolResult(
-                    name=result.name,
-                    output=result.output[:max_chars]
-                    + f"\n\n[Output truncated to {max_chars} characters]",
-                    is_error=result.is_error,
-                    tool_use_id=result.tool_use_id or call.tool_use_id,
-                    content_type=result.content_type,
-                )
-
-            if result.tool_use_id is None:
-                return ToolResult(
-                    name=result.name,
-                    output=result.output,
-                    is_error=result.is_error,
-                    tool_use_id=call.tool_use_id,
-                    content_type=result.content_type,
-                )
-            return result
-        except ToolInputError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except ToolPermissionError as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )
-        except Exception as e:
-            return ToolResult(
-                name=call.name,
-                output={"error": str(e)},
-                is_error=True,
-                tool_use_id=call.tool_use_id,
-            )