@acontext/acontext 0.0.8 → 0.0.10

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/messages.d.ts

@@ -27,7 +27,6 @@ export declare const AcontextMessageSchema: z.ZodObject<{
     role: z.ZodEnum<{
         user: "user";
         assistant: "assistant";
-        system: "system";
     }>;
     parts: z.ZodArray<z.ZodObject<{
         type: z.ZodString;
@@ -39,14 +38,14 @@ export declare const AcontextMessageSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AcontextMessageInput = z.infer<typeof AcontextMessageSchema>;
 export declare class AcontextMessage {
-    role: 'user' | 'assistant' | 'system';
+    role: 'user' | 'assistant';
     parts: MessagePart[];
     meta?: Record<string, unknown> | null;
     constructor(data: AcontextMessageInput);
     toJSON(): AcontextMessageInput;
 }
 export declare function buildAcontextMessage(options: {
-    role: 'user' | 'assistant' | 'system';
+    role: 'user' | 'assistant';
     parts: (MessagePart | string | MessagePartInput)[];
     meta?: Record<string, unknown> | null;
 }): AcontextMessage;

package/dist/messages.js

@@ -44,7 +44,7 @@ class MessagePart {
 }
 exports.MessagePart = MessagePart;
 exports.AcontextMessageSchema = zod_1.z.object({
-    role: zod_1.z.enum(['user', 'assistant', 'system']),
+    role: zod_1.z.enum(['user', 'assistant']),
     parts: zod_1.z.array(exports.MessagePartSchema),
     meta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional(),
 });
@@ -64,8 +64,8 @@ class AcontextMessage {
 }
 exports.AcontextMessage = AcontextMessage;
 function buildAcontextMessage(options) {
-    if (!['user', 'assistant', 'system'].includes(options.role)) {
-        throw new Error("role must be one of {'user', 'assistant', 'system'}");
+    if (!['user', 'assistant'].includes(options.role)) {
+        throw new Error("role must be one of {'user', 'assistant'}");
     }
     const normalizedParts = options.parts.map((part) => {
         if (part instanceof MessagePart) {

package/dist/resources/sessions.d.ts

@@ -4,7 +4,7 @@
 import { RequesterProtocol } from '../client-types';
 import { AcontextMessage } from '../messages';
 import { FileUpload } from '../uploads';
-import { GetMessagesOutput, GetTasksOutput, LearningStatus, ListSessionsOutput, Message, Session, TokenCounts } from '../types';
+import { EditStrategy, GetMessagesOutput, GetTasksOutput, LearningStatus, ListSessionsOutput, Message, Session, TokenCounts } from '../types';
 export type MessageBlob = AcontextMessage | Record<string, unknown>;
 export declare class SessionsAPI {
     private requester;
@@ -18,6 +18,7 @@ export declare class SessionsAPI {
     }): Promise<ListSessionsOutput>;
     create(options?: {
         spaceId?: string | null;
+        disableTaskTracking?: boolean | null;
         configs?: Record<string, unknown>;
     }): Promise<Session>;
     delete(sessionId: string): Promise<void>;
@@ -38,12 +39,29 @@ export declare class SessionsAPI {
         fileField?: string | null;
         file?: FileUpload | null;
     }): Promise<Message>;
+    /**
+     * Get messages for a session.
+     *
+     * @param sessionId - The UUID of the session.
+     * @param options - Options for retrieving messages.
+     * @param options.limit - Maximum number of messages to return.
+     * @param options.cursor - Cursor for pagination.
+     * @param options.withAssetPublicUrl - Whether to include presigned URLs for assets.
+     * @param options.format - The format of the messages ('acontext', 'openai', or 'anthropic').
+     * @param options.timeDesc - Order by created_at descending if true, ascending if false.
+     * @param options.editStrategies - Optional list of edit strategies to apply before format conversion.
+     *   Examples:
+     *   - Remove tool results: [{ type: 'remove_tool_result', params: { keep_recent_n_tool_results: 3 } }]
+     *   - Token limit: [{ type: 'token_limit', params: { limit_tokens: 20000 } }]
+     * @returns GetMessagesOutput containing the list of messages and pagination information.
+     */
     getMessages(sessionId: string, options?: {
         limit?: number | null;
         cursor?: string | null;
         withAssetPublicUrl?: boolean | null;
         format?: 'acontext' | 'openai' | 'anthropic';
         timeDesc?: boolean | null;
+        editStrategies?: Array<EditStrategy> | null;
     }): Promise<GetMessagesOutput>;
     flush(sessionId: string): Promise<{
         status: number;

package/dist/resources/sessions.js

@@ -32,6 +32,9 @@ class SessionsAPI {
         if (options?.spaceId) {
             payload.space_id = options.spaceId;
         }
+        if (options?.disableTaskTracking !== undefined && options?.disableTaskTracking !== null) {
+            payload.disable_task_tracking = options.disableTaskTracking;
+        }
         if (options?.configs !== undefined) {
             payload.configs = options.configs;
         }
@@ -115,6 +118,22 @@ class SessionsAPI {
             return types_1.MessageSchema.parse(data);
         }
     }
+    /**
+     * Get messages for a session.
+     *
+     * @param sessionId - The UUID of the session.
+     * @param options - Options for retrieving messages.
+     * @param options.limit - Maximum number of messages to return.
+     * @param options.cursor - Cursor for pagination.
+     * @param options.withAssetPublicUrl - Whether to include presigned URLs for assets.
+     * @param options.format - The format of the messages ('acontext', 'openai', or 'anthropic').
+     * @param options.timeDesc - Order by created_at descending if true, ascending if false.
+     * @param options.editStrategies - Optional list of edit strategies to apply before format conversion.
+     *   Examples:
+     *   - Remove tool results: [{ type: 'remove_tool_result', params: { keep_recent_n_tool_results: 3 } }]
+     *   - Token limit: [{ type: 'token_limit', params: { limit_tokens: 20000 } }]
+     * @returns GetMessagesOutput containing the list of messages and pagination information.
+     */
     async getMessages(sessionId, options) {
         const params = {};
         if (options?.format !== undefined) {
@@ -126,6 +145,9 @@ class SessionsAPI {
             with_asset_public_url: options?.withAssetPublicUrl ?? null,
             time_desc: options?.timeDesc ?? true, // Default to true
         }));
+        if (options?.editStrategies !== undefined && options?.editStrategies !== null) {
+            params.edit_strategies = JSON.stringify(options.editStrategies);
+        }
         const data = await this.requester.request('GET', `/session/${sessionId}/messages`, {
             params: Object.keys(params).length > 0 ? params : undefined,
         });

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.
      *
@@ -133,7 +95,7 @@ class SpacesAPI {
      */
     async confirmExperience(spaceId, experienceId, options) {
         const payload = { save: options.save };
-        const data = await this.requester.request('PATCH', `/space/${spaceId}/experience_confirmations/${experienceId}`, { jsonData: payload });
+        const data = await this.requester.request('PUT', `/space/${spaceId}/experience_confirmations/${experienceId}`, { jsonData: payload });
         if (data === null || data === undefined) {
             return null;
         }

package/dist/types/session.d.ts

@@ -55,6 +55,7 @@ export type Message = z.infer<typeof MessageSchema>;
 export declare const SessionSchema: z.ZodObject<{
     id: z.ZodString;
     project_id: z.ZodString;
+    disable_task_tracking: z.ZodBoolean;
     space_id: z.ZodNullable<z.ZodString>;
     configs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     created_at: z.ZodString;
@@ -78,6 +79,7 @@ export declare const ListSessionsOutputSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         project_id: z.ZodString;
+        disable_task_tracking: z.ZodBoolean;
         space_id: z.ZodNullable<z.ZodString>;
         configs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         created_at: z.ZodString;
@@ -128,3 +130,64 @@ export declare const TokenCountsSchema: z.ZodObject<{
     total_tokens: z.ZodNumber;
 }, z.core.$strip>;
 export type TokenCounts = z.infer<typeof TokenCountsSchema>;
+/**
+ * Parameters for the remove_tool_result edit strategy.
+ */
+export declare const RemoveToolResultParamsSchema: z.ZodObject<{
+    keep_recent_n_tool_results: z.ZodOptional<z.ZodNumber>;
+    tool_result_placeholder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RemoveToolResultParams = z.infer<typeof RemoveToolResultParamsSchema>;
+/**
+ * Edit strategy to replace old tool results with placeholder text.
+ *
+ * Example: { type: 'remove_tool_result', params: { keep_recent_n_tool_results: 5, tool_result_placeholder: 'Cleared' } }
+ */
+export declare const RemoveToolResultStrategySchema: z.ZodObject<{
+    type: z.ZodLiteral<"remove_tool_result">;
+    params: z.ZodObject<{
+        keep_recent_n_tool_results: z.ZodOptional<z.ZodNumber>;
+        tool_result_placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RemoveToolResultStrategy = z.infer<typeof RemoveToolResultStrategySchema>;
+/**
+ * Parameters for the token_limit edit strategy.
+ */
+export declare const TokenLimitParamsSchema: z.ZodObject<{
+    limit_tokens: z.ZodNumber;
+}, z.core.$strip>;
+export type TokenLimitParams = z.infer<typeof TokenLimitParamsSchema>;
+/**
+ * Edit strategy to truncate messages based on token count.
+ *
+ * Removes oldest messages until the total token count is within the specified limit.
+ * Maintains tool-call/tool-result pairing - when removing a message with tool-calls,
+ * the corresponding tool-result messages are also removed.
+ *
+ * Example: { type: 'token_limit', params: { limit_tokens: 20000 } }
+ */
+export declare const TokenLimitStrategySchema: z.ZodObject<{
+    type: z.ZodLiteral<"token_limit">;
+    params: z.ZodObject<{
+        limit_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TokenLimitStrategy = z.infer<typeof TokenLimitStrategySchema>;
+/**
+ * Union schema for all edit strategies.
+ * When adding new strategies, extend this union: z.union([RemoveToolResultStrategySchema, OtherStrategySchema, ...])
+ */
+export declare const EditStrategySchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"remove_tool_result">;
+    params: z.ZodObject<{
+        keep_recent_n_tool_results: z.ZodOptional<z.ZodNumber>;
+        tool_result_placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"token_limit">;
+    params: z.ZodObject<{
+        limit_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export type EditStrategy = z.infer<typeof EditStrategySchema>;

package/dist/types/session.js

@@ -3,7 +3,7 @@
  * Type definitions for session, message, and task resources.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenCountsSchema = exports.LearningStatusSchema = exports.GetTasksOutputSchema = exports.GetMessagesOutputSchema = exports.PublicURLSchema = exports.ListSessionsOutputSchema = exports.TaskSchema = exports.SessionSchema = exports.MessageSchema = exports.PartSchema = exports.AssetSchema = void 0;
+exports.EditStrategySchema = exports.TokenLimitStrategySchema = exports.TokenLimitParamsSchema = exports.RemoveToolResultStrategySchema = exports.RemoveToolResultParamsSchema = exports.TokenCountsSchema = exports.LearningStatusSchema = exports.GetTasksOutputSchema = exports.GetMessagesOutputSchema = exports.PublicURLSchema = exports.ListSessionsOutputSchema = exports.TaskSchema = exports.SessionSchema = exports.MessageSchema = exports.PartSchema = exports.AssetSchema = void 0;
 const zod_1 = require("zod");
 exports.AssetSchema = zod_1.z.object({
     bucket: zod_1.z.string(),
@@ -35,6 +35,7 @@ exports.MessageSchema = zod_1.z.object({
 exports.SessionSchema = zod_1.z.object({
     id: zod_1.z.string(),
     project_id: zod_1.z.string(),
+    disable_task_tracking: zod_1.z.boolean(),
     space_id: zod_1.z.string().nullable(),
     configs: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable(),
     created_at: zod_1.z.string(),
@@ -79,3 +80,59 @@ exports.LearningStatusSchema = zod_1.z.object({
 exports.TokenCountsSchema = zod_1.z.object({
     total_tokens: zod_1.z.number(),
 });
+/**
+ * Parameters for the remove_tool_result edit strategy.
+ */
+exports.RemoveToolResultParamsSchema = zod_1.z.object({
+    /**
+     * Number of most recent tool results to keep with original content.
+     * @default 3
+     */
+    keep_recent_n_tool_results: zod_1.z.number().optional(),
+    /**
+     * Custom text to replace old tool results with.
+     * @default "Done"
+     */
+    tool_result_placeholder: zod_1.z.string().optional(),
+});
+/**
+ * Edit strategy to replace old tool results with placeholder text.
+ *
+ * Example: { type: 'remove_tool_result', params: { keep_recent_n_tool_results: 5, tool_result_placeholder: 'Cleared' } }
+ */
+exports.RemoveToolResultStrategySchema = zod_1.z.object({
+    type: zod_1.z.literal('remove_tool_result'),
+    params: exports.RemoveToolResultParamsSchema,
+});
+/**
+ * Parameters for the token_limit edit strategy.
+ */
+exports.TokenLimitParamsSchema = zod_1.z.object({
+    /**
+     * Maximum number of tokens to keep. Required parameter.
+     * Messages will be removed from oldest to newest until total tokens <= limit_tokens.
+     * Tool-call and tool-result pairs are always removed together.
+     */
+    limit_tokens: zod_1.z.number(),
+});
+/**
+ * Edit strategy to truncate messages based on token count.
+ *
+ * Removes oldest messages until the total token count is within the specified limit.
+ * Maintains tool-call/tool-result pairing - when removing a message with tool-calls,
+ * the corresponding tool-result messages are also removed.
+ *
+ * Example: { type: 'token_limit', params: { limit_tokens: 20000 } }
+ */
+exports.TokenLimitStrategySchema = zod_1.z.object({
+    type: zod_1.z.literal('token_limit'),
+    params: exports.TokenLimitParamsSchema,
+});
+/**
+ * Union schema for all edit strategies.
+ * When adding new strategies, extend this union: z.union([RemoveToolResultStrategySchema, OtherStrategySchema, ...])
+ */
+exports.EditStrategySchema = zod_1.z.union([
+    exports.RemoveToolResultStrategySchema,
+    exports.TokenLimitStrategySchema,
+]);

package/package.json

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