decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

agent/openclaw/src/plugin_generator.py

@@ -0,0 +1,231 @@
+import os
+import json
+import shutil
+import tempfile
+import subprocess
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class MCPTool:
+    """Represents an MCP tool definition."""
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+
+
+@dataclass
+class MCPServerTools:
+    """MCP server with its discovered tools."""
+    name: str
+    url: str
+    tools: List[MCPTool]
+
+
+class StaticPluginGenerator:
+    """Generates static OpenClaw plugins for MCP servers."""
+
+    def __init__(self, extensions_dir: Optional[str] = None, debug: bool = False):
+        """
+        Initialize the plugin generator.
+
+        Args:
+            extensions_dir: Directory for OpenClaw extensions.
+                           Defaults to ~/.openclaw/extensions
+            debug: Enable debug output
+        """
+        self.extensions_dir = extensions_dir or os.path.expanduser(
+            "~/.openclaw/extensions"
+        )
+        self.debug = debug
+        self._generated_plugins: List[str] = []
+
+    def generate_plugin(
+        self,
+        servers: List[MCPServerTools],
+        plugin_id: str,
+    ) -> str:
+        """
+        Generate a static OpenClaw plugin for the given MCP servers.
+
+        Args:
+            servers: List of MCP servers with their tools
+            plugin_id: Unique identifier for this plugin
+
+        Returns:
+            Path to the installed plugin directory
+        """
+        # Create temp directory for plugin
+        plugin_dir = tempfile.mkdtemp(prefix=f"openclaw_plugin_{plugin_id}_")
+
+        try:
+            # Generate plugin files
+            self._write_package_json(plugin_dir, plugin_id)
+            self._write_manifest(plugin_dir, plugin_id, servers)
+            self._write_index_ts(plugin_dir, servers)
+
+            # Install the plugin
+            installed_path = self._install_plugin(plugin_dir, plugin_id)
+            self._generated_plugins.append(plugin_id)
+
+            if self.debug:
+                print(f"[PluginGenerator] Generated plugin '{plugin_id}' at {installed_path}")
+
+            return installed_path
+
+        finally:
+            # Clean up temp directory
+            shutil.rmtree(plugin_dir, ignore_errors=True)
+
+    def _write_package_json(self, plugin_dir: str, plugin_id: str) -> None:
+        """Write package.json for the plugin."""
+        package = {
+            "name": plugin_id,
+            "version": "1.0.0",
+            "type": "module",
+            "openclaw": {
+                "extensions": ["./index.ts"]
+            },
+            "dependencies": {}
+        }
+
+        with open(os.path.join(plugin_dir, "package.json"), "w") as f:
+            json.dump(package, f, indent=2)
+
+    def _write_manifest(
+        self,
+        plugin_dir: str,
+        plugin_id: str,
+        servers: List[MCPServerTools]
+    ) -> None:
+        """Write openclaw.plugin.json manifest."""
+        # Build server config schema
+        server_names = [s.name for s in servers]
+
+        manifest = {
+            "id": plugin_id,
+            "name": f"MCP Tools ({', '.join(server_names)})",
+            "description": f"Static MCP tools for servers: {', '.join(server_names)}",
+            "configSchema": {
+                "type": "object",
+                "properties": {}
+            }
+        }
+
+        with open(os.path.join(plugin_dir, "openclaw.plugin.json"), "w") as f:
+            json.dump(manifest, f, indent=2)
+
+    def _write_index_ts(self, plugin_dir: str, servers: List[MCPServerTools]) -> None:
+        """Write the main plugin TypeScript file."""
+
+        # Generate tool registration code for each server
+        tool_registrations = []
+
+        for server in servers:
+            for tool in server.tools:
+                tool_name = f"{server.name}_{tool.name}"
+
+                # Escape strings for TypeScript
+                description = tool.description.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+                schema_json = json.dumps(tool.input_schema)
+
+                registration = f'''
+  // Tool: {tool_name} from {server.name}
+  api.registerTool({{
+    name: "{tool_name}",
+    description: "{description}",
+    parameters: {schema_json},
+    async execute(_id: string, params: unknown) {{
+      try {{
+        const response = await fetch("{server.url}", {{
+          method: "POST",
+          headers: {{ "Content-Type": "application/json" }},
+          body: JSON.stringify({{
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method: "tools/call",
+            params: {{
+              name: "{tool.name}",
+              arguments: params
+            }}
+          }})
+        }});
+
+        const result = await response.json();
+
+        if (result.error) {{
+          return {{
+            content: [{{ type: "text", text: `Error: ${{result.error.message}}` }}],
+            isError: true
+          }};
+        }}
+
+        const text = result.result?.content
+          ?.map((c: any) => c.text ?? c.data ?? "")
+          .join("\\n") ?? JSON.stringify(result.result);
+
+        return {{
+          content: [{{ type: "text", text }}],
+          isError: false
+        }};
+      }} catch (err) {{
+        return {{
+          content: [{{ type: "text", text: `Error calling {tool_name}: ${{err}}` }}],
+          isError: true
+        }};
+      }}
+    }}
+  }});
+'''
+                tool_registrations.append(registration)
+
+        # Combine into full plugin code (minimal logging to verify loading)
+        total_tools = sum(len(s.tools) for s in servers)
+        plugin_code = f'''// Auto-generated static MCP tools plugin
+// Generated for servers: {", ".join(s.name for s in servers)}
+
+export default function (api: any) {{
+  console.log("[OpenClaw-MCP] Loading {total_tools} tools...");
+{"".join(tool_registrations)}
+  console.log("[OpenClaw-MCP] Done.");
+}}
+'''
+
+        with open(os.path.join(plugin_dir, "index.ts"), "w") as f:
+            f.write(plugin_code)
+
+    def _install_plugin(self, plugin_dir: str, plugin_id: str) -> str:
+        """
+        Install the plugin to OpenClaw extensions directory.
+        """
+        # Remove existing plugin if present
+        target_dir = os.path.join(self.extensions_dir, plugin_id)
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+
+        # Copy plugin to extensions directory
+        os.makedirs(self.extensions_dir, exist_ok=True)
+        shutil.copytree(plugin_dir, target_dir)
+
+        if self.debug:
+            print(f"[PluginGenerator] Installed plugin to: {target_dir}")
+
+        return target_dir
+
+    def uninstall_plugin(self, plugin_id: str) -> None:
+        """Remove a generated plugin."""
+        target_dir = os.path.join(self.extensions_dir, plugin_id)
+
+        if os.path.exists(target_dir):
+            shutil.rmtree(target_dir)
+            if self.debug:
+                print(f"[PluginGenerator] Removed plugin directory: {target_dir}")
+
+        if plugin_id in self._generated_plugins:
+            self._generated_plugins.remove(plugin_id)
+
+    def cleanup_all(self) -> None:
+        """Remove all plugins generated by this instance."""
+        for plugin_id in list(self._generated_plugins):
+            self.uninstall_plugin(plugin_id)

agent/openclaw/src/utils.py

@@ -0,0 +1,341 @@
+import os
+import json
+from datetime import datetime, timezone
+from typing import List, Dict, Any, Optional, Set
+
+from dt_arena.src.types.trajectory import Trajectory
+
+
+class OpenClawTrajectoryConverter:
+    """
+    Convert OpenClaw session logs to standard trajectory format.
+
+    The trajectory format is compatible with the DecodingTrust Agent Arena
+    evaluation platform and includes:
+    - Task info (task_id, instruction, domain, category)
+    - Trajectory info (success, step_count, duration, timestamp)
+    - Trajectory steps (user, agent, tool messages)
+    """
+
+    def __init__(self, output_dir: str, timestamp: Optional[str] = None):
+        self.output_dir = output_dir
+        self.timestamp = timestamp
+        os.makedirs(self.output_dir, exist_ok=True)
+
+    def convert_session_log(
+        self,
+        session_log_path: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        task_id: Optional[str] = None,
+        duration: float = 0.0,
+        mcp_tool_lists: Optional[Dict[str, List[Dict[str, Any]]]] = None,
+    ) -> Optional[Trajectory]:
+        """
+        Convert an OpenClaw session JSONL file directly to a Trajectory object.
+
+        Reads the session log written by OpenClaw CLI and produces the standard
+        trajectory format (matching openaisdk output): each tool call yields
+        exactly 2 steps — an agent action step and a tool return step.
+
+        Args:
+            session_log_path: Path to the session JSONL file
+            metadata: Optional trace metadata (task_id, instruction, domain, etc.)
+            task_id: Optional task ID override
+            duration: Execution duration in seconds
+            mcp_tool_lists: Optional dict mapping server name to list of tool dicts
+                (each with "name" and "description"). Stored in traj_info.metadata
+                as available tools per MCP server.
+
+        Returns:
+            Trajectory object, or None if file is missing / empty
+        """
+        if not os.path.exists(session_log_path):
+            return None
+
+        meta = metadata or {}
+
+        # Create Trajectory
+        traj = Trajectory(
+            task_id=task_id or meta.get("task_id", "unknown"),
+            original_instruction=meta.get("instruction", ""),
+            malicious_instruction=meta.get("malicious_goal"),
+            domain=meta.get("domain"),
+            risk_category=meta.get("category"),
+        )
+        traj.data["traj_info"]["duration"] = round(duration, 3)
+        traj.data["traj_info"]["timestamp"] = datetime.now(timezone.utc).isoformat()
+        traj.data["traj_info"]["metadata"] = {
+            "framework": "openclaw",
+        }
+
+        # Store MCP tool lists as metadata (not trajectory steps)
+        if mcp_tool_lists:
+            traj.data["traj_info"]["metadata"]["mcp_tools"] = mcp_tool_lists
+
+        # Parse session JSONL / runtime trajectory JSONL
+        entries: List[Dict[str, Any]] = []
+        with open(session_log_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if isinstance(entry, dict):
+                    entries.append(entry)
+
+        if not entries:
+            return None
+
+        self._convert_runtime_trajectory_entries(traj, entries)
+
+        # Save trajectory file
+        if self.timestamp:
+            filename = f"{self.timestamp}.json"
+        else:
+            filename = f"{task_id or 'unknown'}.json"
+        output_path = os.path.join(self.output_dir, filename)
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(traj.to_dict(), f, indent=2, ensure_ascii=False)
+
+        return traj
+
+    def _convert_runtime_trajectory_entries(
+        self,
+        traj: Trajectory,
+        entries: List[Dict[str, Any]],
+    ) -> None:
+        """Convert OpenClaw 2026.4+ runtime trajectory JSONL traces."""
+        traj_meta = traj.data["traj_info"].setdefault("metadata", {})
+        traj_meta["trace_schema"] = "openclaw-trajectory"
+
+        last_assistant_text: Optional[str] = None
+        seen_user_messages: Set[str] = set()
+        seen_tool_call_ids: Set[str] = set()
+
+        for entry in entries:
+            event_type = entry.get("type")
+            data = entry.get("data") or {}
+
+            for key in ("traceId", "sessionId", "provider", "modelId", "modelApi", "workspaceDir", "runId"):
+                value = entry.get(key)
+                if value is not None:
+                    traj_meta.setdefault(key, value)
+
+            if event_type == "trace.metadata":
+                harness = data.get("harness")
+                if harness:
+                    traj_meta["harness"] = harness
+                invocation = (harness or {}).get("invocation")
+                if invocation:
+                    traj_meta["invocation"] = invocation
+
+            elif event_type == "context.compiled":
+                system_prompt = data.get("systemPrompt")
+                if system_prompt:
+                    traj_meta.setdefault("system_prompt", system_prompt)
+                available_tools = data.get("availableTools")
+                if available_tools:
+                    traj_meta["available_tools"] = available_tools
+
+            elif event_type == "prompt.submitted":
+                prompt = data.get("prompt")
+                if prompt:
+                    seen_user_messages.add(prompt)
+                    traj.append_user_step(
+                        prompt,
+                        metadata={
+                            "source": "openclaw-trajectory",
+                            "session_id": entry.get("sessionId"),
+                            "ts": entry.get("ts"),
+                        },
+                    )
+
+            elif event_type == "model.completed":
+                usage = data.get("usage")
+                if usage:
+                    traj_meta["usage"] = usage
+                messages_snapshot = data.get("messagesSnapshot")
+                if isinstance(messages_snapshot, list):
+                    snapshot_assistant_text = self._append_message_steps(
+                        traj,
+                        messages_snapshot,
+                        source="openclaw-trajectory",
+                        session_id=entry.get("sessionId"),
+                        ts=entry.get("ts"),
+                        seen_user_messages=seen_user_messages,
+                        seen_tool_call_ids=seen_tool_call_ids,
+                    )
+                    if snapshot_assistant_text:
+                        last_assistant_text = snapshot_assistant_text
+                assistant_text = self._join_assistant_texts(data.get("assistantTexts"))
+                if assistant_text and not last_assistant_text:
+                    last_assistant_text = assistant_text
+
+            elif event_type == "session.ended":
+                traj_meta["final_status"] = data.get("status")
+
+        if last_assistant_text:
+            traj.append_agent_step(
+                action="send_message_to_user",
+                metadata={"message": last_assistant_text, "source": "openclaw-trajectory"},
+            )
+            traj.set_final_response(last_assistant_text)
+
+    def _append_message_steps(
+        self,
+        traj: Trajectory,
+        messages: List[Dict[str, Any]],
+        source: Optional[str] = None,
+        session_id: Optional[str] = None,
+        ts: Optional[str] = None,
+        seen_user_messages: Optional[Set[str]] = None,
+        seen_tool_call_ids: Optional[Set[str]] = None,
+    ) -> Optional[str]:
+        """Append user/tool steps from an OpenClaw message array."""
+        tool_results: Dict[str, Dict[str, Any]] = {}
+        for msg in messages:
+            if msg.get("role") == "toolResult":
+                call_id = msg.get("toolCallId")
+                if call_id:
+                    tool_results[call_id] = msg
+
+        last_assistant_text: Optional[str] = None
+
+        for msg in messages:
+            role = msg.get("role")
+
+            if role == "user":
+                texts = self._extract_message_texts(msg.get("content", []))
+                if not texts:
+                    continue
+                user_text = "\n".join(texts)
+                if seen_user_messages is not None and user_text in seen_user_messages:
+                    continue
+                if seen_user_messages is not None:
+                    seen_user_messages.add(user_text)
+                traj.append_user_step(
+                    user_text,
+                    metadata=self._build_trace_metadata(source, session_id, ts),
+                )
+
+            elif role == "assistant":
+                for block in msg.get("content", []):
+                    if not isinstance(block, dict):
+                        continue
+
+                    if block.get("type") == "text":
+                        text = block.get("text", "").strip()
+                        if text:
+                            last_assistant_text = text
+
+                    elif block.get("type") == "toolCall":
+                        call_id = block.get("id", "")
+                        if seen_tool_call_ids is not None and call_id and call_id in seen_tool_call_ids:
+                            continue
+                        if seen_tool_call_ids is not None and call_id:
+                            seen_tool_call_ids.add(call_id)
+
+                        tool_name = block.get("name", "unknown")
+                        arguments = block.get("arguments", {})
+                        action_str = self._format_action_string(tool_name, arguments)
+                        server = self._extract_server_name(tool_name)
+
+                        traj.append_agent_step(
+                            action=action_str,
+                            tool_name=tool_name,
+                            tool_params=arguments,
+                            server=server,
+                            metadata=self._build_trace_metadata(source, session_id, ts),
+                        )
+
+                        result_msg = tool_results.get(call_id)
+                        if result_msg:
+                            result_parts = self._extract_message_texts(result_msg.get("content", []))
+                            result_payload = "\n".join(result_parts)
+                            traj.append_tool_return(
+                                result=self._parse_tool_output(result_payload),
+                                tool_name=tool_name,
+                                server=server,
+                                metadata=self._build_trace_metadata(source, session_id, ts),
+                            )
+
+        return last_assistant_text
+
+    @staticmethod
+    def _extract_message_texts(content: Any) -> List[str]:
+        """Extract text fragments from OpenClaw content blocks."""
+        texts: List[str] = []
+        if not isinstance(content, list):
+            return texts
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text = str(block.get("text", "")).strip()
+                if text:
+                    texts.append(text)
+            elif isinstance(block, str):
+                text = block.strip()
+                if text:
+                    texts.append(text)
+        return texts
+
+    @staticmethod
+    def _build_trace_metadata(
+        source: Optional[str],
+        session_id: Optional[str],
+        ts: Optional[str],
+    ) -> Dict[str, Any]:
+        metadata: Dict[str, Any] = {}
+        if source:
+            metadata["source"] = source
+        if session_id:
+            metadata["session_id"] = session_id
+        if ts:
+            metadata["ts"] = ts
+        return metadata
+
+    @staticmethod
+    def _join_assistant_texts(texts: Any) -> Optional[str]:
+        """Normalize OpenClaw runtime assistantTexts arrays into one response."""
+        if not texts or not isinstance(texts, list):
+            return None
+        parts = [str(text).strip() for text in texts if str(text).strip()]
+        if not parts:
+            return None
+        return "\n\n".join(parts)
+
+    @staticmethod
+    def _format_action_string(tool_name: str, arguments: Dict[str, Any]) -> str:
+        """Format a tool call into a human-readable action string."""
+        params = []
+        for k, v in arguments.items():
+            if isinstance(v, str):
+                v_display = v[:100] + "..." if len(v) > 100 else v
+                params.append(f'{k}="{v_display}"')
+            else:
+                params.append(f"{k}={v}")
+        return f"{tool_name}({', '.join(params)})"
+
+    @staticmethod
+    def _extract_server_name(tool_name: str) -> str:
+        """
+        Extract MCP server name from a prefixed tool name.
+
+        OpenClaw plugin tools are named like: workspace_ServerName_toolName
+        """
+        parts = tool_name.split("_", 2)
+        if len(parts) >= 3 and parts[0] == "workspace":
+            return parts[1]
+        return "openclaw"
+
+    @staticmethod
+    def _parse_tool_output(output_data: Any) -> Any:
+        """Parse tool output, attempting JSON decode for string data."""
+        if isinstance(output_data, str):
+            try:
+                return json.loads(output_data)
+            except json.JSONDecodeError:
+                return output_data
+        return output_data

agent/pocketflow/__init__.py

@@ -0,0 +1,18 @@
+"""
+PocketFlow Agent Implementation
+
+This module provides an agent implementation using PocketFlow for workflow orchestration
+with trajectory tracking and MCP server support.
+
+"""
+
+from .src.agent import MCPReactAgent, MCPServerInfo
+from .src.native_agent import NativeMCPReactAgent
+from .src.agent_wrapper import MCPReactAgentNativeWrapper
+
+__all__ = [
+    "MCPReactAgent",
+    "MCPServerInfo",
+    "NativeMCPReactAgent",
+    "MCPReactAgentNativeWrapper",
+]