@acontext/acontext 0.0.21 → 0.1.1

package/dist/client.d.ts

@@ -1,10 +1,9 @@
 /**
  * High-level synchronous client for the Acontext API.
  */
-import { BlocksAPI } from './resources/blocks';
 import { DisksAPI } from './resources/disks';
+import { SandboxesAPI } from './resources/sandboxes';
 import { SessionsAPI } from './resources/sessions';
-import { SpacesAPI } from './resources/spaces';
 import { ToolsAPI } from './resources/tools';
 import { SkillsAPI } from './resources/skills';
 import { UsersAPI } from './resources/users';
@@ -20,14 +19,13 @@ export declare class AcontextClient implements RequesterProtocol {
     private _apiKey;
     private _timeout;
     private _userAgent;
-    spaces: SpacesAPI;
     sessions: SessionsAPI;
     disks: DisksAPI;
     artifacts: DisksAPI['artifacts'];
-    blocks: BlocksAPI;
     tools: ToolsAPI;
     skills: SkillsAPI;
     users: UsersAPI;
+    sandboxes: SandboxesAPI;
     constructor(options?: AcontextClientOptions);
     get baseUrl(): string;
     /**
@@ -48,6 +46,7 @@ export declare class AcontextClient implements RequesterProtocol {
             contentType: string;
         }>;
         unwrap?: boolean;
+        timeout?: number;
     }): Promise<T>;
     private handleResponse;
     private getFetch;

package/dist/client.js

@@ -38,10 +38,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcontextClient = void 0;
 const errors_1 = require("./errors");
-const blocks_1 = require("./resources/blocks");
 const disks_1 = require("./resources/disks");
+const sandboxes_1 = require("./resources/sandboxes");
 const sessions_1 = require("./resources/sessions");
-const spaces_1 = require("./resources/spaces");
 const tools_1 = require("./resources/tools");
 const skills_1 = require("./resources/skills");
 const users_1 = require("./resources/users");
@@ -73,14 +72,13 @@ class AcontextClient {
                 (typeof process !== 'undefined' && process.env?.ACONTEXT_TIMEOUT
                     ? parseFloat(process.env.ACONTEXT_TIMEOUT)
                     : 320000);
-        this.spaces = new spaces_1.SpacesAPI(this);
         this.sessions = new sessions_1.SessionsAPI(this);
         this.disks = new disks_1.DisksAPI(this);
         this.artifacts = this.disks.artifacts;
-        this.blocks = new blocks_1.BlocksAPI(this);
         this.tools = new tools_1.ToolsAPI(this);
         this.skills = new skills_1.SkillsAPI(this);
         this.users = new users_1.UsersAPI(this);
+        this.sandboxes = new sandboxes_1.SandboxesAPI(this);
     }
     get baseUrl() {
         return this._baseUrl;
@@ -101,6 +99,8 @@ class AcontextClient {
     async request(method, path, options) {
         const unwrap = options?.unwrap !== false;
         const url = `${this._baseUrl}${path}`;
+        // Use per-request timeout if provided, otherwise use client default
+        const effectiveTimeout = options?.timeout ?? this._timeout;
         try {
             // Build headers
             const headers = {
@@ -186,7 +186,7 @@ class AcontextClient {
             // Make the request
             const fetchImpl = await this.getFetch();
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this._timeout);
+            const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
             try {
                 const response = await fetchImpl(finalUrl, {
                     method,
@@ -200,7 +200,7 @@ class AcontextClient {
             catch (error) {
                 clearTimeout(timeoutId);
                 if (error instanceof Error && error.name === 'AbortError') {
-                    throw new errors_1.TransportError(`Request timeout after ${this._timeout}ms`);
+                    throw new errors_1.TransportError(`Request timeout after ${effectiveTimeout}ms`);
                 }
                 throw error;
             }

package/dist/resources/disks.d.ts

@@ -54,4 +54,16 @@ export declare class DiskArtifactsAPI {
         query: string;
         limit?: number;
     }): Promise<Artifacts>;
+    downloadToSandbox(diskId: string, options: {
+        filePath: string;
+        filename: string;
+        sandboxId: string;
+        sandboxPath: string;
+    }): Promise<boolean>;
+    uploadFromSandbox(diskId: string, options: {
+        sandboxId: string;
+        sandboxPath: string;
+        sandboxFilename: string;
+        filePath: string;
+    }): Promise<Artifact>;
 }

package/dist/resources/disks.js

@@ -122,5 +122,29 @@ class DiskArtifactsAPI {
         });
         return types_1.ArtifactsSchema.parse(data);
     }
+    async downloadToSandbox(diskId, options) {
+        const payload = {
+            file_path: options.filePath,
+            filename: options.filename,
+            sandbox_id: options.sandboxId,
+            sandbox_path: options.sandboxPath,
+        };
+        const data = await this.requester.request('POST', `/disk/${diskId}/artifact/download_to_sandbox`, {
+            jsonData: payload,
+        });
+        return Boolean(data?.success);
+    }
+    async uploadFromSandbox(diskId, options) {
+        const payload = {
+            sandbox_id: options.sandboxId,
+            sandbox_path: options.sandboxPath,
+            sandbox_filename: options.sandboxFilename,
+            file_path: options.filePath,
+        };
+        const data = await this.requester.request('POST', `/disk/${diskId}/artifact/upload_from_sandbox`, {
+            jsonData: payload,
+        });
+        return types_1.ArtifactSchema.parse(data);
+    }
 }
 exports.DiskArtifactsAPI = DiskArtifactsAPI;

package/dist/resources/index.d.ts

@@ -1,10 +1,9 @@
 /**
  * Resource API exports
  */
-export * from './spaces';
 export * from './sessions';
 export * from './disks';
-export * from './blocks';
 export * from './tools';
 export * from './skills';
+export * from './sandboxes';
 export * from './users';

package/dist/resources/index.js

@@ -17,10 +17,9 @@ 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("./spaces"), exports);
 __exportStar(require("./sessions"), exports);
 __exportStar(require("./disks"), exports);
-__exportStar(require("./blocks"), exports);
 __exportStar(require("./tools"), exports);
 __exportStar(require("./skills"), exports);
+__exportStar(require("./sandboxes"), exports);
 __exportStar(require("./users"), exports);

package/dist/resources/sandboxes.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Sandboxes endpoints.
+ */
+import { RequesterProtocol } from '../client-types';
+import { FlagResponse, GetSandboxLogsOutput, SandboxCommandOutput, SandboxRuntimeInfo } from '../types';
+export declare class SandboxesAPI {
+    private requester;
+    constructor(requester: RequesterProtocol);
+    /**
+     * Create and start a new sandbox.
+     *
+     * @returns SandboxRuntimeInfo containing the sandbox ID, status, and timestamps
+     */
+    create(): Promise<SandboxRuntimeInfo>;
+    /**
+     * Execute a shell command in the sandbox.
+     *
+     * @param options - Command execution options
+     * @param options.sandboxId - The UUID of the sandbox
+     * @param options.command - The shell command to execute
+     * @param options.timeout - Optional timeout in milliseconds for this command.
+     *                          If not provided, uses the client's default timeout.
+     * @returns SandboxCommandOutput containing stdout, stderr, and exit code
+     */
+    execCommand(options: {
+        sandboxId: string;
+        command: string;
+        timeout?: number;
+    }): Promise<SandboxCommandOutput>;
+    /**
+     * Kill a running sandbox.
+     *
+     * @param sandboxId - The UUID of the sandbox to kill
+     * @returns FlagResponse with status and error message
+     */
+    kill(sandboxId: string): Promise<FlagResponse>;
+    /**
+     * Get sandbox logs for the project with cursor-based pagination.
+     *
+     * @param options - Optional parameters for retrieving logs
+     * @param options.limit - Maximum number of logs to return (default 20, max 200)
+     * @param options.cursor - Cursor for pagination. Use the cursor from the previous response to get the next page
+     * @param options.timeDesc - Order by created_at descending if true, ascending if false (default false)
+     * @returns GetSandboxLogsOutput containing the list of sandbox logs and pagination information
+     */
+    getLogs(options?: {
+        limit?: number | null;
+        cursor?: string | null;
+        timeDesc?: boolean | null;
+    }): Promise<GetSandboxLogsOutput>;
+}

package/dist/resources/sandboxes.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Sandboxes endpoints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxesAPI = void 0;
+const utils_1 = require("../utils");
+const types_1 = require("../types");
+class SandboxesAPI {
+    constructor(requester) {
+        this.requester = requester;
+    }
+    /**
+     * Create and start a new sandbox.
+     *
+     * @returns SandboxRuntimeInfo containing the sandbox ID, status, and timestamps
+     */
+    async create() {
+        const data = await this.requester.request('POST', '/sandbox');
+        return types_1.SandboxRuntimeInfoSchema.parse(data);
+    }
+    /**
+     * Execute a shell command in the sandbox.
+     *
+     * @param options - Command execution options
+     * @param options.sandboxId - The UUID of the sandbox
+     * @param options.command - The shell command to execute
+     * @param options.timeout - Optional timeout in milliseconds for this command.
+     *                          If not provided, uses the client's default timeout.
+     * @returns SandboxCommandOutput containing stdout, stderr, and exit code
+     */
+    async execCommand(options) {
+        const data = await this.requester.request('POST', `/sandbox/${options.sandboxId}/exec`, {
+            jsonData: { command: options.command },
+            timeout: options.timeout,
+        });
+        return types_1.SandboxCommandOutputSchema.parse(data);
+    }
+    /**
+     * Kill a running sandbox.
+     *
+     * @param sandboxId - The UUID of the sandbox to kill
+     * @returns FlagResponse with status and error message
+     */
+    async kill(sandboxId) {
+        const data = await this.requester.request('DELETE', `/sandbox/${sandboxId}`);
+        return types_1.FlagResponseSchema.parse(data);
+    }
+    /**
+     * Get sandbox logs for the project with cursor-based pagination.
+     *
+     * @param options - Optional parameters for retrieving logs
+     * @param options.limit - Maximum number of logs to return (default 20, max 200)
+     * @param options.cursor - Cursor for pagination. Use the cursor from the previous response to get the next page
+     * @param options.timeDesc - Order by created_at descending if true, ascending if false (default false)
+     * @returns GetSandboxLogsOutput containing the list of sandbox logs and pagination information
+     */
+    async getLogs(options) {
+        const params = (0, utils_1.buildParams)({
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            time_desc: options?.timeDesc ?? null,
+        });
+        const data = await this.requester.request('GET', '/sandbox/logs', {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.GetSandboxLogsOutputSchema.parse(data);
+    }
+}
+exports.SandboxesAPI = SandboxesAPI;

package/dist/resources/sessions.d.ts

@@ -4,22 +4,19 @@
 import { RequesterProtocol } from '../client-types';
 import { AcontextMessage } from '../messages';
 import { FileUpload } from '../uploads';
-import { EditStrategy, GetMessagesOutput, GetTasksOutput, LearningStatus, ListSessionsOutput, Message, MessageObservingStatus, Session, TokenCounts } from '../types';
+import { EditStrategy, GetMessagesOutput, GetTasksOutput, ListSessionsOutput, Message, MessageObservingStatus, Session, TokenCounts } from '../types';
 export type MessageBlob = AcontextMessage | Record<string, unknown>;
 export declare class SessionsAPI {
     private requester;
     constructor(requester: RequesterProtocol);
     list(options?: {
         user?: string | null;
-        spaceId?: string | null;
-        notConnected?: boolean | null;
         limit?: number | null;
         cursor?: string | null;
         timeDesc?: boolean | null;
     }): Promise<ListSessionsOutput>;
     create(options?: {
         user?: string | null;
-        spaceId?: string | null;
         disableTaskTracking?: boolean | null;
         configs?: Record<string, unknown>;
     }): Promise<Session>;
@@ -28,9 +25,6 @@ export declare class SessionsAPI {
         configs: Record<string, unknown>;
     }): Promise<void>;
     getConfigs(sessionId: string): Promise<Session>;
-    connectToSpace(sessionId: string, options: {
-        spaceId: string;
-    }): Promise<void>;
     getTasks(sessionId: string, options?: {
         limit?: number | null;
         cursor?: string | null;
@@ -87,16 +81,6 @@ export declare class SessionsAPI {
         status: number;
         errmsg: string;
     }>;
-    /**
-     * Get learning status for a session.
-     *
-     * Returns the count of space digested tasks and not space digested tasks.
-     * If the session is not connected to a space, returns 0 and 0.
-     *
-     * @param sessionId - The UUID of the session.
-     * @returns LearningStatus object containing space_digested_count and not_space_digested_count.
-     */
-    getLearningStatus(sessionId: string): Promise<LearningStatus>;
     /**
      * Get total token counts for all text and tool-call parts in a session.
      *

package/dist/resources/sessions.js

@@ -16,11 +16,7 @@ class SessionsAPI {
         if (options?.user) {
             params.user = options.user;
         }
-        if (options?.spaceId) {
-            params.space_id = options.spaceId;
-        }
         Object.assign(params, (0, utils_1.buildParams)({
-            not_connected: options?.notConnected ?? null,
             limit: options?.limit ?? null,
             cursor: options?.cursor ?? null,
             time_desc: options?.timeDesc ?? null,
@@ -35,9 +31,6 @@ class SessionsAPI {
         if (options?.user !== undefined && options?.user !== null) {
             payload.user = options.user;
         }
-        if (options?.spaceId) {
-            payload.space_id = options.spaceId;
-        }
         if (options?.disableTaskTracking !== undefined && options?.disableTaskTracking !== null) {
             payload.disable_task_tracking = options.disableTaskTracking;
         }
@@ -62,12 +55,6 @@ class SessionsAPI {
         const data = await this.requester.request('GET', `/session/${sessionId}/configs`);
         return types_1.SessionSchema.parse(data);
     }
-    async connectToSpace(sessionId, options) {
-        const payload = { space_id: options.spaceId };
-        await this.requester.request('POST', `/session/${sessionId}/connect_to_space`, {
-            jsonData: payload,
-        });
-    }
     async getTasks(sessionId, options) {
         const params = (0, utils_1.buildParams)({
             limit: options?.limit ?? null,
@@ -213,19 +200,6 @@ class SessionsAPI {
         const data = await this.requester.request('POST', `/session/${sessionId}/flush`);
         return data;
     }
-    /**
-     * Get learning status for a session.
-     *
-     * Returns the count of space digested tasks and not space digested tasks.
-     * If the session is not connected to a space, returns 0 and 0.
-     *
-     * @param sessionId - The UUID of the session.
-     * @returns LearningStatus object containing space_digested_count and not_space_digested_count.
-     */
-    async getLearningStatus(sessionId) {
-        const data = await this.requester.request('GET', `/session/${sessionId}/get_learning_status`);
-        return types_1.LearningStatusSchema.parse(data);
-    }
     /**
      * Get total token counts for all text and tool-call parts in a session.
      *

package/dist/resources/skills.d.ts

@@ -3,7 +3,7 @@
  */
 import { RequesterProtocol } from '../client-types';
 import { FileUpload } from '../uploads';
-import { GetSkillFileResp, ListSkillsOutput, Skill } from '../types';
+import { DownloadSkillToSandboxResp, GetSkillFileResp, ListSkillsOutput, Skill } from '../types';
 export declare class SkillsAPI {
     private requester;
     constructor(requester: RequesterProtocol);
@@ -54,4 +54,17 @@ export declare class SkillsAPI {
         filePath: string;
         expire?: number | null;
     }): Promise<GetSkillFileResp>;
+    /**
+     * Download all files from a skill to a sandbox environment.
+     *
+     * Files are placed at /skills/{skillName}/.
+     *
+     * @param skillId - The UUID of the skill to download
+     * @param options - Download options
+     * @param options.sandboxId - The UUID of the target sandbox
+     * @returns DownloadSkillToSandboxResp containing success status, directory path, skill name and description
+     */
+    downloadToSandbox(skillId: string, options: {
+        sandboxId: string;
+    }): Promise<DownloadSkillToSandboxResp>;
 }

package/dist/resources/skills.js

@@ -93,5 +93,22 @@ class SkillsAPI {
         });
         return types_1.GetSkillFileRespSchema.parse(data);
     }
+    /**
+     * Download all files from a skill to a sandbox environment.
+     *
+     * Files are placed at /skills/{skillName}/.
+     *
+     * @param skillId - The UUID of the skill to download
+     * @param options - Download options
+     * @param options.sandboxId - The UUID of the target sandbox
+     * @returns DownloadSkillToSandboxResp containing success status, directory path, skill name and description
+     */
+    async downloadToSandbox(skillId, options) {
+        const payload = {
+            sandbox_id: options.sandboxId,
+        };
+        const data = await this.requester.request('POST', `/agent_skills/${skillId}/download_to_sandbox`, { jsonData: payload });
+        return types_1.DownloadSkillToSandboxRespSchema.parse(data);
+    }
 }
 exports.SkillsAPI = SkillsAPI;

package/dist/resources/users.d.ts

@@ -24,11 +24,11 @@ export declare class UsersAPI {
      * Get resource counts for a user.
      *
      * @param identifier - The user identifier string
-     * @returns GetUserResourcesOutput containing counts for Spaces, Sessions, Disks, and Skills
+     * @returns GetUserResourcesOutput containing counts for Sessions, Disks, and Skills
      */
     getResources(identifier: string): Promise<GetUserResourcesOutput>;
     /**
-     * Delete a user and cascade delete all associated resources (Space, Session, Disk, Skill).
+     * Delete a user and cascade delete all associated resources (Session, Disk, Skill).
      *
      * @param identifier - The user identifier string
      */

package/dist/resources/users.js

@@ -34,14 +34,14 @@ class UsersAPI {
      * Get resource counts for a user.
      *
      * @param identifier - The user identifier string
-     * @returns GetUserResourcesOutput containing counts for Spaces, Sessions, Disks, and Skills
+     * @returns GetUserResourcesOutput containing counts for Sessions, Disks, and Skills
      */
     async getResources(identifier) {
         const data = await this.requester.request('GET', `/user/${encodeURIComponent(identifier)}/resources`);
         return types_1.GetUserResourcesOutputSchema.parse(data);
     }
     /**
-     * Delete a user and cascade delete all associated resources (Space, Session, Disk, Skill).
+     * Delete a user and cascade delete all associated resources (Session, Disk, Skill).
      *
      * @param identifier - The user identifier string
      */

package/dist/types/index.d.ts

@@ -2,10 +2,9 @@
  * Type exports
  */
 export * from './common';
-export * from './space';
 export * from './session';
 export * from './disk';
-export * from './block';
 export * from './tool';
 export * from './skill';
+export * from './sandbox';
 export * from './user';

package/dist/types/index.js

@@ -18,10 +18,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./common"), exports);
-__exportStar(require("./space"), exports);
 __exportStar(require("./session"), exports);
 __exportStar(require("./disk"), exports);
-__exportStar(require("./block"), exports);
 __exportStar(require("./tool"), exports);
 __exportStar(require("./skill"), exports);
+__exportStar(require("./sandbox"), exports);
 __exportStar(require("./user"), exports);

package/dist/types/sandbox.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Type definitions for sandbox resources.
+ */
+import { z } from 'zod';
+export declare const SandboxRuntimeInfoSchema: z.ZodObject<{
+    sandbox_id: z.ZodString;
+    sandbox_status: z.ZodString;
+    sandbox_created_at: z.ZodString;
+    sandbox_expires_at: z.ZodString;
+}, z.core.$strip>;
+export type SandboxRuntimeInfo = z.infer<typeof SandboxRuntimeInfoSchema>;
+export declare const SandboxCommandOutputSchema: z.ZodObject<{
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+    exit_code: z.ZodNumber;
+}, z.core.$strip>;
+export type SandboxCommandOutput = z.infer<typeof SandboxCommandOutputSchema>;
+export declare const HistoryCommandSchema: z.ZodObject<{
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+}, z.core.$strip>;
+export type HistoryCommand = z.infer<typeof HistoryCommandSchema>;
+export declare const GeneratedFileSchema: z.ZodObject<{
+    sandbox_path: z.ZodString;
+}, z.core.$strip>;
+export type GeneratedFile = z.infer<typeof GeneratedFileSchema>;
+export declare const SandboxLogSchema: z.ZodObject<{
+    id: z.ZodString;
+    project_id: z.ZodString;
+    backend_sandbox_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    backend_type: z.ZodString;
+    history_commands: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodNumber;
+    }, z.core.$strip>>;
+    generated_files: z.ZodArray<z.ZodObject<{
+        sandbox_path: z.ZodString;
+    }, z.core.$strip>>;
+    will_total_alive_seconds: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type SandboxLog = z.infer<typeof SandboxLogSchema>;
+export declare const GetSandboxLogsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        project_id: z.ZodString;
+        backend_sandbox_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        backend_type: z.ZodString;
+        history_commands: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            exit_code: z.ZodNumber;
+        }, z.core.$strip>>;
+        generated_files: z.ZodArray<z.ZodObject<{
+            sandbox_path: z.ZodString;
+        }, z.core.$strip>>;
+        will_total_alive_seconds: z.ZodNumber;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>>;
+    next_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    has_more: z.ZodBoolean;
+}, z.core.$strip>;
+export type GetSandboxLogsOutput = z.infer<typeof GetSandboxLogsOutputSchema>;

package/dist/types/sandbox.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Type definitions for sandbox resources.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSandboxLogsOutputSchema = exports.SandboxLogSchema = exports.GeneratedFileSchema = exports.HistoryCommandSchema = exports.SandboxCommandOutputSchema = exports.SandboxRuntimeInfoSchema = void 0;
+const zod_1 = require("zod");
+exports.SandboxRuntimeInfoSchema = zod_1.z.object({
+    sandbox_id: zod_1.z.string(),
+    sandbox_status: zod_1.z.string(),
+    sandbox_created_at: zod_1.z.string(),
+    sandbox_expires_at: zod_1.z.string(),
+});
+exports.SandboxCommandOutputSchema = zod_1.z.object({
+    stdout: zod_1.z.string(),
+    stderr: zod_1.z.string(),
+    exit_code: zod_1.z.number(),
+});
+exports.HistoryCommandSchema = zod_1.z.object({
+    command: zod_1.z.string(),
+    exit_code: zod_1.z.number(),
+});
+exports.GeneratedFileSchema = zod_1.z.object({
+    sandbox_path: zod_1.z.string(),
+});
+exports.SandboxLogSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    project_id: zod_1.z.string(),
+    backend_sandbox_id: zod_1.z.string().nullable().optional(),
+    backend_type: zod_1.z.string(),
+    history_commands: zod_1.z.array(exports.HistoryCommandSchema),
+    generated_files: zod_1.z.array(exports.GeneratedFileSchema),
+    will_total_alive_seconds: zod_1.z.number(),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string(),
+});
+exports.GetSandboxLogsOutputSchema = zod_1.z.object({
+    items: zod_1.z.array(exports.SandboxLogSchema),
+    next_cursor: zod_1.z.string().nullable().optional(),
+    has_more: zod_1.z.boolean(),
+});

package/dist/types/session.d.ts

@@ -57,7 +57,6 @@ export declare const SessionSchema: z.ZodObject<{
     project_id: z.ZodString;
     user_id: z.ZodOptional<z.ZodNullable<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;
     updated_at: z.ZodString;
@@ -72,7 +71,6 @@ export declare const TaskDataSchema: z.ZodObject<{
     task_description: z.ZodString;
     progresses: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     user_preferences: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    sop_thinking: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export type TaskData = z.infer<typeof TaskDataSchema>;
 export declare const TaskSchema: z.ZodObject<{
@@ -84,11 +82,9 @@ export declare const TaskSchema: z.ZodObject<{
         task_description: z.ZodString;
         progresses: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
         user_preferences: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-        sop_thinking: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;
     status: z.ZodString;
     is_planning: z.ZodBoolean;
-    space_digested: z.ZodBoolean;
     created_at: z.ZodString;
     updated_at: z.ZodString;
 }, z.core.$strip>;
@@ -99,7 +95,6 @@ export declare const ListSessionsOutputSchema: z.ZodObject<{
         project_id: z.ZodString;
         user_id: z.ZodOptional<z.ZodNullable<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;
         updated_at: z.ZodString;
@@ -136,11 +131,9 @@ export declare const GetTasksOutputSchema: z.ZodObject<{
             task_description: z.ZodString;
             progresses: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
             user_preferences: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-            sop_thinking: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>;
         status: z.ZodString;
         is_planning: z.ZodBoolean;
-        space_digested: z.ZodBoolean;
         created_at: z.ZodString;
         updated_at: z.ZodString;
     }, z.core.$strip>>;
@@ -148,11 +141,6 @@ export declare const GetTasksOutputSchema: z.ZodObject<{
     has_more: z.ZodBoolean;
 }, z.core.$strip>;
 export type GetTasksOutput = z.infer<typeof GetTasksOutputSchema>;
-export declare const LearningStatusSchema: z.ZodObject<{
-    space_digested_count: z.ZodNumber;
-    not_space_digested_count: z.ZodNumber;
-}, z.core.$strip>;
-export type LearningStatus = z.infer<typeof LearningStatusSchema>;
 export declare const TokenCountsSchema: z.ZodObject<{
     total_tokens: z.ZodNumber;
 }, z.core.$strip>;