dacp 0.1.0__py3-none-any.whl

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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+dacp/__init__.py,sha256=SY-MnntwhtBTXfVVSSEtK6rLBrlOMkWyXhfPvpeJSDo,690
+dacp/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp/llm.py,sha256=doz7mHby2pLf0khX-AVcNo9DE1yZCGLwAzaEUEfTeo0,581
+dacp/protocol.py,sha256=DVhLTdyDVlAu8ETSEX8trPeycKfMeirHwcWQ8-BY7eA,1026
+dacp/tools.py,sha256=fkRAnVPgbsOxfphYgevDmrxfIkSF3lliVWAMLThpY68,971
+dacp/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp-0.1.0.dist-info/licenses/LICENSE,sha256=tb5kgUYRypHqAy8wlrJUBSYI5l1SBmawSYHmCC-MVW0,1074
+dacp-0.1.0.dist-info/METADATA,sha256=Dwm_o_IWbwSdr3QeRFTccyGzwAwNRRQ20eG8g0BX12I,3447
+dacp-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dacp-0.1.0.dist-info/top_level.txt,sha256=Qxy0cy5jl7ttTQoGFlY9LXB6CbSvsekJ2y0P8I7L1zA,5
+dacp-0.1.0.dist-info/RECORD,,

dacp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dacp-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

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