[Haik]: ckpt, swapped the HaikFix folder to be parallel to the agents folder bc ima start the full replacement process i think

backend/apps/HaikFix/tools/shared_structs/MCP_Tool.py

@@ -0,0 +1,72 @@
+from typing import Optional, Dict, Any, Literal, Callable, Awaitable, List, Union
+from pydantic import Field
+from claude_agent_sdk import (
+    create_sdk_mcp_server, 
+    tool as sdk_tool
+)
+from claude_agent_sdk.types import (
+    McpStdioServerConfig,
+    McpSSEServerConfig,
+    McpHttpServerConfig,
+    McpSdkServerConfig,
+    McpServerConfig
+)
+from typeguard import typechecked
+from backend.apps.HaikFix.tools.shared_structs.Tool import Tool
+
+class MCP_Tool(Tool):
+    server_name: str
+    input_schema: type
+
+    @typechecked
+    def to_sdk_args(self) -> str:
+        return f"mcp__{self.server_name}__{self.name}"
+
+    @typechecked
+    def to_mcp_server_config(self) -> Dict[str, McpServerConfig]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+
+class SDK_MCP_Tool(MCP_Tool):
+    # sdk transport: in-process handler
+    handler: Callable[[Dict[str, Any]], Awaitable[Dict[str, Any]]]
+
+    @typechecked
+    def to_mcp_server_config(self) -> Dict[str, McpSdkServerConfig]:
+
+        @sdk_tool(self.name, self.description or "", self.input_schema)
+        async def sdk_handler(args):
+            return await self.handler(args)
+        
+        server: McpSdkServerConfig = create_sdk_mcp_server(self.server_name, tools=[sdk_handler])
+
+        return {self.server_name: server}
+
+
+class STDIO_MCP_Tool(MCP_Tool):
+    command: Optional[str] = None
+    args: List[str] = Field(default_factory=list)
+    env: Dict[str, str] = Field(default_factory=dict)
+
+    @typechecked
+    def to_mcp_server_config(self) -> Dict[str, McpStdioServerConfig]:
+        return {self.server_name: {
+            "type": "stdio",
+            "command": self.command,
+            "args": self.args,
+            "env": self.env,
+        }}
+
+
+class SSE_HTTP_MCP_Tool(MCP_Tool):
+    transport: Literal["sse", "http"]
+    url: Optional[str] = None
+    headers: Dict[str, str] = Field(default_factory=dict)
+
+    @typechecked
+    def to_mcp_server_config(self) -> Dict[str, Union[McpSSEServerConfig, McpHttpServerConfig]]:
+        return {self.server_name: {
+            "type": self.transport,
+            "url": self.url,
+            "headers": self.headers,
+        }}

backend/apps/HaikFix/tools/shared_structs/TOOL_PERMISSIONS.py

@@ -0,0 +1,2 @@
+from typing import Literal
+TOOL_PERMISSIONS = Literal["allow", "ask", "deny"]

backend/apps/HaikFix/tools/shared_structs/Tool.py

@@ -0,0 +1,14 @@
+from typing import Optional
+from pydantic import BaseModel
+from backend.apps.HaikFix.tools.shared_structs.TOOL_PERMISSIONS import TOOL_PERMISSIONS
+from typeguard import typechecked
+
+class Tool(BaseModel):
+    name: str
+    description: Optional[str] = None
+    deferred: bool
+    permission: TOOL_PERMISSIONS
+
+    @typechecked
+    def to_sdk_args(self) -> str:
+        return self.name

backend/apps/HaikFix/tools/shared_structs/Toolkit.py

@@ -0,0 +1,42 @@
+from typing import Optional, List
+from pydantic import BaseModel
+from backend.apps.HaikFix.tools.shared_structs.Tool import Tool
+from backend.apps.HaikFix.tools.shared_structs.TOOL_PERMISSIONS import TOOL_PERMISSIONS
+from typeguard import typechecked
+
+class Toolkit(BaseModel):
+    name: str
+    description: str
+    tools: Optional[List[Tool]] = None
+    nested_toolkits: Optional[List["Toolkit"]] = None
+
+    @typechecked
+    def __init__(
+        self, 
+        name: str, 
+        description: str, 
+        tools: Optional[List[Tool]] = None, 
+        nested_toolkits: Optional[List["Toolkit"]] = None
+    ) -> None:
+        super().__init__(
+            name=name, 
+            description=description, 
+            tools=tools, 
+            nested_toolkits=nested_toolkits
+        )
+        self.validate_structure(tools, nested_toolkits)
+
+    @typechecked
+    def validate_structure(self) -> None:
+        assert not ( (self.tools is None) and (self.nested_toolkits is None) ), "Either tools or nested_toolkits must be provided"
+        assert (self.tools is None) or (self.nested_toolkits is None), "Only one of tools or nested_toolkits can be provided"
+
+    @typechecked
+    def set_permission(self, permission: TOOL_PERMISSIONS) -> None:
+        self.validate_structure()
+        if self.tools is not None:
+            for tool in self.tools:
+                tool.permission = permission
+        if self.nested_toolkits is not None:
+            for toolkit in self.nested_toolkits:
+                toolkit.set_permission(permission)