acontext 0.0.6__tar.gz → 0.0.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: acontext
-Version: 0.0.6
+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.6 → 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.6 → acontext-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acontext"
-version = "0.0.6"
+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.6 → acontext-0.0.7}/src/acontext/resources/async_spaces.py

@@ -3,7 +3,7 @@ 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
@@ -11,7 +11,6 @@ from ..types.space import (
     ExperienceConfirmation,
     ListExperienceConfirmationsOutput,
     ListSpacesOutput,
-    SearchResultBlockItem,
     Space,
     SpaceSearchResult,
 )
@@ -133,62 +132,6 @@ class AsyncSpacesAPI:
         )
         return SpaceSearchResult.model_validate(data)
 
-    async def semantic_glob(
-        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.
-
-        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).
-
-        Returns:
-            List of SearchResultBlockItem objects matching the query.
-        """
-        params = build_params(query=query, limit=limit, threshold=threshold)
-        data = await self._requester.request(
-            "GET", f"/space/{space_id}/semantic_glob", params=params or None
-        )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
-
-    async def semantic_grep(
-        self,
-        space_id: str,
-        *,
-        query: str,
-        limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic grep search for content blocks.
-
-        Searches through content blocks (actual text content) using semantic similarity,
-        similar to a semantic version of the grep command.
-
-        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).
-
-        Returns:
-            List of SearchResultBlockItem objects matching the query.
-        """
-        params = build_params(query=query, limit=limit, threshold=threshold)
-        data = await self._requester.request(
-            "GET", f"/space/{space_id}/semantic_grep", params=params or None
-        )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
-
     async def get_unconfirmed_experiences(
         self,
         space_id: str,

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

@@ -3,7 +3,7 @@ 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
@@ -11,7 +11,6 @@ from ..types.space import (
     ExperienceConfirmation,
     ListExperienceConfirmationsOutput,
     ListSpacesOutput,
-    SearchResultBlockItem,
     Space,
     SpaceSearchResult,
 )
@@ -131,62 +130,6 @@ class SpacesAPI:
         )
         return SpaceSearchResult.model_validate(data)
 
-    def semantic_glob(
-        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.
-
-        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).
-
-        Returns:
-            List of SearchResultBlockItem objects matching the query.
-        """
-        params = build_params(query=query, limit=limit, threshold=threshold)
-        data = self._requester.request(
-            "GET", f"/space/{space_id}/semantic_glob", params=params or None
-        )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
-
-    def semantic_grep(
-        self,
-        space_id: str,
-        *,
-        query: str,
-        limit: int | None = None,
-        threshold: float | None = None,
-    ) -> List[SearchResultBlockItem]:
-        """Perform semantic grep search for content blocks.
-
-        Searches through content blocks (actual text content) using semantic similarity,
-        similar to a semantic version of the grep command.
-
-        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).
-
-        Returns:
-            List of SearchResultBlockItem objects matching the query.
-        """
-        params = build_params(query=query, limit=limit, threshold=threshold)
-        data = self._requester.request(
-            "GET", f"/space/{space_id}/semantic_grep", params=params or None
-        )
-        return [SearchResultBlockItem.model_validate(item) for item in data]
-
     def get_unconfirmed_experiences(
         self,
         space_id: str,