dhara-extension 0.1.0__tar.gz

dhara_extension-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: dhara-extension
+Version: 0.1.0
+Summary: Python SDK for building Dhara extensions
+Author-email: Zosma AI <dev@zosma.ai>
+License: MIT
+Keywords: dhara,extension,json-rpc,ai,coding-agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# dhara-extension-py
+
+Python SDK for building [Dhara](https://github.com/zosmaai/dhara) extensions.
+
+## Installation
+
+```bash
+pip install dhara-extension
+```
+
+Or install from source:
+
+```bash
+cd packages/dhara-extension-py
+pip install -e .
+```
+
+## Quick Start
+
+Create a file `hello-ext/main.py`:
+
+```python
+#!/usr/bin/env python3
+"""A simple Dhara extension using the Python SDK."""
+
+from dhara_extension import Extension
+
+ext = Extension(
+    name="hello-ext",
+    version="1.0.0",
+    description="A friendly hello extension",
+)
+
+@ext.tool(
+    name="hello",
+    description="Greet someone by name",
+    parameters={
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Name to greet",
+            },
+        },
+        "required": ["name"],
+    },
+)
+def hello(input_data):
+    name = input_data.get("name", "World")
+    greeting = f"Hello, {name}! Welcome to Dhara."
+    return {
+        "content": [
+            {"type": "text", "text": greeting},
+        ],
+    }
+
+@ext.tool(
+    name="count",
+    description="Count items in a list",
+)
+def count(input_data):
+    items = input_data.get("items", [])
+    return {
+        "content": [
+            {"type": "text", "text": f"Counted {len(items)} items."},
+        ],
+    }
+
+if __name__ == "__main__":
+    ext.run()
+```
+
+And a `manifest.json`:
+
+```json
+{
+    "name": "hello-ext",
+    "version": "1.0.0",
+    "runtime": {
+        "type": "subprocess",
+        "command": "python3 main.py",
+        "protocol": "json-rpc"
+    },
+    "provides": {
+        "tools": ["hello", "count"]
+    },
+    "capabilities": []
+}
+```
+
+## API Reference
+
+### `Extension(name, version, description="", debug=False)`
+
+Main extension class.
+
+- **`tool(name, description, parameters, capabilities)`** — Decorator to register a tool handler
+- **`run()`** — Start the JSON-RPC stdin/stdout loop
+
+### `create_extension(name, version, description="")`
+
+Convenience function to create an `Extension` instance.
+
+## Protocol
+
+Extensions communicate with Dhara via JSON-RPC 2.0 over stdin/stdout:
+
+```
+→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}
+← {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"0.1.0","name":"hello-ext","tools":[...]}}
+
+→ {"jsonrpc":"2.0","id":2,"method":"tools/execute",
+     "params":{"toolName":"hello","input":{"name":"World"}}}
+← {"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"Hello, World!"}]}}
+```
+
+See the [Dhara Extension Protocol](https://github.com/zosmaai/dhara/blob/main/spec/extension-protocol.md) for details.

dhara_extension-0.1.0/README.md

@@ -0,0 +1,117 @@
+# dhara-extension-py
+
+Python SDK for building [Dhara](https://github.com/zosmaai/dhara) extensions.
+
+## Installation
+
+```bash
+pip install dhara-extension
+```
+
+Or install from source:
+
+```bash
+cd packages/dhara-extension-py
+pip install -e .
+```
+
+## Quick Start
+
+Create a file `hello-ext/main.py`:
+
+```python
+#!/usr/bin/env python3
+"""A simple Dhara extension using the Python SDK."""
+
+from dhara_extension import Extension
+
+ext = Extension(
+    name="hello-ext",
+    version="1.0.0",
+    description="A friendly hello extension",
+)
+
+@ext.tool(
+    name="hello",
+    description="Greet someone by name",
+    parameters={
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Name to greet",
+            },
+        },
+        "required": ["name"],
+    },
+)
+def hello(input_data):
+    name = input_data.get("name", "World")
+    greeting = f"Hello, {name}! Welcome to Dhara."
+    return {
+        "content": [
+            {"type": "text", "text": greeting},
+        ],
+    }
+
+@ext.tool(
+    name="count",
+    description="Count items in a list",
+)
+def count(input_data):
+    items = input_data.get("items", [])
+    return {
+        "content": [
+            {"type": "text", "text": f"Counted {len(items)} items."},
+        ],
+    }
+
+if __name__ == "__main__":
+    ext.run()
+```
+
+And a `manifest.json`:
+
+```json
+{
+    "name": "hello-ext",
+    "version": "1.0.0",
+    "runtime": {
+        "type": "subprocess",
+        "command": "python3 main.py",
+        "protocol": "json-rpc"
+    },
+    "provides": {
+        "tools": ["hello", "count"]
+    },
+    "capabilities": []
+}
+```
+
+## API Reference
+
+### `Extension(name, version, description="", debug=False)`
+
+Main extension class.
+
+- **`tool(name, description, parameters, capabilities)`** — Decorator to register a tool handler
+- **`run()`** — Start the JSON-RPC stdin/stdout loop
+
+### `create_extension(name, version, description="")`
+
+Convenience function to create an `Extension` instance.
+
+## Protocol
+
+Extensions communicate with Dhara via JSON-RPC 2.0 over stdin/stdout:
+
+```
+→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}
+← {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"0.1.0","name":"hello-ext","tools":[...]}}
+
+→ {"jsonrpc":"2.0","id":2,"method":"tools/execute",
+     "params":{"toolName":"hello","input":{"name":"World"}}}
+← {"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"Hello, World!"}]}}
+```
+
+See the [Dhara Extension Protocol](https://github.com/zosmaai/dhara/blob/main/spec/extension-protocol.md) for details.

dhara_extension-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta:__legacy__"
+
+[project]
+name = "dhara-extension"
+version = "0.1.0"
+description = "Python SDK for building Dhara extensions"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Zosma AI", email = "dev@zosma.ai" }
+]
+requires-python = ">=3.9"
+keywords = ["dhara", "extension", "json-rpc", "ai", "coding-agent"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

dhara_extension-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dhara_extension-0.1.0/src/dhara_extension/__init__.py

@@ -0,0 +1,34 @@
+"""
+dhara-extension — Python SDK for building Dhara extensions.
+
+Provides:
+- Extension class with tool registration and JSON-RPC loop
+- Protocol helpers for message parsing and serialization
+"""
+
+from .extension import Extension, create_extension, ToolHandler, ToolDefinition
+from .protocol import (
+    ErrorCodes,
+    JsonRpcRequest,
+    JsonRpcSuccess,
+    JsonRpcErrorResponse,
+    parse_message,
+    serialize_message,
+    create_success,
+    create_error,
+)
+
+__all__ = [
+    "Extension",
+    "create_extension",
+    "ToolHandler",
+    "ToolDefinition",
+    "ErrorCodes",
+    "JsonRpcRequest",
+    "JsonRpcSuccess",
+    "JsonRpcErrorResponse",
+    "parse_message",
+    "serialize_message",
+    "create_success",
+    "create_error",
+]

dhara_extension-0.1.0/src/dhara_extension/extension.py

@@ -0,0 +1,186 @@
+"""
+Main extension class for building Dhara extensions in Python.
+
+Provides a JSON-RPC stdin/stdout loop with automatic protocol handling.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, Callable
+
+from .protocol import ErrorCodes
+
+# ── Type aliases ─────────────────────────────────────────────────────────────────
+
+ToolHandler = Callable[[dict[str, Any]], dict[str, Any]]
+ToolDefinition = dict[str, Any]
+
+
+# ── Extension class ──────────────────────────────────────────────────────────────
+
+
+class Extension:
+    """
+    A Dhara extension that communicates via JSON-RPC over stdin/stdout.
+
+    Usage::
+
+        ext = Extension(name="my-ext", version="1.0.0")
+
+        @ext.tool(
+            name="hello",
+            description="Say hello",
+            parameters={"type": "object", "properties": {"name": {"type": "string"}}},
+        )
+        def hello(input: dict) -> dict:
+            name = input.get("name", "world")
+            return {"content": [{"type": "text", "text": f"Hello, {name}!"}]}
+
+        ext.run()
+    """
+
+    def __init__(
+        self,
+        name: str = "python-ext",
+        version: str = "1.0.0",
+        *,
+        description: str = "",
+        debug: bool = False,
+    ):
+        self.name = name
+        self.version = version
+        self.description = description
+        self.debug = debug
+        self._tools: dict[str, tuple[ToolDefinition, ToolHandler]] = {}
+        self._shutdown_requested = False
+
+    # ── Tool registration ───────────────────────────────────────────────────────
+
+    def tool(
+        self,
+        name: str,
+        description: str = "",
+        parameters: dict[str, Any] | None = None,
+        capabilities: list[str] | None = None,
+    ) -> Callable[[ToolHandler], ToolHandler]:
+        """
+        Decorator that registers a tool handler.
+        """
+        def decorator(handler: ToolHandler) -> ToolHandler:
+            tool_def: ToolDefinition = {
+                "name": name,
+                "description": description,
+                "parameters": parameters or {"type": "object", "properties": {}},
+            }
+            if capabilities:
+                tool_def["capabilities"] = capabilities
+            self._tools[name] = (tool_def, handler)
+            return handler
+        return decorator
+
+    # ── Message dispatch ─────────────────────────────────────────────────────────
+
+    def _dispatch(self, raw_line: str) -> str | None:
+        """
+        Dispatch a single JSON-RPC request.
+        Returns a JSON response string, or None for notifications.
+        """
+        try:
+            data = json.loads(raw_line)
+        except json.JSONDecodeError:
+            return json.dumps(
+                {"jsonrpc": "2.0", "id": None, "error": {"code": ErrorCodes.PARSE_ERROR, "message": "Invalid JSON"}},
+                separators=(",", ":"),
+            )
+
+        method = data.get("method", "")
+        msg_id = data.get("id")
+
+        if method == "initialize":
+            resp = {
+                "protocolVersion": "0.1.0",
+                "name": self.name,
+                "version": self.version,
+                "description": self.description,
+                "tools": [defn for defn, _ in self._tools.values()],
+            }
+            return json.dumps({"jsonrpc": "2.0", "id": msg_id, "result": resp}, separators=(",", ":"))
+
+        if method == "tools/execute":
+            params = data.get("params", {})
+            tool_name = params.get("toolName", "")
+            tool_input = params.get("input", {})
+
+            if tool_name not in self._tools:
+                return json.dumps(
+                    {
+                        "jsonrpc": "2.0",
+                        "id": msg_id,
+                        "error": {"code": ErrorCodes.TOOL_NOT_FOUND, "message": f"Tool not found: {tool_name}"},
+                    },
+                    separators=(",", ":"),
+                )
+
+            _defn, handler = self._tools[tool_name]
+            try:
+                result = handler(tool_input)
+                return json.dumps({"jsonrpc": "2.0", "id": msg_id, "result": result}, separators=(",", ":"))
+            except Exception as exc:
+                return json.dumps(
+                    {
+                        "jsonrpc": "2.0",
+                        "id": msg_id,
+                        "error": {"code": ErrorCodes.TOOL_EXECUTION_ERROR, "message": f"Tool error: {exc}"},
+                    },
+                    separators=(",", ":"),
+                )
+
+        if method == "shutdown":
+            self._shutdown_requested = True
+            return json.dumps(
+                {"jsonrpc": "2.0", "id": msg_id, "result": {"status": "ok"}},
+                separators=(",", ":"),
+            )
+
+        # Unknown method
+        return json.dumps(
+            {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "error": {"code": ErrorCodes.METHOD_NOT_FOUND, "message": f"Unknown: {method}"},
+            },
+            separators=(",", ":"),
+        )
+
+    # ── Main loop ────────────────────────────────────────────────────────────────
+
+    def run(self) -> None:
+        """Run the extension main loop (stdin → stdout JSON-RPC)."""
+        if self.debug:
+            sys.stderr.write(f"[dhara:{self.name}] started\n")
+
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            if self.debug:
+                sys.stderr.write(f"[dhara:{self.name}] << {line}\n")
+            response = self._dispatch(line)
+            if response:
+                print(response, flush=True)
+            if self._shutdown_requested:
+                break
+
+        if self.debug:
+            sys.stderr.write(f"[dhara:{self.name}] stopped\n")
+
+
+def create_extension(
+    name: str = "python-ext",
+    version: str = "1.0.0",
+    description: str = "",
+) -> Extension:
+    """Create a new Dhara extension instance."""
+    return Extension(name=name, version=version, description=description)

dhara_extension-0.1.0/src/dhara_extension/protocol.py

@@ -0,0 +1,160 @@
+"""JSON-RPC 2.0 message types for the Dhara extension protocol."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+# ── JSON-RPC message types ──────────────────────────────────────────────────────
+
+
+@dataclass
+class JsonRpcRequest:
+    """A JSON-RPC 2.0 request from the core."""
+
+    jsonrpc: str = "2.0"
+    id: int | str | None = None
+    method: str = ""
+    params: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class JsonRpcSuccess:
+    """A successful JSON-RPC 2.0 response."""
+
+    jsonrpc: str = "2.0"
+    id: int | str | None = None
+    result: Any = None
+
+
+@dataclass
+class JsonRpcError:
+    """A JSON-RPC 2.0 error object."""
+
+    code: int = -32603
+    message: str = "Internal error"
+    data: Any = None
+
+
+@dataclass
+class JsonRpcErrorResponse:
+    """An error JSON-RPC 2.0 response."""
+
+    jsonrpc: str = "2.0"
+    id: int | str | None = None
+    error: JsonRpcError | None = None
+
+
+JsonRpcMessage = JsonRpcRequest | JsonRpcSuccess | JsonRpcErrorResponse
+
+
+# ── Standard error codes (mirrors @zosmaai/dhara-extension) ────────────────────
+
+
+class ErrorCodes:
+    """Standard JSON-RPC error codes used by Dhara."""
+
+    PARSE_ERROR = -32700
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INVALID_PARAMS = -32602
+    INTERNAL_ERROR = -32603
+
+    # Dhara-specific codes
+    TOOL_EXECUTION_ERROR = -32000
+    TOOL_NOT_FOUND = -32001
+    CAPABILITY_DENIED = -32002
+    EXTENSION_CRASHED = -32003
+    HANDSHAKE_TIMEOUT = -32004
+    SHUTDOWN = -32005
+
+
+# ── Dhara protocol message helpers ──────────────────────────────────────────────
+
+
+def parse_message(line: str) -> JsonRpcMessage:
+    """Parse a single JSON-RPC message from a JSON string."""
+    import json
+
+    data = json.loads(line)
+
+    if "method" in data:
+        return JsonRpcRequest(
+            jsonrpc=data.get("jsonrpc", "2.0"),
+            id=data.get("id"),
+            method=data["method"],
+            params=data.get("params", {}),
+        )
+
+    if "error" in data:
+        err = data.get("error", {})
+        return JsonRpcErrorResponse(
+            jsonrpc=data.get("jsonrpc", "2.0"),
+            id=data.get("id"),
+            error=JsonRpcError(
+                code=err.get("code", -32603),
+                message=err.get("message", "Unknown error"),
+                data=err.get("data"),
+            ),
+        )
+
+    return JsonRpcSuccess(
+        jsonrpc=data.get("jsonrpc", "2.0"),
+        id=data.get("id"),
+        result=data.get("result"),
+    )
+
+
+def serialize_message(message: JsonRpcMessage) -> str:
+    """Serialize a JSON-RPC message to a JSON string."""
+    import json
+
+    if isinstance(message, JsonRpcRequest):
+        obj: dict[str, Any] = {
+            "jsonrpc": message.jsonrpc,
+            "method": message.method,
+        }
+        if message.id is not None:
+            obj["id"] = message.id
+        if message.params:
+            obj["params"] = message.params
+        return json.dumps(obj, separators=(",", ":"))
+
+    if isinstance(message, JsonRpcSuccess):
+        obj = {
+            "jsonrpc": message.jsonrpc,
+            "id": message.id,
+            "result": message.result,
+        }
+        return json.dumps(obj, separators=(",", ":"))
+
+    if isinstance(message, JsonRpcErrorResponse):
+        obj = {
+            "jsonrpc": message.jsonrpc,
+            "id": message.id,
+            "error": {
+                "code": message.error.code if message.error else ErrorCodes.INTERNAL_ERROR,
+                "message": message.error.message if message.error else "Unknown error",
+            },
+        }
+        if message.error and message.error.data:
+            obj["error"]["data"] = message.error.data
+        return json.dumps(obj, separators=(",", ":"))
+
+    return json.dumps(message, separators=(",", ":"))
+
+
+def create_success(id: int | str | None, result: Any) -> JsonRpcSuccess:
+    """Create a success response."""
+    return JsonRpcSuccess(id=id, result=result)
+
+
+def create_error(
+    id: int | str | None,
+    code: int = ErrorCodes.INTERNAL_ERROR,
+    message: str = "Internal error",
+    data: Any = None,
+) -> JsonRpcErrorResponse:
+    """Create an error response."""
+    return JsonRpcErrorResponse(id=id, error=JsonRpcError(code=code, message=message, data=data))

dhara_extension-0.1.0/src/dhara_extension.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: dhara-extension
+Version: 0.1.0
+Summary: Python SDK for building Dhara extensions
+Author-email: Zosma AI <dev@zosma.ai>
+License: MIT
+Keywords: dhara,extension,json-rpc,ai,coding-agent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# dhara-extension-py
+
+Python SDK for building [Dhara](https://github.com/zosmaai/dhara) extensions.
+
+## Installation
+
+```bash
+pip install dhara-extension
+```
+
+Or install from source:
+
+```bash
+cd packages/dhara-extension-py
+pip install -e .
+```
+
+## Quick Start
+
+Create a file `hello-ext/main.py`:
+
+```python
+#!/usr/bin/env python3
+"""A simple Dhara extension using the Python SDK."""
+
+from dhara_extension import Extension
+
+ext = Extension(
+    name="hello-ext",
+    version="1.0.0",
+    description="A friendly hello extension",
+)
+
+@ext.tool(
+    name="hello",
+    description="Greet someone by name",
+    parameters={
+        "type": "object",
+        "properties": {
+            "name": {
+                "type": "string",
+                "description": "Name to greet",
+            },
+        },
+        "required": ["name"],
+    },
+)
+def hello(input_data):
+    name = input_data.get("name", "World")
+    greeting = f"Hello, {name}! Welcome to Dhara."
+    return {
+        "content": [
+            {"type": "text", "text": greeting},
+        ],
+    }
+
+@ext.tool(
+    name="count",
+    description="Count items in a list",
+)
+def count(input_data):
+    items = input_data.get("items", [])
+    return {
+        "content": [
+            {"type": "text", "text": f"Counted {len(items)} items."},
+        ],
+    }
+
+if __name__ == "__main__":
+    ext.run()
+```
+
+And a `manifest.json`:
+
+```json
+{
+    "name": "hello-ext",
+    "version": "1.0.0",
+    "runtime": {
+        "type": "subprocess",
+        "command": "python3 main.py",
+        "protocol": "json-rpc"
+    },
+    "provides": {
+        "tools": ["hello", "count"]
+    },
+    "capabilities": []
+}
+```
+
+## API Reference
+
+### `Extension(name, version, description="", debug=False)`
+
+Main extension class.
+
+- **`tool(name, description, parameters, capabilities)`** — Decorator to register a tool handler
+- **`run()`** — Start the JSON-RPC stdin/stdout loop
+
+### `create_extension(name, version, description="")`
+
+Convenience function to create an `Extension` instance.
+
+## Protocol
+
+Extensions communicate with Dhara via JSON-RPC 2.0 over stdin/stdout:
+
+```
+→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}
+← {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"0.1.0","name":"hello-ext","tools":[...]}}
+
+→ {"jsonrpc":"2.0","id":2,"method":"tools/execute",
+     "params":{"toolName":"hello","input":{"name":"World"}}}
+← {"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"Hello, World!"}]}}
+```
+
+See the [Dhara Extension Protocol](https://github.com/zosmaai/dhara/blob/main/spec/extension-protocol.md) for details.

dhara_extension-0.1.0/src/dhara_extension.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/dhara_extension/__init__.py
+src/dhara_extension/extension.py
+src/dhara_extension/protocol.py
+src/dhara_extension.egg-info/PKG-INFO
+src/dhara_extension.egg-info/SOURCES.txt
+src/dhara_extension.egg-info/dependency_links.txt
+src/dhara_extension.egg-info/top_level.txt
+tests/test_extension.py

dhara_extension-0.1.0/src/dhara_extension.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dhara_extension-0.1.0/src/dhara_extension.egg-info/top_level.txt

@@ -0,0 +1 @@
+dhara_extension

dhara_extension-0.1.0/tests/test_extension.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Tests for the Dhara Python SDK."""
+
+import json
+import subprocess
+import sys
+import unittest
+
+
+class TestProtocolHelpers(unittest.TestCase):
+    """Test protocol.py message helpers."""
+
+    def setUp(self):
+        from dhara_extension.protocol import parse_message, serialize_message, create_success, create_error
+        import json as _json
+        self._json = _json
+        self.parse = parse_message
+        self.serialize = serialize_message
+        self.success = create_success
+        self.error = create_error
+
+    def test_parse_request(self):
+        msg = self.parse('{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"0.1.0"}}')
+        # parse_message returns dataclass objects
+        self.assertEqual(msg.method, "initialize")
+        self.assertEqual(msg.id, 1)
+
+    def test_parse_success(self):
+        msg = self.parse('{"jsonrpc":"2.0","id":1,"result":{"status":"ok"}}')
+        self.assertEqual(msg.result, {"status": "ok"})
+
+    def test_parse_error(self):
+        msg = self.parse('{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"Not found"}}')
+        self.assertEqual(msg.error.code, -32601)
+
+    def test_serialize_success(self):
+        result = self.success(1, {"tools": []})
+        raw = self.serialize(result)
+        data = json.loads(raw)
+        self.assertEqual(data["id"], 1)
+        self.assertEqual(data["result"]["tools"], [])
+
+    def test_serialize_error(self):
+        err = self.error(1, code=-32000, message="Tool error")
+        raw = self.serialize(err)
+        data = json.loads(raw)
+        self.assertEqual(data["id"], 1)
+        self.assertEqual(data["error"]["code"], -32000)
+
+    def test_create_extension(self):
+        from dhara_extension import create_extension
+        ext = create_extension("test-ext", "1.0.0", "A test extension")
+        self.assertEqual(ext.name, "test-ext")
+        self.assertEqual(ext.version, "1.0.0")
+
+
+class TestExtensionTools(unittest.TestCase):
+    """Test tool registration and dispatch."""
+
+    def setUp(self):
+        from dhara_extension import Extension
+        self.ext = Extension("test-ext", "1.0.0", description="A test extension")
+
+        @self.ext.tool(
+            name="echo",
+            description="Echo input",
+            parameters={"type": "object", "properties": {"message": {"type": "string"}}},
+        )
+        def echo(input_data):
+            msg = input_data.get("message", "")
+            return {"content": [{"type": "text", "text": msg}]}
+
+        self.echo_handler = echo
+
+    def test_tool_registration(self):
+        self.assertIn("echo", self.ext._tools)
+
+    def test_initialize_response(self):
+        import json
+        resp = self.ext._dispatch('{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}')
+        data = json.loads(resp)
+        self.assertEqual(data["id"], 1)
+        self.assertIn("tools", data["result"])
+        tool_names = [t["name"] for t in data["result"]["tools"]]
+        self.assertIn("echo", tool_names)
+
+    def test_tool_execution(self):
+        import json
+        resp = self.ext._dispatch(
+            '{"jsonrpc":"2.0","id":2,"method":"tools/execute","params":{"toolName":"echo","input":{"message":"hello"}}}'
+        )
+        data = json.loads(resp)
+        self.assertEqual(data["id"], 2)
+        self.assertEqual(data["result"]["content"][0]["text"], "hello")
+
+    def test_unknown_tool(self):
+        import json
+        resp = self.ext._dispatch(
+            '{"jsonrpc":"2.0","id":3,"method":"tools/execute","params":{"toolName":"nonexistent","input":{}}}'
+        )
+        data = json.loads(resp)
+        self.assertIn("error", data)
+        self.assertIn("not found", data["error"]["message"])
+
+    def test_shutdown(self):
+        import json
+        resp = self.ext._dispatch('{"jsonrpc":"2.0","id":4,"method":"shutdown"}')
+        data = json.loads(resp)
+        self.assertEqual(data["result"]["status"], "ok")
+        self.assertTrue(self.ext._shutdown_requested)
+
+    def test_unknown_method(self):
+        import json
+        resp = self.ext._dispatch('{"jsonrpc":"2.0","id":5,"method":"bogus","params":{}}')
+        data = json.loads(resp)
+        self.assertIn("error", data)
+        self.assertIn("Unknown", data["error"]["message"])
+
+    def test_invalid_json(self):
+        import json
+        resp = self.ext._dispatch("not json")
+        data = json.loads(resp)
+        self.assertIn("error", data)
+
+
+if __name__ == "__main__":
+    unittest.main()