@acontext/acontext 0.0.8 → 0.0.9

package/README.md

@@ -136,9 +136,134 @@ const result = await client.tools.renameToolName({
 console.log(result); // { status: 0, errmsg: '' }
 ```
 
+## 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:
+
+```typescript
+import { AcontextClient, DISK_TOOLS } from '@acontext/acontext';
+
+const client = new AcontextClient({ apiKey: 'sk-ac-your-root-api-bearer-token' });
+
+// Get OpenAI-compatible tool schemas
+const openaiTools = DISK_TOOLS.toOpenAIToolSchema();
+
+// Get Anthropic-compatible tool schemas
+const anthropicTools = DISK_TOOLS.toAnthropicToolSchema();
+
+// Use with OpenAI API
+import OpenAI from 'openai';
+const openai = new OpenAI({ apiKey: 'your-openai-key' });
+const completion = await openai.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Write a file called hello.txt with "Hello, World!"' }],
+  tools: openaiTools,
+});
+```
+
+### Executing Tools
+
+When an LLM calls a tool, execute it using the tool pool:
+
+```typescript
+import { AcontextClient, DISK_TOOLS } from '@acontext/acontext';
+
+const client = new AcontextClient({ apiKey: 'sk-ac-your-root-api-bearer-token' });
+
+// Create a disk for the tools to operate on
+const disk = await client.disks.create();
+
+// Create a context for the tools
+const ctx = DISK_TOOLS.formatContext(client, disk.id);
+
+// Execute a tool (e.g., after LLM returns a tool call)
+const result = await DISK_TOOLS.executeTool(ctx, 'write_file', {
+  filename: 'hello.txt',
+  file_path: '/notes/',
+  content: 'Hello, World!',
+});
+console.log(result); // File 'hello.txt' written successfully to '/notes/hello.txt'
+
+// Read the file
+const readResult = await DISK_TOOLS.executeTool(ctx, 'read_file', {
+  filename: 'hello.txt',
+  file_path: '/notes/',
+});
+console.log(readResult);
+
+// List files in a directory
+const listResult = await DISK_TOOLS.executeTool(ctx, 'list_artifacts', {
+  file_path: '/notes/',
+});
+console.log(listResult);
+
+// Replace a string in a file
+const replaceResult = await DISK_TOOLS.executeTool(ctx, 'replace_string', {
+  filename: 'hello.txt',
+  file_path: '/notes/',
+  old_string: 'Hello',
+  new_string: 'Hi',
+});
+console.log(replaceResult);
+```
+
+### Creating Custom Tools
+
+You can create custom tools by extending `AbstractBaseTool`:
+
+```typescript
+import { AbstractBaseTool, BaseContext, BaseToolPool } from '@acontext/acontext';
+
+interface MyContext extends BaseContext {
+  // Your context properties
+}
+
+class MyCustomTool extends AbstractBaseTool {
+  readonly name = 'my_custom_tool';
+  readonly description = 'A custom tool that does something';
+  readonly arguments = {
+    param1: {
+      type: 'string',
+      description: 'First parameter',
+    },
+  };
+  readonly requiredArguments = ['param1'];
+
+  async execute(ctx: MyContext, llmArguments: Record<string, unknown>): Promise<string> {
+    const param1 = llmArguments.param1 as string;
+    // Your custom logic here
+    return `Result: ${param1}`;
+  }
+}
+
+// Create a custom tool pool
+class MyToolPool extends BaseToolPool {
+  formatContext(...args: unknown[]): MyContext {
+    // Create and return your context
+    return {};
+  }
+}
+
+const myPool = new MyToolPool();
+myPool.addTool(new MyCustomTool());
+```
+
 ## 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)
 
@@ -175,41 +300,3 @@ if (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`):
-
-```typescript
-// Find pages about authentication
-const results = await client.spaces.semanticGlobal('space-uuid', {
-  query: 'authentication and authorization pages',
-  limit: 10,
-  threshold: 1.0, // Only show results with distance < 1.0
-});
-
-for (const block of results) {
-  console.log(`${block.title} - ${block.type}`);
-}
-```
-
-### 3. Semantic Grep (Search content blocks)
-
-Search through actual content blocks using semantic similarity (like a semantic version of `grep`):
-
-```typescript
-// Find code examples for JWT validation
-const results = await client.spaces.semanticGrep('space-uuid', {
-  query: 'JWT token validation code examples',
-  limit: 15,
-  threshold: 0.7,
-});
-
-for (const block of results) {
-  console.log(`${block.title} - distance: ${block.distance}`);
-  const content = block.props.text || block.props.content;
-  if (content) {
-    console.log(`Content: ${String(content).substring(0, 100)}...`);
-  }
-}
-```
-

package/dist/agent/base.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Base classes for agent tools.
+ */
+export interface BaseContext {
+}
+export interface BaseConverter {
+    toOpenAIToolSchema(): Record<string, unknown>;
+    toAnthropicToolSchema(): Record<string, unknown>;
+}
+export interface BaseTool extends BaseConverter {
+    readonly name: string;
+    readonly description: string;
+    readonly arguments: Record<string, unknown>;
+    readonly requiredArguments: string[];
+    execute(ctx: BaseContext, llmArguments: Record<string, unknown>): Promise<string>;
+}
+export declare abstract class AbstractBaseTool implements BaseTool {
+    abstract readonly name: string;
+    abstract readonly description: string;
+    abstract readonly arguments: Record<string, unknown>;
+    abstract readonly requiredArguments: string[];
+    abstract execute(ctx: BaseContext, llmArguments: Record<string, unknown>): Promise<string>;
+    toOpenAIToolSchema(): Record<string, unknown>;
+    toAnthropicToolSchema(): Record<string, unknown>;
+}
+export declare abstract class BaseToolPool {
+    protected tools: Map<string, BaseTool>;
+    addTool(tool: BaseTool): void;
+    removeTool(toolName: string): void;
+    extendToolPool(pool: BaseToolPool): void;
+    executeTool(ctx: BaseContext, toolName: string, llmArguments: Record<string, unknown>): Promise<string>;
+    toolExists(toolName: string): boolean;
+    toOpenAIToolSchema(): Record<string, unknown>[];
+    toAnthropicToolSchema(): Record<string, unknown>[];
+    abstract formatContext(...args: unknown[]): BaseContext;
+}

package/dist/agent/base.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Base classes for agent tools.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseToolPool = exports.AbstractBaseTool = void 0;
+class AbstractBaseTool {
+    toOpenAIToolSchema() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: {
+                    type: 'object',
+                    properties: this.arguments,
+                    required: this.requiredArguments,
+                },
+            },
+        };
+    }
+    toAnthropicToolSchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            input_schema: {
+                type: 'object',
+                properties: this.arguments,
+                required: this.requiredArguments,
+            },
+        };
+    }
+}
+exports.AbstractBaseTool = AbstractBaseTool;
+class BaseToolPool {
+    constructor() {
+        this.tools = new Map();
+    }
+    addTool(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    removeTool(toolName) {
+        this.tools.delete(toolName);
+    }
+    extendToolPool(pool) {
+        for (const [name, tool] of pool.tools.entries()) {
+            this.tools.set(name, tool);
+        }
+    }
+    async executeTool(ctx, toolName, llmArguments) {
+        const tool = this.tools.get(toolName);
+        if (!tool) {
+            throw new Error(`Tool '${toolName}' not found`);
+        }
+        const result = await tool.execute(ctx, llmArguments);
+        return result.trim();
+    }
+    toolExists(toolName) {
+        return this.tools.has(toolName);
+    }
+    toOpenAIToolSchema() {
+        return Array.from(this.tools.values()).map((tool) => tool.toOpenAIToolSchema());
+    }
+    toAnthropicToolSchema() {
+        return Array.from(this.tools.values()).map((tool) => tool.toAnthropicToolSchema());
+    }
+}
+exports.BaseToolPool = BaseToolPool;

package/dist/agent/disk.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Disk tools for agent operations.
+ */
+import { AcontextClient } from '../client';
+import { AbstractBaseTool, BaseContext, BaseToolPool } from './base';
+export interface DiskContext extends BaseContext {
+    client: AcontextClient;
+    diskId: string;
+}
+export declare class WriteFileTool extends AbstractBaseTool {
+    readonly name = "write_file";
+    readonly description = "Write text content to a file in the file system. Creates the file if it doesn't exist, overwrites if it does.";
+    readonly arguments: {
+        file_path: {
+            type: string;
+            description: string;
+        };
+        filename: {
+            type: string;
+            description: string;
+        };
+        content: {
+            type: string;
+            description: string;
+        };
+    };
+    readonly requiredArguments: string[];
+    execute(ctx: DiskContext, llmArguments: Record<string, unknown>): Promise<string>;
+}
+export declare class ReadFileTool extends AbstractBaseTool {
+    readonly name = "read_file";
+    readonly description = "Read a text file from the file system and return its content.";
+    readonly arguments: {
+        file_path: {
+            type: string;
+            description: string;
+        };
+        filename: {
+            type: string;
+            description: string;
+        };
+        line_offset: {
+            type: string;
+            description: string;
+        };
+        line_limit: {
+            type: string;
+            description: string;
+        };
+    };
+    readonly requiredArguments: string[];
+    execute(ctx: DiskContext, llmArguments: Record<string, unknown>): Promise<string>;
+}
+export declare class ReplaceStringTool extends AbstractBaseTool {
+    readonly name = "replace_string";
+    readonly description = "Replace an old string with a new string in a file. Reads the file, performs the replacement, and writes it back.";
+    readonly arguments: {
+        file_path: {
+            type: string;
+            description: string;
+        };
+        filename: {
+            type: string;
+            description: string;
+        };
+        old_string: {
+            type: string;
+            description: string;
+        };
+        new_string: {
+            type: string;
+            description: string;
+        };
+    };
+    readonly requiredArguments: string[];
+    execute(ctx: DiskContext, llmArguments: Record<string, unknown>): Promise<string>;
+}
+export declare class ListTool extends AbstractBaseTool {
+    readonly name = "list_artifacts";
+    readonly description = "List all files and directories in a specified path on the disk.";
+    readonly arguments: {
+        file_path: {
+            type: string;
+            description: string;
+        };
+    };
+    readonly requiredArguments: string[];
+    execute(ctx: DiskContext, llmArguments: Record<string, unknown>): Promise<string>;
+}
+export declare class DiskToolPool extends BaseToolPool {
+    formatContext(client: AcontextClient, diskId: string): DiskContext;
+}
+export declare const DISK_TOOLS: DiskToolPool;

package/dist/agent/disk.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Disk tools for agent operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISK_TOOLS = exports.DiskToolPool = exports.ListTool = exports.ReplaceStringTool = exports.ReadFileTool = exports.WriteFileTool = void 0;
+const uploads_1 = require("../uploads");
+const base_1 = require("./base");
+function normalizePath(path) {
+    if (!path) {
+        return '/';
+    }
+    let normalized = path.startsWith('/') ? path : `/${path}`;
+    if (!normalized.endsWith('/')) {
+        normalized += '/';
+    }
+    return normalized;
+}
+class WriteFileTool extends base_1.AbstractBaseTool {
+    constructor() {
+        super(...arguments);
+        this.name = 'write_file';
+        this.description = "Write text content to a file in the file system. Creates the file if it doesn't exist, overwrites if it does.";
+        this.arguments = {
+            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.',
+            },
+        };
+        this.requiredArguments = ['filename', 'content'];
+    }
+    async execute(ctx, llmArguments) {
+        const filename = llmArguments.filename;
+        const content = llmArguments.content;
+        const filePath = llmArguments.file_path || null;
+        if (!filename) {
+            throw new Error('filename is required');
+        }
+        if (!content) {
+            throw new Error('content is required');
+        }
+        const normalizedPath = normalizePath(filePath);
+        const payload = new uploads_1.FileUpload({
+            filename,
+            content: Buffer.from(content, 'utf-8'),
+            contentType: 'text/plain',
+        });
+        const artifact = await ctx.client.disks.artifacts.upsert(ctx.diskId, {
+            file: payload,
+            filePath: normalizedPath,
+        });
+        return `File '${artifact.filename}' written successfully to '${artifact.path}'`;
+    }
+}
+exports.WriteFileTool = WriteFileTool;
+class ReadFileTool extends base_1.AbstractBaseTool {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_file';
+        this.description = 'Read a text file from the file system and return its content.';
+        this.arguments = {
+            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: 'number',
+                description: 'The line number to start reading from. Default to 0',
+            },
+            line_limit: {
+                type: 'number',
+                description: 'The maximum number of lines to return. Default to 100',
+            },
+        };
+        this.requiredArguments = ['filename'];
+    }
+    async execute(ctx, llmArguments) {
+        const filename = llmArguments.filename;
+        const filePath = llmArguments.file_path || null;
+        const lineOffset = llmArguments.line_offset || 0;
+        const lineLimit = llmArguments.line_limit || 100;
+        if (!filename) {
+            throw new Error('filename is required');
+        }
+        const normalizedPath = normalizePath(filePath);
+        const result = await ctx.client.disks.artifacts.get(ctx.diskId, {
+            filePath: normalizedPath,
+            filename,
+            withContent: true,
+        });
+        if (!result.content) {
+            throw new Error('Failed to read file: server did not return content.');
+        }
+        const contentStr = result.content.raw;
+        const lines = contentStr.split('\n');
+        const lineStart = Math.min(lineOffset, Math.max(0, lines.length - 1));
+        const lineEnd = Math.min(lineStart + lineLimit, lines.length);
+        const preview = lines.slice(lineStart, lineEnd).join('\n');
+        return `[${normalizedPath}${filename} - showing L${lineStart}-${lineEnd} of ${lines.length} lines]\n${preview}`;
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+class ReplaceStringTool extends base_1.AbstractBaseTool {
+    constructor() {
+        super(...arguments);
+        this.name = 'replace_string';
+        this.description = 'Replace an old string with a new string in a file. Reads the file, performs the replacement, and writes it back.';
+        this.arguments = {
+            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.',
+            },
+        };
+        this.requiredArguments = ['filename', 'old_string', 'new_string'];
+    }
+    async execute(ctx, llmArguments) {
+        const filename = llmArguments.filename;
+        const filePath = llmArguments.file_path || null;
+        const oldString = llmArguments.old_string;
+        const newString = llmArguments.new_string;
+        if (!filename) {
+            throw new Error('filename is required');
+        }
+        if (oldString === null || oldString === undefined) {
+            throw new Error('old_string is required');
+        }
+        if (newString === null || newString === undefined) {
+            throw new Error('new_string is required');
+        }
+        const normalizedPath = normalizePath(filePath);
+        // Read the file content
+        const result = await ctx.client.disks.artifacts.get(ctx.diskId, {
+            filePath: normalizedPath,
+            filename,
+            withContent: true,
+        });
+        if (!result.content) {
+            throw new Error('Failed to read file: server did not return content.');
+        }
+        const contentStr = result.content.raw;
+        // Perform the replacement
+        if (!contentStr.includes(oldString)) {
+            return `String '${oldString}' not found in file '${filename}'`;
+        }
+        // Count occurrences before replacement
+        let replacementCount = 0;
+        let searchIndex = 0;
+        while (searchIndex < contentStr.length) {
+            const index = contentStr.indexOf(oldString, searchIndex);
+            if (index === -1) {
+                break;
+            }
+            replacementCount++;
+            searchIndex = index + oldString.length;
+        }
+        const updatedContent = contentStr.replace(oldString, newString);
+        // Write the updated content back
+        const payload = new uploads_1.FileUpload({
+            filename,
+            content: Buffer.from(updatedContent, 'utf-8'),
+            contentType: 'text/plain',
+        });
+        await ctx.client.disks.artifacts.upsert(ctx.diskId, {
+            file: payload,
+            filePath: normalizedPath,
+        });
+        return `Found ${replacementCount} old_string in ${normalizedPath}${filename} and replaced it.`;
+    }
+}
+exports.ReplaceStringTool = ReplaceStringTool;
+class ListTool extends base_1.AbstractBaseTool {
+    constructor() {
+        super(...arguments);
+        this.name = 'list_artifacts';
+        this.description = 'List all files and directories in a specified path on the disk.';
+        this.arguments = {
+            file_path: {
+                type: 'string',
+                description: "Optional directory path to list, e.g. '/todo/' or '/notes/'. Root is '/'",
+            },
+        };
+        this.requiredArguments = ['file_path'];
+    }
+    async execute(ctx, llmArguments) {
+        const filePath = llmArguments.file_path;
+        const normalizedPath = normalizePath(filePath);
+        const result = await ctx.client.disks.artifacts.list(ctx.diskId, {
+            path: normalizedPath,
+        });
+        const artifactsList = result.artifacts.map((artifact) => artifact.filename);
+        if (artifactsList.length === 0 && result.directories.length === 0) {
+            return `No files or directories found in '${normalizedPath}'`;
+        }
+        const outputParts = [];
+        if (artifactsList.length > 0) {
+            outputParts.push(`Files: ${artifactsList.join(', ')}`);
+        }
+        if (result.directories.length > 0) {
+            outputParts.push(`Directories: ${result.directories.join(', ')}`);
+        }
+        const lsSect = outputParts.join('\n');
+        return `[Listing in ${normalizedPath}]\n${lsSect}`;
+    }
+}
+exports.ListTool = ListTool;
+class DiskToolPool extends base_1.BaseToolPool {
+    formatContext(client, diskId) {
+        return {
+            client,
+            diskId,
+        };
+    }
+}
+exports.DiskToolPool = DiskToolPool;
+exports.DISK_TOOLS = new DiskToolPool();
+exports.DISK_TOOLS.addTool(new WriteFileTool());
+exports.DISK_TOOLS.addTool(new ReadFileTool());
+exports.DISK_TOOLS.addTool(new ReplaceStringTool());
+exports.DISK_TOOLS.addTool(new ListTool());

package/dist/agent/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent tools for Acontext SDK.
+ */
+export * from './base';
+export * from './disk';

package/dist/agent/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Agent tools for Acontext SDK.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./disk"), exports);

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export { MessagePart, AcontextMessage, buildAcontextMessage } from './messages';
 export { APIError, TransportError, AcontextError } from './errors';
 export * from './types';
 export * from './resources';
+export * from './agent';

package/dist/index.js

@@ -32,3 +32,4 @@ Object.defineProperty(exports, "TransportError", { enumerable: true, get: functi
 Object.defineProperty(exports, "AcontextError", { enumerable: true, get: function () { return errors_1.AcontextError; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./resources"), exports);
+__exportStar(require("./agent"), exports);

package/dist/resources/spaces.d.ts

@@ -2,7 +2,7 @@
  * Spaces endpoints.
  */
 import { RequesterProtocol } from '../client-types';
-import { ExperienceConfirmation, ListExperienceConfirmationsOutput, ListSpacesOutput, SearchResultBlockItem, Space, SpaceSearchResult } from '../types';
+import { ExperienceConfirmation, ListExperienceConfirmationsOutput, ListSpacesOutput, Space, SpaceSearchResult } from '../types';
 export declare class SpacesAPI {
     private requester;
     constructor(requester: RequesterProtocol);
@@ -37,36 +37,6 @@ export declare class SpacesAPI {
         semanticThreshold?: number | null;
         maxIterations?: number | null;
     }): Promise<SpaceSearchResult>;
-    /**
-     * 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.
-     *
-     * @param spaceId - The UUID of the space
-     * @param options - Search options
-     * @returns List of SearchResultBlockItem objects matching the query
-     */
-    semanticGlobal(spaceId: string, options: {
-        query: string;
-        limit?: number | null;
-        threshold?: number | null;
-    }): Promise<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.
-     *
-     * @param spaceId - The UUID of the space
-     * @param options - Search options
-     * @returns List of SearchResultBlockItem objects matching the query
-     */
-    semanticGrep(spaceId: string, options: {
-        query: string;
-        limit?: number | null;
-        threshold?: number | null;
-    }): Promise<SearchResultBlockItem[]>;
     /**
      * Get all unconfirmed experiences in a space with cursor-based pagination.
      *

package/dist/resources/spaces.js

@@ -66,44 +66,6 @@ class SpacesAPI {
         const data = await this.requester.request('GET', `/space/${spaceId}/experience_search`, { params: Object.keys(params).length > 0 ? params : undefined });
         return types_1.SpaceSearchResultSchema.parse(data);
     }
-    /**
-     * 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.
-     *
-     * @param spaceId - The UUID of the space
-     * @param options - Search options
-     * @returns List of SearchResultBlockItem objects matching the query
-     */
-    async semanticGlobal(spaceId, options) {
-        const params = (0, utils_1.buildParams)({
-            query: options.query,
-            limit: options.limit ?? null,
-            threshold: options.threshold ?? null,
-        });
-        const data = await this.requester.request('GET', `/space/${spaceId}/semantic_glob`, { params: Object.keys(params).length > 0 ? params : undefined });
-        return data.map((item) => types_1.SearchResultBlockItemSchema.parse(item));
-    }
-    /**
-     * 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.
-     *
-     * @param spaceId - The UUID of the space
-     * @param options - Search options
-     * @returns List of SearchResultBlockItem objects matching the query
-     */
-    async semanticGrep(spaceId, options) {
-        const params = (0, utils_1.buildParams)({
-            query: options.query,
-            limit: options.limit ?? null,
-            threshold: options.threshold ?? null,
-        });
-        const data = await this.requester.request('GET', `/space/${spaceId}/semantic_grep`, { params: Object.keys(params).length > 0 ? params : undefined });
-        return data.map((item) => types_1.SearchResultBlockItemSchema.parse(item));
-    }
     /**
      * Get all unconfirmed experiences in a space with cursor-based pagination.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acontext/acontext",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "TypeScript SDK for the Acontext API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",