agenttool-sdk 0.1.0__py3-none-any.whl

agenttool/__init__.py

@@ -0,0 +1,17 @@
+"""AgentTool SDK — memory and tools for AI agents."""
+
+from .client import AgentTool
+from .exceptions import AgentToolError
+from .models import ExecuteResult, Memory, ScrapeResult, SearchResult, UsageStats
+
+__all__ = [
+    "AgentTool",
+    "AgentToolError",
+    "ExecuteResult",
+    "Memory",
+    "ScrapeResult",
+    "SearchResult",
+    "UsageStats",
+]
+
+__version__ = "0.1.0"

agenttool/client.py

@@ -0,0 +1,85 @@
+"""Main AgentTool client — the single entry point."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import httpx
+
+from .exceptions import AgentToolError
+from .memory import MemoryClient
+from .tools import ToolsClient
+
+
+class AgentTool:
+    """Unified client for the agenttool.dev platform.
+
+    Usage::
+
+        from agenttool import AgentTool
+
+        at = AgentTool()                          # reads AT_API_KEY from env
+        at.memory.store("just a string")           # store a memory
+        results = at.memory.search("what I said")  # semantic search
+        hits = at.tools.search("latest AI news")   # web search
+        page = at.tools.scrape("https://x.com")    # scrape a URL
+        out = at.tools.execute("print(42)")         # run sandboxed code
+
+    Args:
+        api_key: API key. Falls back to ``AT_API_KEY`` env var.
+        base_url: Override the API base URL.
+        timeout: Request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: str = "https://api.agenttool.dev",
+        timeout: float = 30.0,
+    ) -> None:
+        resolved_key = api_key or os.environ.get("AT_API_KEY")
+        if not resolved_key:
+            raise AgentToolError(
+                "No API key provided.",
+                hint="Pass api_key= or set the AT_API_KEY environment variable.",
+            )
+
+        self._http = httpx.Client(
+            headers={
+                "Authorization": f"Bearer {resolved_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=timeout,
+        )
+        self._base_url = base_url.rstrip("/")
+        self._memory: Optional[MemoryClient] = None
+        self._tools: Optional[ToolsClient] = None
+
+    @property
+    def memory(self) -> MemoryClient:
+        """Access the Memory API."""
+        if self._memory is None:
+            self._memory = MemoryClient(self._http, self._base_url)
+        return self._memory
+
+    @property
+    def tools(self) -> ToolsClient:
+        """Access the Tools API."""
+        if self._tools is None:
+            self._tools = ToolsClient(self._http, self._base_url)
+        return self._tools
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection."""
+        self._http.close()
+
+    def __enter__(self) -> AgentTool:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"AgentTool(base_url={self._base_url!r})"

agenttool/exceptions.py

@@ -0,0 +1,22 @@
+"""Exceptions for the AgentTool SDK."""
+
+from __future__ import annotations
+
+
+class AgentToolError(Exception):
+    """Base error for all AgentTool SDK operations.
+
+    Attributes:
+        message: Human-readable error description.
+        hint: Actionable suggestion for fixing the error.
+    """
+
+    def __init__(self, message: str, *, hint: str | None = None) -> None:
+        self.message = message
+        self.hint = hint
+        super().__init__(message)
+
+    def __str__(self) -> str:
+        if self.hint:
+            return f"{self.message} (hint: {self.hint})"
+        return self.message

agenttool/memory.py

@@ -0,0 +1,132 @@
+"""Memory client for agent-memory API."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+import httpx
+
+from .exceptions import AgentToolError
+from .models import Memory, UsageStats
+
+if TYPE_CHECKING:
+    pass
+
+
+class MemoryClient:
+    """Client for the agent-memory API.
+
+    Usage::
+
+        at = AgentTool()
+        at.memory.store("just a string")
+        results = at.memory.search("what did I learn?")
+    """
+
+    def __init__(self, http: httpx.Client, base_url: str) -> None:
+        self._http = http
+        self._base = base_url.rstrip("/")
+
+    def _url(self, path: str) -> str:
+        return f"{self._base}{path}"
+
+    def store(
+        self,
+        content: str,
+        *,
+        type: str = "semantic",
+        agent_id: Optional[str] = None,
+        key: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        importance: float = 0.5,
+    ) -> Memory:
+        """Store a memory. Only ``content`` is required.
+
+        Args:
+            content: The memory content string.
+            type: One of semantic, episodic, procedural, working.
+            agent_id: Optional agent identifier.
+            key: Optional dedup/lookup key.
+            metadata: Arbitrary metadata dict.
+            importance: 0.0–1.0 importance score.
+
+        Returns:
+            The created Memory object.
+        """
+        body: Dict[str, Any] = {"content": content, "type": type, "importance": importance}
+        if agent_id is not None:
+            body["agent_id"] = agent_id
+        if key is not None:
+            body["key"] = key
+        if metadata is not None:
+            body["metadata"] = metadata
+
+        resp = self._http.post(self._url("/v1/memories"), json=body)
+        self._check(resp)
+        return Memory.from_dict(resp.json())
+
+    def search(
+        self,
+        query: str,
+        *,
+        limit: int = 10,
+        type: Optional[str] = None,
+        agent_id: Optional[str] = None,
+    ) -> List[Memory]:
+        """Semantic search over stored memories.
+
+        Args:
+            query: Natural-language search query.
+            limit: Max results to return.
+            type: Filter by memory type.
+            agent_id: Filter by agent.
+
+        Returns:
+            List of matching Memory objects.
+        """
+        body: Dict[str, Any] = {"query": query, "limit": limit}
+        if type is not None:
+            body["type"] = type
+        if agent_id is not None:
+            body["agent_id"] = agent_id
+
+        resp = self._http.post(self._url("/v1/memories/search"), json=body)
+        self._check(resp)
+        data = resp.json()
+        results = data if isinstance(data, list) else data.get("results", [])
+        return [Memory.from_dict(m) for m in results]
+
+    def get(self, memory_id: str) -> Memory:
+        """Retrieve a single memory by ID.
+
+        Args:
+            memory_id: The memory's unique identifier.
+
+        Returns:
+            The Memory object.
+        """
+        resp = self._http.get(self._url(f"/v1/memories/{memory_id}"))
+        self._check(resp)
+        return Memory.from_dict(resp.json())
+
+    def usage(self) -> UsageStats:
+        """Get usage statistics.
+
+        Returns:
+            UsageStats with current counters.
+        """
+        resp = self._http.get(self._url("/v1/usage"))
+        self._check(resp)
+        return UsageStats.from_dict(resp.json())
+
+    @staticmethod
+    def _check(resp: httpx.Response) -> None:
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise AgentToolError(
+                f"Memory API error ({resp.status_code}): {detail}",
+                hint="Check your API key and request parameters.",
+            )

agenttool/models.py

@@ -0,0 +1,103 @@
+"""Data models for the AgentTool SDK — plain dataclasses, no pydantic."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class Memory:
+    """A stored memory."""
+
+    id: str
+    content: str
+    type: str = "semantic"
+    agent_id: Optional[str] = None
+    key: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    importance: float = 0.5
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> Memory:
+        return cls(
+            id=data.get("id", ""),
+            content=data.get("content", ""),
+            type=data.get("type", "semantic"),
+            agent_id=data.get("agent_id"),
+            key=data.get("key"),
+            metadata=data.get("metadata", {}),
+            importance=data.get("importance", 0.5),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+        )
+
+
+@dataclass
+class SearchResult:
+    """A web search result."""
+
+    title: str
+    url: str
+    snippet: str = ""
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SearchResult:
+        return cls(
+            title=data.get("title", ""),
+            url=data.get("url", ""),
+            snippet=data.get("snippet", ""),
+        )
+
+
+@dataclass
+class ScrapeResult:
+    """Result of scraping a URL."""
+
+    url: str
+    content: str
+    status_code: int = 200
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ScrapeResult:
+        return cls(
+            url=data.get("url", ""),
+            content=data.get("content", ""),
+            status_code=data.get("status_code", 200),
+        )
+
+
+@dataclass
+class ExecuteResult:
+    """Result of sandboxed code execution."""
+
+    output: str
+    error: str = ""
+    exit_code: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ExecuteResult:
+        return cls(
+            output=data.get("output", ""),
+            error=data.get("error", ""),
+            exit_code=data.get("exit_code", 0),
+        )
+
+
+@dataclass
+class UsageStats:
+    """API usage statistics."""
+
+    memories_stored: int = 0
+    searches_performed: int = 0
+    api_calls: int = 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> UsageStats:
+        return cls(
+            memories_stored=data.get("memories_stored", 0),
+            searches_performed=data.get("searches_performed", 0),
+            api_calls=data.get("api_calls", 0),
+        )

agenttool/tools.py

@@ -0,0 +1,87 @@
+"""Tools client for agent-tools API."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+import httpx
+
+from .exceptions import AgentToolError
+from .models import ExecuteResult, ScrapeResult, SearchResult
+
+
+class ToolsClient:
+    """Client for the agent-tools API.
+
+    Usage::
+
+        at = AgentTool()
+        results = at.tools.search("latest AI news")
+        page = at.tools.scrape("https://example.com")
+        out = at.tools.execute("print(1+1)")
+    """
+
+    def __init__(self, http: httpx.Client, base_url: str) -> None:
+        self._http = http
+        self._base = base_url.rstrip("/")
+
+    def _url(self, path: str) -> str:
+        return f"{self._base}{path}"
+
+    def search(self, query: str, *, num_results: int = 5) -> List[SearchResult]:
+        """Web search.
+
+        Args:
+            query: Search query string.
+            num_results: Number of results to return.
+
+        Returns:
+            List of SearchResult objects.
+        """
+        body: Dict[str, Any] = {"query": query, "num_results": num_results}
+        resp = self._http.post(self._url("/v1/search"), json=body)
+        self._check(resp)
+        data = resp.json()
+        results = data if isinstance(data, list) else data.get("results", [])
+        return [SearchResult.from_dict(r) for r in results]
+
+    def scrape(self, url: str) -> ScrapeResult:
+        """Scrape a URL and return its content.
+
+        Args:
+            url: The URL to scrape.
+
+        Returns:
+            ScrapeResult with the page content.
+        """
+        body: Dict[str, Any] = {"url": url}
+        resp = self._http.post(self._url("/v1/scrape"), json=body)
+        self._check(resp)
+        return ScrapeResult.from_dict(resp.json())
+
+    def execute(self, code: str, *, language: str = "python") -> ExecuteResult:
+        """Execute code in a sandbox.
+
+        Args:
+            code: Source code to execute.
+            language: "python" or "javascript".
+
+        Returns:
+            ExecuteResult with output, error, and exit code.
+        """
+        body: Dict[str, Any] = {"code": code, "language": language}
+        resp = self._http.post(self._url("/v1/execute"), json=body)
+        self._check(resp)
+        return ExecuteResult.from_dict(resp.json())
+
+    @staticmethod
+    def _check(resp: httpx.Response) -> None:
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise AgentToolError(
+                f"Tools API error ({resp.status_code}): {detail}",
+                hint="Check your API key and request parameters.",
+            )

agenttool_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: agenttool-sdk
+Version: 0.1.0
+Summary: Python SDK for agenttool.dev — memory and tools for AI agents
+License-Expression: MIT
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agenttool
+
+Python SDK for [agenttool.dev](https://agenttool.dev) — memory and tools for AI agents.
+
+```bash
+pip install agenttool
+```
+
+```python
+from agenttool import AgentTool
+
+at = AgentTool()  # reads AT_API_KEY from env
+at.memory.store("learned something new")
+results = at.memory.search("what did I learn?")
+hits = at.tools.search("latest AI news")
+page = at.tools.scrape("https://example.com")
+out = at.tools.execute("print(1 + 1)")
+```
+
+Set your key: `export AT_API_KEY=your-key-here`

agenttool_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+agenttool/__init__.py,sha256=tDxu8qhY3p9g7jaoKleUzC7Bx6zdh5ujiVqUTSnDM8k,378
+agenttool/client.py,sha256=AGIvjqp7n16-3wzOfJAG6zA4eZVbUxeU_GxkgwQTR_M,2540
+agenttool/exceptions.py,sha256=thaGw2FpZOk1l0rC-vefJAWe94LqtxAVObifR_m2i70,600
+agenttool/memory.py,sha256=8Mty8c5e-K3xkqbe87yE6PpAGayOuup63SVuw5mWycA,3853
+agenttool/models.py,sha256=zNd-pTnUSJm4CZ0ugjbc2JjZ7hWAJSPUsfyk2WeKx8s,2564
+agenttool/tools.py,sha256=89tGlK3WnyHcqI89Xq52G7zGaK6DsQ108m2V2KsJ8Tg,2688
+agenttool_sdk-0.1.0.dist-info/METADATA,sha256=bx6Eezf627zY7qKxF5GwIlfgiK_yKeOpuU3iSC37UBE,804
+agenttool_sdk-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agenttool_sdk-0.1.0.dist-info/RECORD,,

agenttool_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any