acontext 0.0.18__tar.gz → 0.1.0__tar.gz

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.3
 Name: acontext
-Version: 0.0.18
+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.18 → acontext-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acontext"
-version = "0.0.18"
+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.18 → acontext-0.1.0}/src/acontext/agent/__init__.py

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

{acontext-0.0.18 → 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.18 → 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)

{acontext-0.0.18 → acontext-0.1.0}/src/acontext/agent/skill.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass, field
 
 from .base import BaseContext, BaseTool, BaseToolPool
 from ..client import AcontextClient
+from ..async_client import AcontextAsyncClient
 from ..types.skill import Skill
 
 
@@ -65,6 +66,64 @@ class SkillContext(BaseContext):
         return list(self.skills.keys())
 
 
+@dataclass
+class AsyncSkillContext(BaseContext):
+    """Async context for skill tools with preloaded skill name mapping."""
+
+    client: AcontextAsyncClient
+    skills: dict[str, Skill] = field(default_factory=dict)
+
+    @classmethod
+    async def create(
+        cls, client: AcontextAsyncClient, skill_ids: list[str]
+    ) -> "AsyncSkillContext":
+        """Create an AsyncSkillContext by preloading skills from a list of skill IDs.
+
+        Args:
+            client: The Acontext async client instance.
+            skill_ids: List of skill UUIDs to preload.
+
+        Returns:
+            AsyncSkillContext with preloaded skills mapped by name.
+
+        Raises:
+            ValueError: If duplicate skill names are found.
+        """
+        skills: dict[str, Skill] = {}
+        for skill_id in skill_ids:
+            skill = await client.skills.get(skill_id)
+            if skill.name in skills:
+                raise ValueError(
+                    f"Duplicate skill name '{skill.name}' found. "
+                    f"Existing ID: {skills[skill.name].id}, New ID: {skill.id}"
+                )
+            skills[skill.name] = skill
+        return cls(client=client, skills=skills)
+
+    def get_skill(self, skill_name: str) -> Skill:
+        """Get a skill by name from the preloaded skills.
+
+        Args:
+            skill_name: The name of the skill.
+
+        Returns:
+            The Skill object.
+
+        Raises:
+            ValueError: If the skill is not found in the context.
+        """
+        if skill_name not in self.skills:
+            available = ", ".join(self.skills.keys()) if self.skills else "[none]"
+            raise ValueError(
+                f"Skill '{skill_name}' not found in context. Available skills: {available}"
+            )
+        return self.skills[skill_name]
+
+    def list_skill_names(self) -> list[str]:
+        """Return list of available skill names in this context."""
+        return list(self.skills.keys())
+
+
 class GetSkillTool(BaseTool):
     """Tool for getting a skill by name."""
 
@@ -121,6 +180,35 @@ class GetSkillTool(BaseTool):
             f"{file_list}"
         )
 
+    async def async_execute(self, ctx: AsyncSkillContext, llm_arguments: dict) -> str:
+        """Get a skill by name (async)."""
+        skill_name = llm_arguments.get("skill_name")
+
+        if not skill_name:
+            raise ValueError("skill_name is required")
+
+        skill = ctx.get_skill(skill_name)
+
+        file_count = len(skill.file_index)
+
+        # Format all files with path and MIME type
+        if skill.file_index:
+            file_list = "\n".join(
+                [
+                    f"  - {file_info.path} ({file_info.mime})"
+                    for file_info in skill.file_index
+                ]
+            )
+        else:
+            file_list = "  [NO FILES]"
+
+        return (
+            f"Skill: {skill.name} (ID: {skill.id})\n"
+            f"Description: {skill.description}\n"
+            f"Files: {file_count} file(s)\n"
+            f"{file_list}"
+        )
+
 
 class GetSkillFileTool(BaseTool):
     """Tool for getting a file from a skill."""
@@ -197,6 +285,45 @@ class GetSkillFileTool(BaseTool):
 
         return "\n".join(output_parts)
 
+    async def async_execute(self, ctx: AsyncSkillContext, llm_arguments: dict) -> str:
+        """Get a skill file (async)."""
+        skill_name = llm_arguments.get("skill_name")
+        file_path = llm_arguments.get("file_path")
+        expire = llm_arguments.get("expire")
+
+        if not skill_name:
+            raise ValueError("skill_name is required")
+        if not file_path:
+            raise ValueError("file_path is required")
+
+        skill = ctx.get_skill(skill_name)
+
+        result = await ctx.client.skills.get_file(
+            skill_id=skill.id,
+            file_path=file_path,
+            expire=expire,
+        )
+
+        output_parts = [
+            f"File '{result.path}' (MIME: {result.mime}) from skill '{skill_name}':"
+        ]
+
+        if result.content:
+            output_parts.append(f"\nContent (type: {result.content.type}):")
+            output_parts.append(result.content.raw)
+
+        if result.url:
+            expire_seconds = expire if expire is not None else 900
+            output_parts.append(
+                f"\nDownload URL (expires in {expire_seconds} seconds):"
+            )
+            output_parts.append(result.url)
+
+        if not result.content and not result.url:
+            return f"File '{result.path}' retrieved but no content or URL returned."
+
+        return "\n".join(output_parts)
+
 
 class ListSkillsTool(BaseTool):
     """Tool for listing available skills in the context."""
@@ -228,6 +355,17 @@ class ListSkillsTool(BaseTool):
 
         return f"Available skills ({len(ctx.skills)}):\n" + "\n".join(skill_list)
 
+    async def async_execute(self, ctx: AsyncSkillContext, llm_arguments: dict) -> str:
+        """List all available skills (async)."""
+        if not ctx.skills:
+            return "No skills available in the current context."
+
+        skill_list = []
+        for skill_name, skill in ctx.skills.items():
+            skill_list.append(f"- {skill_name}: {skill.description}")
+
+        return f"Available skills ({len(ctx.skills)}):\n" + "\n".join(skill_list)
+
 
 class SkillToolPool(BaseToolPool):
     """Tool pool for skill operations on Acontext skills."""
@@ -246,6 +384,20 @@ class SkillToolPool(BaseToolPool):
         """
         return SkillContext.create(client=client, skill_ids=skill_ids)
 
+    async def async_format_context(
+        self, client: AcontextAsyncClient, skill_ids: list[str]
+    ) -> AsyncSkillContext:
+        """Create an AsyncSkillContext by preloading skills from a list of skill IDs.
+
+        Args:
+            client: The Acontext async client instance.
+            skill_ids: List of skill UUIDs to preload.
+
+        Returns:
+            AsyncSkillContext with preloaded skills mapped by name.
+        """
+        return await AsyncSkillContext.create(client=client, skill_ids=skill_ids)
+
 
 SKILL_TOOLS = SkillToolPool()
 SKILL_TOOLS.add_tool(ListSkillsTool())

{acontext-0.0.18 → acontext-0.1.0}/src/acontext/resources/async_disks.py

@@ -33,26 +33,28 @@ class AsyncDisksAPI:
         time_desc: bool | None = None,
     ) -> ListDisksOutput:
         """List all disks in the project.
-        
+
         Args:
             user: Filter by user identifier. Defaults to None.
             limit: Maximum number of disks to return. Defaults to None.
             cursor: Cursor for pagination. Defaults to None.
             time_desc: Order by created_at descending if True, ascending if False. Defaults to None.
-            
+
         Returns:
             ListDisksOutput containing the list of disks and pagination information.
         """
-        params = build_params(user=user, limit=limit, cursor=cursor, time_desc=time_desc)
+        params = build_params(
+            user=user, limit=limit, cursor=cursor, time_desc=time_desc
+        )
         data = await self._requester.request("GET", "/disk", params=params or None)
         return ListDisksOutput.model_validate(data)
 
     async def create(self, *, user: str | None = None) -> Disk:
         """Create a new disk.
-        
+
         Args:
             user: Optional user identifier string. Defaults to None.
-            
+
         Returns:
             The created Disk object.
         """
@@ -64,7 +66,7 @@ class AsyncDisksAPI:
 
     async def delete(self, disk_id: str) -> None:
         """Delete a disk by its ID.
-        
+
         Args:
             disk_id: The UUID of the disk to delete.
         """
@@ -79,20 +81,22 @@ class AsyncDiskArtifactsAPI:
         self,
         disk_id: str,
         *,
-        file: FileUpload
-        | tuple[str, BinaryIO | bytes]
-        | tuple[str, BinaryIO | bytes, str],
+        file: (
+            FileUpload
+            | tuple[str, BinaryIO | bytes]
+            | tuple[str, BinaryIO | bytes, str]
+        ),
         file_path: str | None = None,
         meta: Mapping[str, Any] | None = None,
     ) -> Artifact:
         """Upload a file to create or update an artifact.
-        
+
         Args:
             disk_id: The UUID of the disk.
             file: The file to upload (FileUpload object or tuple format).
             file_path: Directory path (not including filename), defaults to "/".
             meta: Custom metadata as JSON-serializable dict, defaults to None.
-            
+
         Returns:
             Artifact containing the created/updated artifact information.
         """
@@ -122,7 +126,7 @@ class AsyncDiskArtifactsAPI:
         expire: int | None = None,
     ) -> GetArtifactResp:
         """Get an artifact by disk ID, file path, and filename.
-        
+
         Args:
             disk_id: The UUID of the disk.
             file_path: Directory path (not including filename).
@@ -130,7 +134,7 @@ class AsyncDiskArtifactsAPI:
             with_public_url: Whether to include a presigned public URL. Defaults to None.
             with_content: Whether to include file content. Defaults to None.
             expire: URL expiration time in seconds. Defaults to None.
-            
+
         Returns:
             GetArtifactResp containing the artifact and optionally public URL and content.
         """
@@ -141,7 +145,9 @@ class AsyncDiskArtifactsAPI:
             with_content=with_content,
             expire=expire,
         )
-        data = await self._requester.request("GET", f"/disk/{disk_id}/artifact", params=params)
+        data = await self._requester.request(
+            "GET", f"/disk/{disk_id}/artifact", params=params
+        )
         return GetArtifactResp.model_validate(data)
 
     async def update(
@@ -153,13 +159,13 @@ class AsyncDiskArtifactsAPI:
         meta: Mapping[str, Any],
     ) -> UpdateArtifactResp:
         """Update an artifact's metadata.
-        
+
         Args:
             disk_id: The UUID of the disk.
             file_path: Directory path (not including filename).
             filename: The filename of the artifact.
             meta: Custom metadata as JSON-serializable dict.
-            
+
         Returns:
             UpdateArtifactResp containing the updated artifact information.
         """
@@ -168,7 +174,9 @@ class AsyncDiskArtifactsAPI:
             "file_path": full_path,
             "meta": json.dumps(cast(Mapping[str, Any], meta)),
         }
-        data = await self._requester.request("PUT", f"/disk/{disk_id}/artifact", json_data=payload)
+        data = await self._requester.request(
+            "PUT", f"/disk/{disk_id}/artifact", json_data=payload
+        )
         return UpdateArtifactResp.model_validate(data)
 
     async def delete(
@@ -179,7 +187,7 @@ class AsyncDiskArtifactsAPI:
         filename: str,
     ) -> None:
         """Delete an artifact by disk ID, file path, and filename.
-        
+
         Args:
             disk_id: The UUID of the disk.
             file_path: Directory path (not including filename).
@@ -187,7 +195,9 @@ class AsyncDiskArtifactsAPI:
         """
         full_path = f"{file_path.rstrip('/')}/{filename}"
         params = {"file_path": full_path}
-        await self._requester.request("DELETE", f"/disk/{disk_id}/artifact", params=params)
+        await self._requester.request(
+            "DELETE", f"/disk/{disk_id}/artifact", params=params
+        )
 
     async def list(
         self,
@@ -195,9 +205,83 @@ class AsyncDiskArtifactsAPI:
         *,
         path: str | None = None,
     ) -> ListArtifactsResp:
+        """List artifacts in a disk at a specific path.
+
+        Args:
+            disk_id: The UUID of the disk.
+            path: Directory path to list. Defaults to None (root).
+
+        Returns:
+            ListArtifactsResp containing the list of artifacts.
+        """
         params: dict[str, Any] = {}
         if path is not None:
             params["path"] = path
-        data = await self._requester.request("GET", f"/disk/{disk_id}/artifact/ls", params=params or None)
+        data = await self._requester.request(
+            "GET", f"/disk/{disk_id}/artifact/ls", params=params or None
+        )
         return ListArtifactsResp.model_validate(data)
 
+    async def grep_artifacts(
+        self,
+        disk_id: str,
+        *,
+        query: str,
+        limit: int = 100,
+    ) -> list[Artifact]:
+        """Search artifact content using regex pattern.
+
+        Args:
+            disk_id: The disk ID to search in
+            query: Regex pattern to search for in file content
+            limit: Maximum number of results (default 100, max 1000)
+
+        Returns:
+            List of matching artifacts
+
+        Example:
+        ```python
+            # Search for TODO comments in code
+            results = await client.disks.artifacts.grep_artifacts(
+                disk_id="disk-uuid",
+                query="TODO.*bug"
+            )
+        ```
+        """
+        params = build_params(query=query, limit=limit)
+        data = await self._requester.request(
+            "GET", f"/disk/{disk_id}/artifact/grep", params=params
+        )
+        return [Artifact.model_validate(item) for item in data]
+
+    async def glob_artifacts(
+        self,
+        disk_id: str,
+        *,
+        query: str,
+        limit: int = 100,
+    ) -> list[Artifact]:
+        """Search artifact paths using glob pattern.
+
+        Args:
+            disk_id: The disk ID to search in
+            query: Glob pattern (e.g., '**/*.py', '*.txt')
+            limit: Maximum number of results (default 100, max 1000)
+
+        Returns:
+            List of matching artifacts
+
+        Example:
+        ```python
+            # Find all Python files
+            results = await client.disks.artifacts.glob_artifacts(
+                disk_id="disk-uuid",
+                query="**/*.py"
+            )
+        ```
+        """
+        params = build_params(query=query, limit=limit)
+        data = await self._requester.request(
+            "GET", f"/disk/{disk_id}/artifact/glob", params=params
+        )
+        return [Artifact.model_validate(item) for item in data]

{acontext-0.0.18 → acontext-0.1.0}/src/acontext/resources/async_sessions.py

@@ -78,6 +78,7 @@ class AsyncSessionsAPI:
         *,
         user: str | None = None,
         space_id: str | None = None,
+        disable_task_tracking: bool | None = None,
         configs: Mapping[str, Any] | None = None,
     ) -> Session:
         """Create a new session.
@@ -85,6 +86,7 @@ class AsyncSessionsAPI:
         Args:
             user: Optional user identifier string. Defaults to None.
             space_id: Optional space ID to associate with the session. Defaults to None.
+            disable_task_tracking: Whether to disable task tracking for this session. Defaults to None (server default: False).
             configs: Optional session configuration dictionary. Defaults to None.
 
         Returns:
@@ -95,6 +97,8 @@ class AsyncSessionsAPI:
             payload["user"] = user
         if space_id:
             payload["space_id"] = space_id
+        if disable_task_tracking is not None:
+            payload["disable_task_tracking"] = disable_task_tracking
         if configs is not None:
             payload["configs"] = configs
         data = await self._requester.request("POST", "/session", json_data=payload)
@@ -367,21 +371,22 @@ class AsyncSessionsAPI:
         )
         return TokenCounts.model_validate(data)
 
+    async def messages_observing_status(
+        self, session_id: str
+    ) -> MessageObservingStatus:
+        """Get message observing status counts for a session.
 
-async def messages_observing_status(self, session_id: str) -> MessageObservingStatus:
-    """Get message observing status counts for a session.
+        Returns the count of messages by their observing status:
+        observed, in_process, and pending.
 
-    Returns the count of messages by their observing status:
-    observed, in_process, and pending.
-
-    Args:
-        session_id: The UUID of the session.
+        Args:
+            session_id: The UUID of the session.
 
-    Returns:
-        MessageObservingStatus object containing observed, in_process,
-        pending counts and updated_at timestamp.
-    """
-    data = await self._requester.request(
-        "GET", f"/session/{session_id}/observing_status"
-    )
-    return MessageObservingStatus.model_validate(data)
+        Returns:
+            MessageObservingStatus object containing observed, in_process,
+            pending counts and updated_at timestamp.
+        """
+        data = await self._requester.request(
+            "GET", f"/session/{session_id}/observing_status"
+        )
+        return MessageObservingStatus.model_validate(data)