acontext 0.0.5__tar.gz → 0.0.7__tar.gz

{acontext-0.0.5 → acontext-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: acontext
-Version: 0.0.5
+Version: 0.0.7
 Summary: Python SDK for the Acontext API
 Keywords: acontext,sdk,client,api
 Requires-Dist: httpx>=0.28.1
@@ -304,6 +304,144 @@ result = client.tools.rename_tool_name(
 print(result.status)  # 0 for success
 ```
 
+### Agent Tools
+
+The SDK provides agent tools that allow LLMs (OpenAI, Anthropic) to interact with Acontext disks through function calling. These tools can be converted to OpenAI or Anthropic tool schemas and executed when the LLM calls them.
+
+#### Pre-configured Disk Tools
+
+The SDK includes a pre-configured `DISK_TOOLS` pool with four disk operation tools:
+
+- **`write_file`**: Write text content to a file
+- **`read_file`**: Read a text file with optional line offset and limit
+- **`replace_string`**: Replace strings in a file
+- **`list_artifacts`**: List files and directories in a path
+
+#### Getting Tool Schemas for LLM APIs
+
+Convert tools to the appropriate format for your LLM provider:
+
+```python
+from acontext import AcontextClient
+from acontext.agent.disk import DISK_TOOLS
+
+client = AcontextClient(api_key="sk-ac-your-root-api-bearer-token")
+
+# Get OpenAI-compatible tool schemas
+openai_tools = DISK_TOOLS.to_openai_tool_schema()
+
+# Get Anthropic-compatible tool schemas
+anthropic_tools = DISK_TOOLS.to_anthropic_tool_schema()
+
+# Use with OpenAI API
+import openai
+openai_client = openai.OpenAI(api_key="your-openai-key")
+completion = openai_client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": 'Write a file called hello.txt with "Hello, World!"'}],
+    tools=openai_tools,
+)
+```
+
+#### Executing Tools
+
+When an LLM calls a tool, execute it using the tool pool:
+
+```python
+from acontext import AcontextClient
+from acontext.agent.disk import DISK_TOOLS
+
+client = AcontextClient(api_key="sk-ac-your-root-api-bearer-token")
+
+# Create a disk for the tools to operate on
+disk = client.disks.create()
+
+# Create a context for the tools
+ctx = DISK_TOOLS.format_context(client, disk.id)
+
+# Execute a tool (e.g., after LLM returns a tool call)
+result = DISK_TOOLS.execute_tool(
+    ctx,
+    "write_file",
+    {"filename": "hello.txt", "file_path": "/notes/", "content": "Hello, World!"}
+)
+print(result)  # File 'hello.txt' written successfully to '/notes/hello.txt'
+
+# Read the file
+read_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "read_file",
+    {"filename": "hello.txt", "file_path": "/notes/"}
+)
+print(read_result)
+
+# List files in a directory
+list_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "list_artifacts",
+    {"file_path": "/notes/"}
+)
+print(list_result)
+
+# Replace a string in a file
+replace_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "replace_string",
+    {
+        "filename": "hello.txt",
+        "file_path": "/notes/",
+        "old_string": "Hello",
+        "new_string": "Hi",
+    }
+)
+print(replace_result)
+```
+
+#### Creating Custom Tools
+
+You can create custom tools by extending `BaseTool`:
+
+```python
+from acontext.agent.base import BaseTool, BaseToolPool, BaseContext
+from typing import Dict, Any
+
+class MyCustomTool(BaseTool):
+    @property
+    def name(self) -> str:
+        return "my_custom_tool"
+    
+    @property
+    def description(self) -> str:
+        return "A custom tool that does something"
+    
+    @property
+    def arguments(self) -> dict:
+        return {
+            "param1": {
+                "type": "string",
+                "description": "First parameter",
+            }
+        }
+    
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["param1"]
+    
+    def execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
+        param1 = llm_arguments.get("param1")
+        # Your custom logic here
+        return f"Result: {param1}"
+
+# Create a custom tool pool
+class MyToolPool(BaseToolPool):
+    def format_context(self, *args, **kwargs) -> BaseContext:
+        # Create and return your context
+        return BaseContext()
+
+my_pool = MyToolPool()
+my_pool.add_tool(MyCustomTool())
+```
+
 ### Blocks API
 
 #### List blocks
@@ -484,7 +622,7 @@ for artifact in artifacts.items:
 
 ### Semantic search within spaces
 
-The SDK provides three powerful semantic search APIs for finding content within your spaces:
+The SDK provides a powerful semantic search API for finding content within your spaces:
 
 #### 1. Experience Search (Advanced AI-powered search)
 
@@ -520,39 +658,4 @@ if result.final_answer:
     print(f"AI Answer: {result.final_answer}")
 ```
 
-#### 2. Semantic Glob (Search page/folder titles)
-
-Search for pages and folders by their titles using semantic similarity (like a semantic version of `glob`):
-
-```python
-# Find pages about authentication
-results = client.spaces.semantic_glob(
-    space_id="space-uuid",
-    query="authentication and authorization pages",
-    limit=10,
-    threshold=1.0,  # Only show results with distance < 1.0
-)
-
-for block in results:
-    print(f"{block.title} - {block.type}")
-```
-
-#### 3. Semantic Grep (Search content blocks)
-
-Search through actual content blocks using semantic similarity (like a semantic version of `grep`):
-
-```python
-# Find code examples for JWT validation
-results = client.spaces.semantic_grep(
-    space_id="space-uuid",
-    query="JWT token validation code examples",
-    limit=15,
-    threshold=0.7,
-)
-
-for block in results:
-    print(f"{block.title} - distance: {block.distance}")
-    print(f"Content: {block.props.get('text', '')[:100]}...")
-```
-
 See `examples/search_usage.py` for more detailed examples including async usage.

{acontext-0.0.5 → acontext-0.0.7}/README.md

@@ -289,6 +289,144 @@ result = client.tools.rename_tool_name(
 print(result.status)  # 0 for success
 ```
 
+### Agent Tools
+
+The SDK provides agent tools that allow LLMs (OpenAI, Anthropic) to interact with Acontext disks through function calling. These tools can be converted to OpenAI or Anthropic tool schemas and executed when the LLM calls them.
+
+#### Pre-configured Disk Tools
+
+The SDK includes a pre-configured `DISK_TOOLS` pool with four disk operation tools:
+
+- **`write_file`**: Write text content to a file
+- **`read_file`**: Read a text file with optional line offset and limit
+- **`replace_string`**: Replace strings in a file
+- **`list_artifacts`**: List files and directories in a path
+
+#### Getting Tool Schemas for LLM APIs
+
+Convert tools to the appropriate format for your LLM provider:
+
+```python
+from acontext import AcontextClient
+from acontext.agent.disk import DISK_TOOLS
+
+client = AcontextClient(api_key="sk-ac-your-root-api-bearer-token")
+
+# Get OpenAI-compatible tool schemas
+openai_tools = DISK_TOOLS.to_openai_tool_schema()
+
+# Get Anthropic-compatible tool schemas
+anthropic_tools = DISK_TOOLS.to_anthropic_tool_schema()
+
+# Use with OpenAI API
+import openai
+openai_client = openai.OpenAI(api_key="your-openai-key")
+completion = openai_client.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": 'Write a file called hello.txt with "Hello, World!"'}],
+    tools=openai_tools,
+)
+```
+
+#### Executing Tools
+
+When an LLM calls a tool, execute it using the tool pool:
+
+```python
+from acontext import AcontextClient
+from acontext.agent.disk import DISK_TOOLS
+
+client = AcontextClient(api_key="sk-ac-your-root-api-bearer-token")
+
+# Create a disk for the tools to operate on
+disk = client.disks.create()
+
+# Create a context for the tools
+ctx = DISK_TOOLS.format_context(client, disk.id)
+
+# Execute a tool (e.g., after LLM returns a tool call)
+result = DISK_TOOLS.execute_tool(
+    ctx,
+    "write_file",
+    {"filename": "hello.txt", "file_path": "/notes/", "content": "Hello, World!"}
+)
+print(result)  # File 'hello.txt' written successfully to '/notes/hello.txt'
+
+# Read the file
+read_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "read_file",
+    {"filename": "hello.txt", "file_path": "/notes/"}
+)
+print(read_result)
+
+# List files in a directory
+list_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "list_artifacts",
+    {"file_path": "/notes/"}
+)
+print(list_result)
+
+# Replace a string in a file
+replace_result = DISK_TOOLS.execute_tool(
+    ctx,
+    "replace_string",
+    {
+        "filename": "hello.txt",
+        "file_path": "/notes/",
+        "old_string": "Hello",
+        "new_string": "Hi",
+    }
+)
+print(replace_result)
+```
+
+#### Creating Custom Tools
+
+You can create custom tools by extending `BaseTool`:
+
+```python
+from acontext.agent.base import BaseTool, BaseToolPool, BaseContext
+from typing import Dict, Any
+
+class MyCustomTool(BaseTool):
+    @property
+    def name(self) -> str:
+        return "my_custom_tool"
+    
+    @property
+    def description(self) -> str:
+        return "A custom tool that does something"
+    
+    @property
+    def arguments(self) -> dict:
+        return {
+            "param1": {
+                "type": "string",
+                "description": "First parameter",
+            }
+        }
+    
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["param1"]
+    
+    def execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
+        param1 = llm_arguments.get("param1")
+        # Your custom logic here
+        return f"Result: {param1}"
+
+# Create a custom tool pool
+class MyToolPool(BaseToolPool):
+    def format_context(self, *args, **kwargs) -> BaseContext:
+        # Create and return your context
+        return BaseContext()
+
+my_pool = MyToolPool()
+my_pool.add_tool(MyCustomTool())
+```
+
 ### Blocks API
 
 #### List blocks
@@ -469,7 +607,7 @@ for artifact in artifacts.items:
 
 ### Semantic search within spaces
 
-The SDK provides three powerful semantic search APIs for finding content within your spaces:
+The SDK provides a powerful semantic search API for finding content within your spaces:
 
 #### 1. Experience Search (Advanced AI-powered search)
 
@@ -505,39 +643,4 @@ if result.final_answer:
     print(f"AI Answer: {result.final_answer}")
 ```
 
-#### 2. Semantic Glob (Search page/folder titles)
-
-Search for pages and folders by their titles using semantic similarity (like a semantic version of `glob`):
-
-```python
-# Find pages about authentication
-results = client.spaces.semantic_glob(
-    space_id="space-uuid",
-    query="authentication and authorization pages",
-    limit=10,
-    threshold=1.0,  # Only show results with distance < 1.0
-)
-
-for block in results:
-    print(f"{block.title} - {block.type}")
-```
-
-#### 3. Semantic Grep (Search content blocks)
-
-Search through actual content blocks using semantic similarity (like a semantic version of `grep`):
-
-```python
-# Find code examples for JWT validation
-results = client.spaces.semantic_grep(
-    space_id="space-uuid",
-    query="JWT token validation code examples",
-    limit=15,
-    threshold=0.7,
-)
-
-for block in results:
-    print(f"{block.title} - distance: {block.distance}")
-    print(f"Content: {block.props.get('text', '')[:100]}...")
-```
-
 See `examples/search_usage.py` for more detailed examples including async usage.

{acontext-0.0.5 → acontext-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acontext"
-version = "0.0.5"
+version = "0.0.7"
 description = "Python SDK for the Acontext API"
 readme = "README.md"
 requires-python = ">=3.10"

acontext-0.0.7/src/acontext/agent/base.py

@@ -0,0 +1,89 @@
+class BaseContext:
+    pass
+
+
+class BaseConverter:
+    def to_openai_tool_schema(self) -> dict:
+        raise NotImplementedError
+
+    def to_anthropic_tool_schema(self) -> dict:
+        raise NotImplementedError
+
+
+class BaseTool(BaseConverter):
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def description(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def arguments(self) -> dict:
+        raise NotImplementedError
+
+    @property
+    def required_arguments(self) -> list[str]:
+        raise NotImplementedError
+
+    def execute(self, ctx: BaseContext, llm_arguments: dict) -> str:
+        raise NotImplementedError
+
+    def to_openai_tool_schema(self) -> dict:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": self.arguments,
+                    "required": self.required_arguments,
+                },
+            },
+        }
+
+    def to_anthropic_tool_schema(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": {
+                "type": "object",
+                "properties": self.arguments,
+                "required": self.required_arguments,
+            },
+        }
+
+
+class BaseToolPool(BaseConverter):
+    def __init__(self):
+        self.tools: dict[str, BaseTool] = {}
+
+    def add_tool(self, tool: BaseTool):
+        self.tools[tool.name] = tool
+
+    def remove_tool(self, tool_name: str):
+        self.tools.pop(tool_name)
+
+    def extent_tool_pool(self, pool: "BaseToolPool"):
+        self.tools.update(pool.tools)
+
+    def execute_tool(
+        self, ctx: BaseContext, tool_name: str, llm_arguments: dict
+    ) -> str:
+        tool = self.tools[tool_name]
+        r = tool.execute(ctx, llm_arguments)
+        return r.strip()
+
+    def tool_exists(self, tool_name: str) -> bool:
+        return tool_name in self.tools
+
+    def to_openai_tool_schema(self) -> list[dict]:
+        return [tool.to_openai_tool_schema() for tool in self.tools.values()]
+
+    def to_anthropic_tool_schema(self) -> list[dict]:
+        return [tool.to_anthropic_tool_schema() for tool in self.tools.values()]
+
+    def format_context(self, *args, **kwargs) -> BaseContext:
+        raise NotImplementedError

acontext-0.0.7/src/acontext/agent/disk.py

@@ -0,0 +1,325 @@
+from dataclasses import dataclass
+
+from .base import BaseContext, BaseTool, BaseToolPool
+from ..client import AcontextClient
+from ..uploads import FileUpload
+
+
+@dataclass
+class DiskContext(BaseContext):
+    client: AcontextClient
+    disk_id: str
+
+
+def _normalize_path(path: str | None) -> str:
+    """Normalize a file path to ensure it starts with '/'."""
+    if not path:
+        return "/"
+    normalized = path if path.startswith("/") else f"/{path}"
+    if not normalized.endswith("/"):
+        normalized += "/"
+    return normalized
+
+
+class WriteFileTool(BaseTool):
+    """Tool for writing text content to a file on the Acontext disk."""
+
+    @property
+    def name(self) -> str:
+        return "write_file"
+
+    @property
+    def description(self) -> str:
+        return "Write text content to a file in the file system. Creates the file if it doesn't exist, overwrites if it does."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional folder path to organize files, e.g. '/notes/' or '/documents/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename such as 'report.md' or 'demo.txt'.",
+            },
+            "content": {
+                "type": "string",
+                "description": "Text content to write to the file.",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename", "content"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Write text content to a file."""
+        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 = 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."""
+
+    @property
+    def name(self) -> str:
+        return "read_file"
+
+    @property
+    def description(self) -> str:
+        return "Read a text file from the file system and return its content."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path where the file is located, e.g. '/notes/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename to read.",
+            },
+            "line_offset": {
+                "type": "integer",
+                "description": "The line number to start reading from. Default to 0",
+            },
+            "line_limit": {
+                "type": "integer",
+                "description": "The maximum number of lines to return. Default to 100",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Read a text file and return its content preview."""
+        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 = 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."""
+
+    @property
+    def name(self) -> str:
+        return "replace_string"
+
+    @property
+    def description(self) -> str:
+        return "Replace an old string with a new string in a file. Reads the file, performs the replacement, and writes it back."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path where the file is located, e.g. '/notes/'. Defaults to root '/' if not specified.",
+            },
+            "filename": {
+                "type": "string",
+                "description": "Filename to modify.",
+            },
+            "old_string": {
+                "type": "string",
+                "description": "The string to be replaced.",
+            },
+            "new_string": {
+                "type": "string",
+                "description": "The string to replace the old_string with.",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["filename", "old_string", "new_string"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """Replace an old string with a new string in a file."""
+        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 = 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"))
+        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."""
+
+    @property
+    def name(self) -> str:
+        return "list_artifacts"
+
+    @property
+    def description(self) -> str:
+        return "List all files and directories in a specified path on the disk."
+
+    @property
+    def arguments(self) -> dict:
+        return {
+            "file_path": {
+                "type": "string",
+                "description": "Optional directory path to list, e.g. '/todo/' or '/notes/'. Root is '/'",
+            },
+        }
+
+    @property
+    def required_arguments(self) -> list[str]:
+        return ["file_path"]
+
+    def execute(self, ctx: DiskContext, llm_arguments: dict) -> str:
+        """List all files in a specified path."""
+        file_path = llm_arguments.get("file_path")
+        normalized_path = _normalize_path(file_path)
+
+        result = 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}'"
+
+        output_parts = []
+        if artifacts_list:
+            output_parts.append(f"Files: {', '.join(artifacts_list)}")
+        if result.directories:
+            output_parts.append(f"Directories: {', '.join(result.directories)}")
+
+        ls_sect = "\n".join(output_parts)
+        return f"""[Listing in {normalized_path}]
+{ls_sect}"""
+
+
+class DiskToolPool(BaseToolPool):
+    """Tool pool for disk operations on Acontext disks."""
+
+    def format_context(self, client: AcontextClient, disk_id: str) -> DiskContext:
+        return DiskContext(client=client, disk_id=disk_id)
+
+
+DISK_TOOLS = DiskToolPool()
+DISK_TOOLS.add_tool(WriteFileTool())
+DISK_TOOLS.add_tool(ReadFileTool())
+DISK_TOOLS.add_tool(ReplaceStringTool())
+DISK_TOOLS.add_tool(ListTool())
+
+
+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)

{acontext-0.0.5 → acontext-0.0.7}/src/acontext/resources/async_spaces.py

@@ -3,13 +3,14 @@ Spaces endpoints (async).
 """
 
 from collections.abc import Mapping
-from typing import Any, List
+from typing import Any
 
 from .._utils import build_params
 from ..client_types import AsyncRequesterProtocol
 from ..types.space import (
+    ExperienceConfirmation,
+    ListExperienceConfirmationsOutput,
     ListSpacesOutput,
-    SearchResultBlockItem,
     Space,
     SpaceSearchResult,
 )
@@ -131,58 +132,59 @@ class AsyncSpacesAPI:
         )
         return SpaceSearchResult.model_validate(data)
 
-    async def semantic_glob(
+    async def get_unconfirmed_experiences(
         self,
         space_id: str,
         *,
-        query: str,
         limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic glob (glob) search for page/folder titles.
-
-        Searches specifically for page/folder titles using semantic similarity,
-        similar to a semantic version of the glob command.
+        cursor: str | None = None,
+        time_desc: bool | None = None,
+    ) -> ListExperienceConfirmationsOutput:
+        """Get all unconfirmed experiences in a space with cursor-based pagination.
 
         Args:
             space_id: The UUID of the space.
-            query: Search query for page/folder titles.
-            limit: Maximum number of results to return (1-50, default 10).
-            threshold: Cosine distance threshold (0=identical, 2=opposite).
+            limit: Maximum number of confirmations to return (1-200, default 20).
+            cursor: Cursor for pagination. Use the cursor from the previous response to get the next page.
+            time_desc: Order by created_at descending if True, ascending if False (default False).
 
         Returns:
-            List of SearchResultBlockItem objects matching the query.
+            ListExperienceConfirmationsOutput containing the list of experience confirmations and pagination information.
         """
-        params = build_params(query=query, limit=limit, threshold=threshold)
+        params = build_params(limit=limit, cursor=cursor, time_desc=time_desc)
         data = await self._requester.request(
-            "GET", f"/space/{space_id}/semantic_glob", params=params or None
+            "GET",
+            f"/space/{space_id}/experience_confirmations",
+            params=params or None,
         )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
+        return ListExperienceConfirmationsOutput.model_validate(data)
 
-    async def semantic_grep(
+    async def confirm_experience(
         self,
         space_id: str,
+        experience_id: str,
         *,
-        query: str,
-        limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic grep search for content blocks.
+        save: bool,
+    ) -> ExperienceConfirmation | None:
+        """Confirm an experience confirmation.
 
-        Searches through content blocks (actual text content) using semantic similarity,
-        similar to a semantic version of the grep command.
+        If save is False, delete the row. If save is True, get the data first,
+        then delete the row.
 
         Args:
             space_id: The UUID of the space.
-            query: Search query for content blocks.
-            limit: Maximum number of results to return (1-50, default 10).
-            threshold: Cosine distance threshold (0=identical, 2=opposite).
+            experience_id: The UUID of the experience confirmation.
+            save: If True, get data before deleting. If False, just delete.
 
         Returns:
-            List of SearchResultBlockItem objects matching the query.
+            ExperienceConfirmation object if save is True, None otherwise.
         """
-        params = build_params(query=query, limit=limit, threshold=threshold)
+        payload = {"save": save}
         data = await self._requester.request(
-            "GET", f"/space/{space_id}/semantic_grep", params=params or None
+            "PATCH",
+            f"/space/{space_id}/experience_confirmations/{experience_id}",
+            json_data=payload,
         )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
+        if data is None:
+            return None
+        return ExperienceConfirmation.model_validate(data)

{acontext-0.0.5 → acontext-0.0.7}/src/acontext/resources/spaces.py

@@ -3,13 +3,14 @@ Spaces endpoints.
 """
 
 from collections.abc import Mapping
-from typing import Any, List
+from typing import Any
 
 from .._utils import build_params
 from ..client_types import RequesterProtocol
 from ..types.space import (
+    ExperienceConfirmation,
+    ListExperienceConfirmationsOutput,
     ListSpacesOutput,
-    SearchResultBlockItem,
     Space,
     SpaceSearchResult,
 )
@@ -129,58 +130,59 @@ class SpacesAPI:
         )
         return SpaceSearchResult.model_validate(data)
 
-    def semantic_glob(
+    def get_unconfirmed_experiences(
         self,
         space_id: str,
         *,
-        query: str,
         limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic glob (glob) search for page/folder titles.
-
-        Searches specifically for page/folder titles using semantic similarity,
-        similar to a semantic version of the glob command.
+        cursor: str | None = None,
+        time_desc: bool | None = None,
+    ) -> ListExperienceConfirmationsOutput:
+        """Get all unconfirmed experiences in a space with cursor-based pagination.
 
         Args:
             space_id: The UUID of the space.
-            query: Search query for page/folder titles.
-            limit: Maximum number of results to return (1-50, default 10).
-            threshold: Cosine distance threshold (0=identical, 2=opposite).
+            limit: Maximum number of confirmations to return (1-200, default 20).
+            cursor: Cursor for pagination. Use the cursor from the previous response to get the next page.
+            time_desc: Order by created_at descending if True, ascending if False (default False).
 
         Returns:
-            List of SearchResultBlockItem objects matching the query.
+            ListExperienceConfirmationsOutput containing the list of experience confirmations and pagination information.
         """
-        params = build_params(query=query, limit=limit, threshold=threshold)
+        params = build_params(limit=limit, cursor=cursor, time_desc=time_desc)
         data = self._requester.request(
-            "GET", f"/space/{space_id}/semantic_glob", params=params or None
+            "GET",
+            f"/space/{space_id}/experience_confirmations",
+            params=params or None,
         )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
+        return ListExperienceConfirmationsOutput.model_validate(data)
 
-    def semantic_grep(
+    def confirm_experience(
         self,
         space_id: str,
+        experience_id: str,
         *,
-        query: str,
-        limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic grep search for content blocks.
+        save: bool,
+    ) -> ExperienceConfirmation | None:
+        """Confirm an experience confirmation.
 
-        Searches through content blocks (actual text content) using semantic similarity,
-        similar to a semantic version of the grep command.
+        If save is False, delete the row. If save is True, get the data first,
+        then delete the row.
 
         Args:
             space_id: The UUID of the space.
-            query: Search query for content blocks.
-            limit: Maximum number of results to return (1-50, default 10).
-            threshold: Cosine distance threshold (0=identical, 2=opposite).
+            experience_id: The UUID of the experience confirmation.
+            save: If True, get data before deleting. If False, just delete.
 
         Returns:
-            List of SearchResultBlockItem objects matching the query.
+            ExperienceConfirmation object if save is True, None otherwise.
         """
-        params = build_params(query=query, limit=limit, threshold=threshold)
+        payload = {"save": save}
         data = self._requester.request(
-            "GET", f"/space/{space_id}/semantic_grep", params=params or None
+            "PATCH",
+            f"/space/{space_id}/experience_confirmations/{experience_id}",
+            json_data=payload,
         )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
+        if data is None:
+            return None
+        return ExperienceConfirmation.model_validate(data)

{acontext-0.0.5 → acontext-0.0.7}/src/acontext/types/__init__.py

@@ -24,6 +24,8 @@ from .session import (
 )
 from .block import Block
 from .space import (
+    ExperienceConfirmation,
+    ListExperienceConfirmationsOutput,
     ListSpacesOutput,
     SearchResultBlockItem,
     Space,
@@ -58,6 +60,8 @@ __all__ = [
     "Task",
     "TokenCounts",
     # Space types
+    "ExperienceConfirmation",
+    "ListExperienceConfirmationsOutput",
     "ListSpacesOutput",
     "SearchResultBlockItem",
     "Space",

{acontext-0.0.5 → acontext-0.0.7}/src/acontext/types/space.py

@@ -44,3 +44,26 @@ class SpaceSearchResult(BaseModel):
         ..., description="List of cited blocks"
     )
     final_answer: str | None = Field(None, description="AI-generated final answer")
+
+
+class ExperienceConfirmation(BaseModel):
+    """Experience confirmation model."""
+
+    id: str = Field(..., description="Experience confirmation UUID")
+    space_id: str = Field(..., description="Space UUID")
+    task_id: str | None = Field(None, description="Task UUID (optional)")
+    experience_data: dict[str, Any] = Field(
+        ..., description="Experience data dictionary"
+    )
+    created_at: str = Field(..., description="ISO 8601 formatted creation timestamp")
+    updated_at: str = Field(..., description="ISO 8601 formatted update timestamp")
+
+
+class ListExperienceConfirmationsOutput(BaseModel):
+    """Response model for listing experience confirmations."""
+
+    items: list[ExperienceConfirmation] = Field(
+        ..., description="List of experience confirmations"
+    )
+    next_cursor: str | None = Field(None, description="Cursor for pagination")
+    has_more: bool = Field(..., description="Whether there are more items")