dacp 0.1.0__tar.gz

dacp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DACP Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

dacp-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: dacp
+Version: 0.1.0
+Summary: DACP - Declarative Agent Communication Protocol for LLM/agent communications and tool function calls
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/dacp
+Project-URL: Repository, https://github.com/yourusername/dacp
+Project-URL: Issues, https://github.com/yourusername/dacp/issues
+Keywords: llm,agent,tools,openai,communication
+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.8
+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.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.28.0; extra == "dev"
+Dynamic: license-file
+
+# DACP - Delcarative Agent Communication Protocol
+
+A Python library for managing LLM/agent communications and tool function calls following the OAS Open Agent Specification.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import dacp
+
+# Register a custom tool
+def my_custom_tool(param1: str, param2: int) -> dict:
+    return {"result": f"Processed {param1} with {param2}"}
+
+dacp.register_tool("my_custom_tool", my_custom_tool)
+
+# Call an LLM
+response = dacp.call_llm("What is the weather like today?")
+
+# Parse agent response
+parsed = dacp.parse_agent_response(response)
+
+# Check if it's a tool request
+if dacp.is_tool_request(parsed):
+    tool_name, args = dacp.get_tool_request(parsed)
+    result = dacp.run_tool(tool_name, args)
+    tool_response = dacp.wrap_tool_result(tool_name, result)
+```
+
+## Features
+
+- **Tool Registry**: Register and manage custom tools for LLM agents
+- **LLM Integration**: Built-in support for OpenAI models (extensible)
+- **Protocol Parsing**: Parse and validate agent responses
+- **Tool Execution**: Safe execution of registered tools
+- **OAS Compliance**: Follows Open Agent Specification standards
+
+## API Reference
+
+### Tools
+
+- `register_tool(tool_id: str, func)`: Register a new tool
+- `run_tool(tool_id: str, args: Dict) -> dict`: Execute a registered tool
+- `TOOL_REGISTRY`: Access the current tool registry
+
+### LLM
+
+- `call_llm(prompt: str, model: str = "gpt-4") -> str`: Call an LLM with a prompt
+
+### Protocol
+
+- `parse_agent_response(response: str | dict) -> dict`: Parse agent response
+- `is_tool_request(msg: dict) -> bool`: Check if message is a tool request
+- `get_tool_request(msg: dict) -> tuple[str, dict]`: Extract tool request details
+- `wrap_tool_result(name: str, result: dict) -> dict`: Wrap tool result for agent
+- `is_final_response(msg: dict) -> bool`: Check if message is a final response
+- `get_final_response(msg: dict) -> dict`: Extract final response
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black .
+
+# Lint code
+flake8
+```
+
+## License
+
+MIT License

dacp-0.1.0/README.md

@@ -0,0 +1,82 @@
+# DACP - Delcarative Agent Communication Protocol
+
+A Python library for managing LLM/agent communications and tool function calls following the OAS Open Agent Specification.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import dacp
+
+# Register a custom tool
+def my_custom_tool(param1: str, param2: int) -> dict:
+    return {"result": f"Processed {param1} with {param2}"}
+
+dacp.register_tool("my_custom_tool", my_custom_tool)
+
+# Call an LLM
+response = dacp.call_llm("What is the weather like today?")
+
+# Parse agent response
+parsed = dacp.parse_agent_response(response)
+
+# Check if it's a tool request
+if dacp.is_tool_request(parsed):
+    tool_name, args = dacp.get_tool_request(parsed)
+    result = dacp.run_tool(tool_name, args)
+    tool_response = dacp.wrap_tool_result(tool_name, result)
+```
+
+## Features
+
+- **Tool Registry**: Register and manage custom tools for LLM agents
+- **LLM Integration**: Built-in support for OpenAI models (extensible)
+- **Protocol Parsing**: Parse and validate agent responses
+- **Tool Execution**: Safe execution of registered tools
+- **OAS Compliance**: Follows Open Agent Specification standards
+
+## API Reference
+
+### Tools
+
+- `register_tool(tool_id: str, func)`: Register a new tool
+- `run_tool(tool_id: str, args: Dict) -> dict`: Execute a registered tool
+- `TOOL_REGISTRY`: Access the current tool registry
+
+### LLM
+
+- `call_llm(prompt: str, model: str = "gpt-4") -> str`: Call an LLM with a prompt
+
+### Protocol
+
+- `parse_agent_response(response: str | dict) -> dict`: Parse agent response
+- `is_tool_request(msg: dict) -> bool`: Check if message is a tool request
+- `get_tool_request(msg: dict) -> tuple[str, dict]`: Extract tool request details
+- `wrap_tool_result(name: str, result: dict) -> dict`: Wrap tool result for agent
+- `is_final_response(msg: dict) -> bool`: Check if message is a final response
+- `get_final_response(msg: dict) -> dict`: Extract final response
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black .
+
+# Lint code
+flake8
+```
+
+## License
+
+MIT License

dacp-0.1.0/dacp/__init__.py

@@ -0,0 +1,31 @@
+"""
+DACP - Declarative Agent Communication Protocol
+
+A Python library for managing LLM/agent communications and tool function calls
+following the OAS Open Agent Specification.
+"""
+
+from .tools import register_tool, run_tool, TOOL_REGISTRY
+from .llm import call_llm
+from .protocol import (
+    parse_agent_response,
+    is_tool_request,
+    get_tool_request,
+    wrap_tool_result,
+    is_final_response,
+    get_final_response,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "register_tool",
+    "run_tool",
+    "TOOL_REGISTRY",
+    "call_llm",
+    "parse_agent_response",
+    "is_tool_request",
+    "get_tool_request",
+    "wrap_tool_result",
+    "is_final_response",
+    "get_final_response",
+]

dacp-0.1.0/dacp/llm.py

@@ -0,0 +1,19 @@
+import os
+import openai
+
+
+def call_llm(prompt: str, model: str = "gpt-4") -> str:
+    # Default: OpenAI, can later extend for other LLMs
+    client = openai.OpenAI(
+        api_key=os.getenv("OPENAI_API_KEY"), base_url="https://api.openai.com/v1"
+    )
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7,
+        max_tokens=150,
+    )
+    content = response.choices[0].message.content
+    if content is None:
+        raise ValueError("LLM returned empty response")
+    return content

dacp-0.1.0/dacp/protocol.py

@@ -0,0 +1,35 @@
+import json
+from typing import Dict, Any, Union, Tuple, cast
+
+
+def parse_agent_response(response: Union[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Parse the agent/LLM response (as string or dict) and return a dict.
+    """
+    if isinstance(response, dict):
+        return response
+    try:
+        return cast(Dict[str, Any], json.loads(response))
+    except Exception as e:
+        raise ValueError(f"Malformed agent response: {e}")
+
+
+def is_tool_request(msg: Dict[str, Any]) -> bool:
+    return "tool_request" in msg
+
+
+def get_tool_request(msg: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    req = msg["tool_request"]
+    return req["name"], req.get("args", {})
+
+
+def wrap_tool_result(name: str, result: Dict[str, Any]) -> Dict[str, Any]:
+    return {"tool_result": {"name": name, "result": result}}
+
+
+def is_final_response(msg: Dict[str, Any]) -> bool:
+    return "final_response" in msg
+
+
+def get_final_response(msg: Dict[str, Any]) -> Dict[str, Any]:
+    return cast(Dict[str, Any], msg["final_response"])

dacp-0.1.0/dacp/tools.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any, Callable
+
+TOOL_REGISTRY: Dict[str, Callable[..., Dict[str, Any]]] = {}
+
+
+def register_tool(tool_id: str, func: Callable[..., Dict[str, Any]]) -> None:
+    """Register a tool function."""
+    TOOL_REGISTRY[tool_id] = func
+
+
+def run_tool(tool_id: str, args: Dict[str, Any]) -> Dict[str, Any]:
+    """Run a registered tool with the given arguments."""
+    if tool_id not in TOOL_REGISTRY:
+        raise ValueError(f"Unknown tool: {tool_id}")
+    tool_func = TOOL_REGISTRY[tool_id]
+    return tool_func(**args)
+
+
+# --- Example tool ---
+def file_writer(path: str, content: str) -> dict:
+    # Only allow paths in /tmp or ./output for now!
+    allowed_prefixes = ["./output/", "/tmp/"]
+    if not any(path.startswith(prefix) for prefix in allowed_prefixes):
+        raise ValueError("Path not allowed")
+    with open(path, "w") as f:
+        f.write(content)
+    return {"result": f"Written to {path}"}
+
+
+register_tool("file_writer", file_writer)

dacp-0.1.0/dacp.egg-info/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: dacp
+Version: 0.1.0
+Summary: DACP - Declarative Agent Communication Protocol for LLM/agent communications and tool function calls
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/dacp
+Project-URL: Repository, https://github.com/yourusername/dacp
+Project-URL: Issues, https://github.com/yourusername/dacp/issues
+Keywords: llm,agent,tools,openai,communication
+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.8
+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.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.28.0; extra == "dev"
+Dynamic: license-file
+
+# DACP - Delcarative Agent Communication Protocol
+
+A Python library for managing LLM/agent communications and tool function calls following the OAS Open Agent Specification.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import dacp
+
+# Register a custom tool
+def my_custom_tool(param1: str, param2: int) -> dict:
+    return {"result": f"Processed {param1} with {param2}"}
+
+dacp.register_tool("my_custom_tool", my_custom_tool)
+
+# Call an LLM
+response = dacp.call_llm("What is the weather like today?")
+
+# Parse agent response
+parsed = dacp.parse_agent_response(response)
+
+# Check if it's a tool request
+if dacp.is_tool_request(parsed):
+    tool_name, args = dacp.get_tool_request(parsed)
+    result = dacp.run_tool(tool_name, args)
+    tool_response = dacp.wrap_tool_result(tool_name, result)
+```
+
+## Features
+
+- **Tool Registry**: Register and manage custom tools for LLM agents
+- **LLM Integration**: Built-in support for OpenAI models (extensible)
+- **Protocol Parsing**: Parse and validate agent responses
+- **Tool Execution**: Safe execution of registered tools
+- **OAS Compliance**: Follows Open Agent Specification standards
+
+## API Reference
+
+### Tools
+
+- `register_tool(tool_id: str, func)`: Register a new tool
+- `run_tool(tool_id: str, args: Dict) -> dict`: Execute a registered tool
+- `TOOL_REGISTRY`: Access the current tool registry
+
+### LLM
+
+- `call_llm(prompt: str, model: str = "gpt-4") -> str`: Call an LLM with a prompt
+
+### Protocol
+
+- `parse_agent_response(response: str | dict) -> dict`: Parse agent response
+- `is_tool_request(msg: dict) -> bool`: Check if message is a tool request
+- `get_tool_request(msg: dict) -> tuple[str, dict]`: Extract tool request details
+- `wrap_tool_result(name: str, result: dict) -> dict`: Wrap tool result for agent
+- `is_final_response(msg: dict) -> bool`: Check if message is a final response
+- `get_final_response(msg: dict) -> dict`: Extract final response
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black .
+
+# Lint code
+flake8
+```
+
+## License
+
+MIT License

dacp-0.1.0/dacp.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+dacp/__init__.py
+dacp/exceptions.py
+dacp/llm.py
+dacp/protocol.py
+dacp/tools.py
+dacp/types.py
+dacp.egg-info/PKG-INFO
+dacp.egg-info/SOURCES.txt
+dacp.egg-info/dependency_links.txt
+dacp.egg-info/requires.txt
+dacp.egg-info/top_level.txt
+tests/test_llm.py
+tests/test_protocol.py
+tests/test_tools.py

dacp-0.1.0/dacp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dacp-0.1.0/dacp.egg-info/requires.txt

@@ -0,0 +1,9 @@
+openai>=1.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=22.0.0
+flake8>=5.0.0
+mypy>=1.0.0
+types-requests>=2.28.0

dacp-0.1.0/dacp.egg-info/top_level.txt

@@ -0,0 +1 @@
+dacp

dacp-0.1.0/pyproject.toml

@@ -0,0 +1,101 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dacp"
+version = "0.1.0"
+description = "DACP - Declarative Agent Communication Protocol for LLM/agent communications and tool function calls"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+keywords = ["llm", "agent", "tools", "openai", "communication"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "openai>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=22.0.0",
+    "flake8>=5.0.0",
+    "mypy>=1.0.0",
+    "types-requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/dacp"
+Repository = "https://github.com/yourusername/dacp"
+Issues = "https://github.com/yourusername/dacp/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["dacp*"]
+exclude = ["tests*"]
+
+[tool.black]
+line-length = 88
+target-version = ['py38']
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "--cov=dacp --cov-report=term-missing --cov-report=html"
+
+[tool.coverage.run]
+source = ["dacp"]
+omit = ["tests/*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]
+
+[tool.flake8]
+max-line-length = 88
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+
+[[tool.mypy.overrides]]
+module = [
+    "openai.*",
+]
+ignore_missing_imports = true 

dacp-0.1.0/setup.cfg

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

dacp-0.1.0/tests/test_llm.py

@@ -0,0 +1,116 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import os
+from dacp.llm import call_llm
+
+
+@patch("dacp.llm.openai")
+def test_call_llm_success(mock_openai):
+    """Test successful LLM call."""
+    # Mock the OpenAI client and response
+    mock_client = MagicMock()
+    mock_openai.OpenAI.return_value = mock_client
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "Hello, world!"
+    mock_client.chat.completions.create.return_value = mock_response
+
+    # Test the function
+    result = call_llm("Test prompt")
+
+    # Verify the result
+    assert result == "Hello, world!"
+
+    # Verify OpenAI was called correctly
+    mock_openai.OpenAI.assert_called_once_with(
+        api_key=os.getenv("OPENAI_API_KEY"), base_url="https://api.openai.com/v1"
+    )
+    mock_client.chat.completions.create.assert_called_once_with(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Test prompt"}],
+        temperature=0.7,
+        max_tokens=150,
+    )
+
+
+@patch("dacp.llm.openai")
+def test_call_llm_custom_model(mock_openai):
+    """Test LLM call with custom model."""
+    mock_client = MagicMock()
+    mock_openai.OpenAI.return_value = mock_client
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "Custom model response"
+    mock_client.chat.completions.create.return_value = mock_response
+
+    # Test with custom model
+    result = call_llm("Test prompt", model="gpt-3.5-turbo")
+
+    assert result == "Custom model response"
+
+    # Verify custom model was used
+    mock_client.chat.completions.create.assert_called_once_with(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": "Test prompt"}],
+        temperature=0.7,
+        max_tokens=150,
+    )
+
+
+@patch("dacp.llm.openai")
+def test_call_llm_api_error(mock_openai):
+    """Test LLM call with API error."""
+    mock_client = MagicMock()
+    mock_openai.OpenAI.return_value = mock_client
+
+    # Mock an API error
+    mock_client.chat.completions.create.side_effect = Exception("API Error")
+
+    # Test that the error is raised
+    with pytest.raises(Exception):
+        call_llm("Test prompt")
+
+
+@patch("dacp.llm.openai")
+def test_call_llm_environment_variable(mock_openai):
+    """Test that the function uses the OPENAI_API_KEY environment variable."""
+    # Set a test API key
+    test_api_key = "test-api-key-123"
+    with patch.dict(os.environ, {"OPENAI_API_KEY": test_api_key}):
+        mock_client = MagicMock()
+        mock_openai.OpenAI.return_value = mock_client
+
+        mock_response = MagicMock()
+        mock_response.choices = [MagicMock()]
+        mock_response.choices[0].message.content = "Test response"
+        mock_client.chat.completions.create.return_value = mock_response
+
+        call_llm("Test prompt")
+
+        # Verify the API key was used
+        mock_openai.OpenAI.assert_called_once_with(
+            api_key=test_api_key, base_url="https://api.openai.com/v1"
+        )
+
+
+@patch("dacp.llm.openai")
+def test_call_llm_default_parameters(mock_openai):
+    """Test that default parameters are used correctly."""
+    mock_client = MagicMock()
+    mock_openai.OpenAI.return_value = mock_client
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = "Default response"
+    mock_client.chat.completions.create.return_value = mock_response
+
+    call_llm("Test prompt")
+
+    # Verify default parameters
+    call_args = mock_client.chat.completions.create.call_args
+    assert call_args[1]["model"] == "gpt-4"
+    assert call_args[1]["temperature"] == 0.7
+    assert call_args[1]["max_tokens"] == 150
+    assert call_args[1]["messages"] == [{"role": "user", "content": "Test prompt"}]

dacp-0.1.0/tests/test_protocol.py

@@ -0,0 +1,116 @@
+import pytest
+import json
+from dacp.protocol import (
+    parse_agent_response,
+    is_tool_request,
+    get_tool_request,
+    wrap_tool_result,
+    is_final_response,
+    get_final_response,
+)
+
+
+def test_parse_agent_response_dict():
+    """Test parsing agent response that's already a dict."""
+    response = {"tool_request": {"name": "test_tool", "args": {"param": "value"}}}
+    result = parse_agent_response(response)
+    assert result == response
+
+
+def test_parse_agent_response_string():
+    """Test parsing agent response that's a JSON string."""
+    response_dict = {"tool_request": {"name": "test_tool", "args": {"param": "value"}}}
+    response_string = json.dumps(response_dict)
+    result = parse_agent_response(response_string)
+    assert result == response_dict
+
+
+def test_parse_agent_response_invalid_json():
+    """Test parsing invalid JSON string."""
+    with pytest.raises(ValueError, match="Malformed agent response"):
+        parse_agent_response("invalid json")
+
+
+def test_is_tool_request_true():
+    """Test is_tool_request returns True for tool requests."""
+    msg = {"tool_request": {"name": "test_tool", "args": {}}}
+    assert is_tool_request(msg) is True
+
+
+def test_is_tool_request_false():
+    """Test is_tool_request returns False for non-tool requests."""
+    msg = {"final_response": {"content": "Hello"}}
+    assert is_tool_request(msg) is False
+
+
+def test_get_tool_request():
+    """Test getting tool request details."""
+    msg = {"tool_request": {"name": "test_tool", "args": {"param": "value"}}}
+    name, args = get_tool_request(msg)
+    assert name == "test_tool"
+    assert args == {"param": "value"}
+
+
+def test_get_tool_request_no_args():
+    """Test getting tool request with no args."""
+    msg = {"tool_request": {"name": "test_tool"}}
+    name, args = get_tool_request(msg)
+    assert name == "test_tool"
+    assert args == {}
+
+
+def test_wrap_tool_result():
+    """Test wrapping tool result."""
+    result = {"output": "success"}
+    wrapped = wrap_tool_result("test_tool", result)
+    expected = {"tool_result": {"name": "test_tool", "result": result}}
+    assert wrapped == expected
+
+
+def test_is_final_response_true():
+    """Test is_final_response returns True for final responses."""
+    msg = {"final_response": {"content": "Hello"}}
+    assert is_final_response(msg) is True
+
+
+def test_is_final_response_false():
+    """Test is_final_response returns False for non-final responses."""
+    msg = {"tool_request": {"name": "test_tool", "args": {}}}
+    assert is_final_response(msg) is False
+
+
+def test_get_final_response():
+    """Test getting final response content."""
+    final_content = {"content": "Hello, world!"}
+    msg = {"final_response": final_content}
+    result = get_final_response(msg)
+    assert result == final_content
+
+
+def test_complex_agent_response():
+    """Test parsing a complex agent response."""
+    complex_response = {
+        "tool_request": {
+            "name": "weather_api",
+            "args": {"location": "New York", "units": "celsius"},
+        },
+        "metadata": {"timestamp": "2024-01-01T00:00:00Z", "session_id": "abc123"},
+    }
+
+    # Test parsing
+    parsed = parse_agent_response(complex_response)
+    assert parsed == complex_response
+
+    # Test tool request detection
+    assert is_tool_request(parsed) is True
+
+    # Test getting tool request
+    name, args = get_tool_request(parsed)
+    assert name == "weather_api"
+    assert args == {"location": "New York", "units": "celsius"}
+
+    # Test wrapping result
+    tool_result = {"temperature": 20, "condition": "sunny"}
+    wrapped = wrap_tool_result(name, tool_result)
+    assert wrapped["tool_result"]["name"] == "weather_api"
+    assert wrapped["tool_result"]["result"] == tool_result

dacp-0.1.0/tests/test_tools.py

@@ -0,0 +1,72 @@
+import pytest
+from dacp.tools import register_tool, run_tool, TOOL_REGISTRY
+
+
+def test_register_tool():
+    """Test registering a tool."""
+
+    def test_tool(param1: str, param2: int) -> dict:
+        return {"result": f"Processed {param1} with {param2}"}
+
+    register_tool("test_tool", test_tool)
+    assert "test_tool" in TOOL_REGISTRY
+    assert TOOL_REGISTRY["test_tool"] == test_tool
+
+
+def test_run_tool():
+    """Test running a registered tool."""
+
+    def test_tool(param1: str, param2: int) -> dict:
+        return {"result": f"Processed {param1} with {param2}"}
+
+    register_tool("test_tool", test_tool)
+    result = run_tool("test_tool", {"param1": "hello", "param2": 42})
+    assert result["result"] == "Processed hello with 42"
+
+
+def test_run_nonexistent_tool():
+    """Test running a tool that doesn't exist."""
+    with pytest.raises(ValueError):
+        run_tool("nonexistent_tool", {})
+
+
+def test_tool_with_no_args():
+    """Test running a tool with no arguments."""
+
+    def no_args_tool() -> dict:
+        return {"result": "success"}
+
+    register_tool("no_args_tool", no_args_tool)
+    result = run_tool("no_args_tool", {})
+    assert result["result"] == "success"
+
+
+def test_tool_with_optional_args():
+    """Test running a tool with optional arguments."""
+
+    def optional_args_tool(required: str, optional: str = "default") -> dict:
+        return {"result": f"{required}:{optional}"}
+
+    register_tool("optional_args_tool", optional_args_tool)
+
+    # Test with both args
+    result = run_tool("optional_args_tool", {"required": "test", "optional": "custom"})
+    assert result["result"] == "test:custom"
+
+    # Test with only required arg
+    result = run_tool("optional_args_tool", {"required": "test"})
+    assert result["result"] == "test:default"
+
+
+def test_clear_tool_registry():
+    """Test that we can clear and re-register tools."""
+
+    def test_tool() -> dict:
+        return {"result": "test"}
+
+    register_tool("test_tool", test_tool)
+    assert "test_tool" in TOOL_REGISTRY
+
+    # Clear registry
+    TOOL_REGISTRY.clear()
+    assert "test_tool" not in TOOL_REGISTRY