acontext 0.0.17__tar.gz → 0.1.0__tar.gz

{acontext-0.0.17 → acontext-0.1.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.3
 Name: acontext
-Version: 0.0.17
+Version: 0.1.0
 Summary: Python SDK for the Acontext API
 Keywords: acontext,sdk,client,api
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: openai>=2.6.1
 Requires-Dist: anthropic>=0.72.0
 Requires-Dist: pydantic>=2.12.3
+Requires-Dist: urllib3>=2.6.3
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/memodb-io/Acontext
 Project-URL: Issues, https://github.com/memodb-io/Acontext/issues

{acontext-0.0.17 → acontext-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acontext"
-version = "0.0.17"
+version = "0.1.0"
 description = "Python SDK for the Acontext API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -9,6 +9,7 @@ dependencies = [
     "openai>=2.6.1",
     "anthropic>=0.72.0",
     "pydantic>=2.12.3",
+    "urllib3>=2.6.3",
 ]
 keywords = ["acontext", "sdk", "client", "api"]
 

{acontext-0.0.17 → acontext-0.1.0}/src/acontext/agent/__init__.py

@@ -7,4 +7,3 @@ __all__ = [
     "DISK_TOOLS",
     "SKILL_TOOLS",
 ]
-

{acontext-0.0.17 → acontext-0.1.0}/src/acontext/agent/base.py

@@ -33,6 +33,9 @@ class BaseTool(BaseConverter):
     def execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
         raise NotImplementedError
 
+    async def async_execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
+        raise NotImplementedError
+
     def to_openai_tool_schema(self) -> dict:
         return {
             "type": "function",
@@ -90,6 +93,13 @@ class BaseToolPool(BaseConverter):
         r = tool.execute(ctx, llm_arguments)
         return r.strip()
 
+    async def async_execute_tool(
+        self, ctx: BaseContext, tool_name: str, llm_arguments: dict
+    ) -> str:
+        tool = self.tools[tool_name]
+        r = await tool.async_execute(ctx, llm_arguments)
+        return r.strip()
+
     def tool_exists(self, tool_name: str) -> bool:
         return tool_name in self.tools
 
@@ -104,3 +114,6 @@ class BaseToolPool(BaseConverter):
 
     def format_context(self, *args, **kwargs) -> BaseContext:
         raise NotImplementedError
+
+    async def async_format_context(self, *args, **kwargs) -> BaseContext:
+        raise NotImplementedError

{acontext-0.0.17 → acontext-0.1.0}/src/acontext/agent/disk.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 
 from .base import BaseContext, BaseTool, BaseToolPool
 from ..client import AcontextClient
+from ..async_client import AcontextAsyncClient
 from ..uploads import FileUpload
 
 
@@ -11,6 +12,12 @@ class DiskContext(BaseContext):
     disk_id: str
 
 
+@dataclass
+class AsyncDiskContext(BaseContext):
+    client: AcontextAsyncClient
+    disk_id: str
+
+
 def _normalize_path(path: str | None) -> str:
     """Normalize a file path to ensure it starts with '/'."""
     if not path:
@@ -73,6 +80,26 @@ class WriteFileTool(BaseTool):
         )
         return f"File '{artifact.filename}' written successfully to '{artifact.path}'"
 
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Write text content to a file (async)."""
+        filename = llm_arguments.get("filename")
+        content = llm_arguments.get("content")
+        file_path = llm_arguments.get("file_path")
+
+        if not filename:
+            raise ValueError("filename is required")
+        if not content:
+            raise ValueError("content is required")
+
+        normalized_path = _normalize_path(file_path)
+        payload = FileUpload(filename=filename, content=content.encode("utf-8"))
+        artifact = await ctx.client.disks.artifacts.upsert(
+            ctx.disk_id,
+            file=payload,
+            file_path=normalized_path,
+        )
+        return f"File '{artifact.filename}' written successfully to '{artifact.path}'"
+
 
 class ReadFileTool(BaseTool):
     """Tool for reading a text file from the Acontext disk."""
@@ -138,6 +165,34 @@ class ReadFileTool(BaseTool):
         preview = "\n".join(lines[line_start:line_end])
         return f"[{normalized_path}{filename} - showing L{line_start}-{line_end} of {len(lines)} lines]\n{preview}"
 
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Read a text file and return its content preview (async)."""
+        filename = llm_arguments.get("filename")
+        file_path = llm_arguments.get("file_path")
+        line_offset = llm_arguments.get("line_offset", 0)
+        line_limit = llm_arguments.get("line_limit", 100)
+
+        if not filename:
+            raise ValueError("filename is required")
+
+        normalized_path = _normalize_path(file_path)
+        result = await ctx.client.disks.artifacts.get(
+            ctx.disk_id,
+            file_path=normalized_path,
+            filename=filename,
+            with_content=True,
+        )
+
+        if not result.content:
+            raise RuntimeError("Failed to read file: server did not return content.")
+
+        content_str = result.content.raw
+        lines = content_str.split("\n")
+        line_start = min(line_offset, len(lines) - 1)
+        line_end = min(line_start + line_limit, len(lines))
+        preview = "\n".join(lines[line_start:line_end])
+        return f"[{normalized_path}{filename} - showing L{line_start}-{line_end} of {len(lines)} lines]\n{preview}"
+
 
 class ReplaceStringTool(BaseTool):
     """Tool for replacing an old string with a new string in a file on the Acontext disk."""
@@ -221,6 +276,52 @@ class ReplaceStringTool(BaseTool):
 
         return f"Found {replacement_count} old_string in {normalized_path}{filename} and replaced it."
 
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Replace an old string with a new string in a file (async)."""
+        filename = llm_arguments.get("filename")
+        file_path = llm_arguments.get("file_path")
+        old_string = llm_arguments.get("old_string")
+        new_string = llm_arguments.get("new_string")
+
+        if not filename:
+            raise ValueError("filename is required")
+        if old_string is None:
+            raise ValueError("old_string is required")
+        if new_string is None:
+            raise ValueError("new_string is required")
+
+        normalized_path = _normalize_path(file_path)
+
+        # Read the file content
+        result = await ctx.client.disks.artifacts.get(
+            ctx.disk_id,
+            file_path=normalized_path,
+            filename=filename,
+            with_content=True,
+        )
+
+        if not result.content:
+            raise RuntimeError("Failed to read file: server did not return content.")
+
+        content_str = result.content.raw
+
+        # Perform the replacement
+        if old_string not in content_str:
+            return f"String '{old_string}' not found in file '{filename}'"
+
+        updated_content = content_str.replace(old_string, new_string)
+        replacement_count = content_str.count(old_string)
+
+        # Write the updated content back
+        payload = FileUpload(filename=filename, content=updated_content.encode("utf-8"))
+        await ctx.client.disks.artifacts.upsert(
+            ctx.disk_id,
+            file=payload,
+            file_path=normalized_path,
+        )
+
+        return f"Found {replacement_count} old_string in {normalized_path}{filename} and replaced it."
+
 
 class ListTool(BaseTool):
     """Tool for listing files in a directory on the Acontext disk."""
@@ -271,6 +372,31 @@ Directories:
 Files:
 {file_sect}"""
 
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """List all files in a specified path (async)."""
+        file_path = llm_arguments.get("file_path")
+        normalized_path = _normalize_path(file_path)
+
+        result = await ctx.client.disks.artifacts.list(
+            ctx.disk_id,
+            path=normalized_path,
+        )
+
+        artifacts_list = [artifact.filename for artifact in result.artifacts]
+
+        if not artifacts_list and not result.directories:
+            return f"No files or directories found in '{normalized_path}'"
+
+        file_sect = "\n".join(artifacts_list) or "[NO FILE]"
+        dir_sect = (
+            "\n".join([d.rstrip("/") + "/" for d in result.directories]) or "[NO DIR]"
+        )
+        return f"""[Listing in {normalized_path}]
+Directories:
+{dir_sect}
+Files:
+{file_sect}"""
+
 
 class DownloadFileTool(BaseTool):
     """Tool for getting a public download URL for a file on the Acontext disk."""
@@ -327,6 +453,29 @@ class DownloadFileTool(BaseTool):
 
         return f"Public download URL for '{normalized_path}{filename}' (expires in {expire}s):\n{result.public_url}"
 
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Get a public download URL for a file (async)."""
+        filename = llm_arguments.get("filename")
+        file_path = llm_arguments.get("file_path")
+        expire = llm_arguments.get("expire", 3600)
+
+        if not filename:
+            raise ValueError("filename is required")
+
+        normalized_path = _normalize_path(file_path)
+        result = await ctx.client.disks.artifacts.get(
+            ctx.disk_id,
+            file_path=normalized_path,
+            filename=filename,
+            with_public_url=True,
+            expire=expire,
+        )
+
+        if not result.public_url:
+            raise RuntimeError("Failed to get public URL: server did not return a URL.")
+
+        return f"Public download URL for '{normalized_path}{filename}' (expires in {expire}s):\n{result.public_url}"
+
 
 class GrepArtifactsTool(BaseTool):
     """Tool for searching artifact content using regex patterns."""
@@ -377,7 +526,34 @@ class GrepArtifactsTool(BaseTool):
         for artifact in results:
             matches.append(f"{artifact.path}{artifact.filename}")
 
-        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(matches)
+        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(
+            matches
+        )
+
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Search artifact content using regex pattern (async)."""
+        query = llm_arguments.get("query")
+        limit = llm_arguments.get("limit", 100)
+
+        if not query:
+            raise ValueError("query is required")
+
+        results = await ctx.client.disks.artifacts.grep_artifacts(
+            ctx.disk_id,
+            query=query,
+            limit=limit,
+        )
+
+        if not results:
+            return f"No matches found for pattern '{query}'"
+
+        matches = []
+        for artifact in results:
+            matches.append(f"{artifact.path}{artifact.filename}")
+
+        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(
+            matches
+        )
 
 
 class GlobArtifactsTool(BaseTool):
@@ -429,7 +605,34 @@ class GlobArtifactsTool(BaseTool):
         for artifact in results:
             matches.append(f"{artifact.path}{artifact.filename}")
 
-        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(matches)
+        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(
+            matches
+        )
+
+    async def async_execute(self, ctx: AsyncDiskContext, llm_arguments: dict) -> str:
+        """Search artifact paths using glob pattern (async)."""
+        query = llm_arguments.get("query")
+        limit = llm_arguments.get("limit", 100)
+
+        if not query:
+            raise ValueError("query is required")
+
+        results = await ctx.client.disks.artifacts.glob_artifacts(
+            ctx.disk_id,
+            query=query,
+            limit=limit,
+        )
+
+        if not results:
+            return f"No files found matching pattern '{query}'"
+
+        matches = []
+        for artifact in results:
+            matches.append(f"{artifact.path}{artifact.filename}")
+
+        return f"Found {len(matches)} file(s) matching '{query}':\n" + "\n".join(
+            matches
+        )
 
 
 class DiskToolPool(BaseToolPool):
@@ -438,6 +641,11 @@ class DiskToolPool(BaseToolPool):
     def format_context(self, client: AcontextClient, disk_id: str) -> DiskContext:
         return DiskContext(client=client, disk_id=disk_id)
 
+    async def async_format_context(
+        self, client: AcontextAsyncClient, disk_id: str
+    ) -> AsyncDiskContext:
+        return AsyncDiskContext(client=client, disk_id=disk_id)
+
 
 DISK_TOOLS = DiskToolPool()
 DISK_TOOLS.add_tool(WriteFileTool())
@@ -447,48 +655,3 @@ DISK_TOOLS.add_tool(ListTool())
 DISK_TOOLS.add_tool(GrepArtifactsTool())
 DISK_TOOLS.add_tool(GlobArtifactsTool())
 DISK_TOOLS.add_tool(DownloadFileTool())
-
-
-if __name__ == "__main__":
-    client = AcontextClient(
-        api_key="sk-ac-your-root-api-bearer-token",
-        base_url="http://localhost:8029/api/v1",
-    )
-    print(client.ping())
-    new_disk = client.disks.create()
-
-    ctx = DISK_TOOLS.format_context(client, new_disk.id)
-    r = DISK_TOOLS.execute_tool(
-        ctx,
-        "write_file",
-        {"filename": "test.txt", "file_path": "/try/", "content": "Hello, world!"},
-    )
-    print(r)
-    r = DISK_TOOLS.execute_tool(
-        ctx, "read_file", {"filename": "test.txt", "file_path": "/try/"}
-    )
-    print(r)
-    r = DISK_TOOLS.execute_tool(ctx, "list_artifacts", {"file_path": "/"})
-    print(r)
-
-    r = DISK_TOOLS.execute_tool(
-        ctx,
-        "replace_string",
-        {
-            "filename": "test.txt",
-            "file_path": "/try/",
-            "old_string": "Hello",
-            "new_string": "Hi",
-        },
-    )
-    print(r)
-    r = DISK_TOOLS.execute_tool(
-        ctx, "read_file", {"filename": "test.txt", "file_path": "/try/"}
-    )
-    print(r)
-    r = DISK_TOOLS.execute_tool(
-        ctx,
-        "download_file",
-        {"filename": "test.txt", "file_path": "/try/", "expire": 300},
-    )
-    print(r)