@lobehub/market-sdk 0.23.7 → 0.23.8

package/dist/index.d.mts

@@ -1040,6 +1040,200 @@ interface PluginQueryParams {
     tags?: string;
 }
 
+/**
+ * Available tool names for Code Interpreter
+ * Note: Session management (createSession, destroySession, getSessionInfo) is handled
+ * internally by the server - sessions are automatically created when needed and
+ * recreated if expired.
+ */
+type CodeInterpreterToolName = 'editLocalFile' | 'executeCode' | 'exportFile' | 'getCommandOutput' | 'globLocalFiles' | 'grepContent' | 'killCommand' | 'listLocalFiles' | 'moveLocalFiles' | 'readLocalFile' | 'renameLocalFile' | 'runCommand' | 'searchLocalFiles' | 'writeLocalFile';
+/**
+ * Request for RunBuildInTools API
+ */
+interface RunBuildInToolsRequest {
+    /** Tool-specific parameters */
+    params: Record<string, any>;
+    /** Tool name to execute */
+    toolName: CodeInterpreterToolName;
+    /** Topic/conversation ID for session isolation */
+    topicId: string;
+    /** User ID for session isolation */
+    userId: string;
+}
+/**
+ * Success response data from RunBuildInTools
+ */
+interface RunBuildInToolsSuccessData {
+    /** Tool execution result */
+    result: any;
+    /** Indicates if the session was expired and recreated */
+    sessionExpiredAndRecreated: boolean;
+    /** Name of the executed tool */
+    toolName: string;
+}
+/**
+ * Error response data from RunBuildInTools
+ */
+interface RunBuildInToolsError {
+    /** Error code */
+    code: string;
+    /** Additional error details */
+    details?: any;
+    /** Human-readable error message */
+    message: string;
+}
+/**
+ * Response from RunBuildInTools API
+ */
+interface RunBuildInToolsResponse {
+    /** Success data (present when success=true) */
+    data?: RunBuildInToolsSuccessData;
+    /** Error data (present when success=false) */
+    error?: RunBuildInToolsError;
+    /** Whether the operation succeeded */
+    success: boolean;
+}
+/**
+ * Supported programming languages for code execution
+ */
+type ProgrammingLanguage = 'javascript' | 'python' | 'typescript';
+/** Parameters for executeCode tool */
+interface ExecuteCodeParams {
+    /** Code to execute */
+    code: string;
+    /** Programming language (default: python) */
+    language?: ProgrammingLanguage;
+}
+/** Parameters for runCommand tool */
+interface RunCommandParams {
+    /** Whether to run in background */
+    background?: boolean;
+    /** Command to execute */
+    command: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+/** Parameters for getCommandOutput tool */
+interface GetCommandOutputParams {
+    /** Background command ID */
+    commandId: string;
+}
+/** Parameters for killCommand tool */
+interface KillCommandParams {
+    /** Command ID to terminate */
+    commandId: string;
+}
+/** Parameters for readLocalFile tool */
+interface ReadLocalFileParams {
+    /** End line number (1-based, inclusive) */
+    endLine?: number;
+    /** File path to read */
+    path: string;
+    /** Start line number (1-based) */
+    startLine?: number;
+}
+/** Parameters for writeLocalFile tool */
+interface WriteLocalFileParams {
+    /** Content to write */
+    content: string;
+    /** Whether to create parent directories */
+    createDirectories?: boolean;
+    /** File path to write */
+    path: string;
+}
+/** Parameters for editLocalFile tool */
+interface EditLocalFileParams {
+    /** Replace all occurrences (default: false) */
+    all?: boolean;
+    /** File path to edit */
+    path: string;
+    /** String to replace with */
+    replace: string;
+    /** String to search for */
+    search: string;
+}
+/** Parameters for listLocalFiles tool */
+interface ListLocalFilesParams {
+    /** Directory path to list */
+    directoryPath: string;
+}
+/** Parameters for globLocalFiles tool */
+interface GlobLocalFilesParams {
+    /** Base directory (default: current directory) */
+    directory?: string;
+    /** Glob pattern (e.g., "**\/*.ts") */
+    pattern: string;
+}
+/** Parameters for searchLocalFiles tool */
+interface SearchLocalFilesParams {
+    /** Directory to search */
+    directory: string;
+    /** File type/extension filter */
+    fileType?: string;
+    /** Filename keyword filter */
+    keyword?: string;
+    /** Modified time upper bound (ISO date string) */
+    modifiedAfter?: string;
+    /** Modified time lower bound (ISO date string) */
+    modifiedBefore?: string;
+}
+/** Parameters for grepContent tool */
+interface GrepContentParams {
+    /** Directory to search */
+    directory: string;
+    /** File name pattern filter (e.g., "*.ts") */
+    filePattern?: string;
+    /** Regex pattern to search */
+    pattern: string;
+    /** Whether to search recursively (default: true) */
+    recursive?: boolean;
+}
+/** Move operation for moveLocalFiles tool */
+interface MoveOperation {
+    /** Destination path */
+    destination: string;
+    /** Source path */
+    source: string;
+}
+/** Parameters for moveLocalFiles tool */
+interface MoveLocalFilesParams {
+    /** Move operations to perform */
+    operations: MoveOperation[];
+}
+/** Parameters for renameLocalFile tool */
+interface RenameLocalFileParams {
+    /** New name (filename only, not full path) */
+    newName: string;
+    /** Original file/directory path */
+    oldPath: string;
+}
+/** Parameters for exportFile tool */
+interface ExportFileParams {
+    /** File path in sandbox to export */
+    path: string;
+    /** Pre-signed upload URL to upload the file to */
+    uploadUrl: string;
+}
+/**
+ * Map of tool names to their parameter types
+ */
+interface CodeInterpreterToolParams {
+    editLocalFile: EditLocalFileParams;
+    executeCode: ExecuteCodeParams;
+    exportFile: ExportFileParams;
+    getCommandOutput: GetCommandOutputParams;
+    globLocalFiles: GlobLocalFilesParams;
+    grepContent: GrepContentParams;
+    killCommand: KillCommandParams;
+    listLocalFiles: ListLocalFilesParams;
+    moveLocalFiles: MoveLocalFilesParams;
+    readLocalFile: ReadLocalFileParams;
+    renameLocalFile: RenameLocalFileParams;
+    runCommand: RunCommandParams;
+    searchLocalFiles: SearchLocalFilesParams;
+    writeLocalFile: WriteLocalFileParams;
+}
+
 /**
  * User-related type definitions for LobeHub Market SDK
  *
@@ -2569,6 +2763,153 @@ declare class PluginsService extends BaseSDK {
      * ```
      */
     callCloudGateway(request: CloudGatewayRequest, options?: globalThis.RequestInit): Promise<CloudGatewayResponse>;
+    /**
+     * Execute a built-in tool via AWS Bedrock AgentCore Code Interpreter
+     *
+     * This method provides access to file operations, command execution, and session management
+     * tools running in an isolated sandbox environment. Sessions are automatically managed
+     * per user/topic combination.
+     *
+     * @param toolName - Name of the tool to execute
+     * @param params - Tool-specific parameters
+     * @param context - User and topic context for session isolation
+     * @param options - Optional request options
+     * @returns Promise resolving to the tool execution result
+     *
+     * @example
+     * ```typescript
+     * // Run a shell command
+     * const result = await sdk.plugins.runBuildInTool(
+     *   'runCommand',
+     *   { command: 'ls -la' },
+     *   { userId: 'user-123', topicId: 'topic-456' }
+     * );
+     *
+     * // Read a file
+     * const fileResult = await sdk.plugins.runBuildInTool(
+     *   'readLocalFile',
+     *   { path: '/tmp/example.txt' },
+     *   { userId: 'user-123', topicId: 'topic-456' }
+     * );
+     * ```
+     */
+    runBuildInTool<T extends CodeInterpreterToolName>(toolName: T, params: CodeInterpreterToolParams[T], context: {
+        topicId: string;
+        userId: string;
+    }, options?: globalThis.RequestInit): Promise<RunBuildInToolsResponse>;
+    /**
+     * Execute a shell command in the Code Interpreter sandbox
+     *
+     * @param command - Shell command to execute
+     * @param context - User and topic context
+     * @param options - Additional options (background, timeout)
+     * @returns Promise resolving to command execution result
+     */
+    runCommand(command: string, context: {
+        topicId: string;
+        userId: string;
+    }, options?: {
+        background?: boolean;
+        timeout?: number;
+    }): Promise<RunBuildInToolsResponse>;
+    /**
+     * Read a file from the Code Interpreter sandbox
+     *
+     * @param path - File path to read
+     * @param context - User and topic context
+     * @param options - Line range options (startLine, endLine)
+     * @returns Promise resolving to file content
+     */
+    readFile(path: string, context: {
+        topicId: string;
+        userId: string;
+    }, options?: {
+        endLine?: number;
+        startLine?: number;
+    }): Promise<RunBuildInToolsResponse>;
+    /**
+     * Write content to a file in the Code Interpreter sandbox
+     *
+     * @param path - File path to write
+     * @param content - Content to write
+     * @param context - User and topic context
+     * @param options - Additional options (createDirectories)
+     * @returns Promise resolving to write result
+     */
+    writeFile(path: string, content: string, context: {
+        topicId: string;
+        userId: string;
+    }, options?: {
+        createDirectories?: boolean;
+    }): Promise<RunBuildInToolsResponse>;
+    /**
+     * List files in a directory in the Code Interpreter sandbox
+     *
+     * @param directoryPath - Directory path to list
+     * @param context - User and topic context
+     * @returns Promise resolving to directory listing
+     */
+    listFiles(directoryPath: string, context: {
+        topicId: string;
+        userId: string;
+    }): Promise<RunBuildInToolsResponse>;
+    /**
+     * Search for files matching a glob pattern
+     *
+     * @param pattern - Glob pattern (e.g., "**\/*.ts")
+     * @param context - User and topic context
+     * @param directory - Base directory (optional)
+     * @returns Promise resolving to matching files
+     */
+    globFiles(pattern: string, context: {
+        topicId: string;
+        userId: string;
+    }, directory?: string): Promise<RunBuildInToolsResponse>;
+    /**
+     * Search file contents using regex pattern
+     *
+     * @param pattern - Regex pattern to search
+     * @param directory - Directory to search
+     * @param context - User and topic context
+     * @param options - Additional options (filePattern, recursive)
+     * @returns Promise resolving to grep results
+     */
+    grepContent(pattern: string, directory: string, context: {
+        topicId: string;
+        userId: string;
+    }, options?: {
+        filePattern?: string;
+        recursive?: boolean;
+    }): Promise<RunBuildInToolsResponse>;
+    /**
+     * Export a file from the Code Interpreter sandbox to a pre-signed URL
+     *
+     * This method uploads a file from the sandbox to an external storage location
+     * via a pre-signed URL (e.g., S3 pre-signed URL). The upload is performed
+     * using Python code execution within the sandbox.
+     *
+     * @param path - File path in sandbox to export
+     * @param uploadUrl - Pre-signed URL to upload the file to
+     * @param context - User and topic context
+     * @returns Promise resolving to export result with success status and file info
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.plugins.exportFile(
+     *   './output/result.csv',
+     *   'https://s3.amazonaws.com/bucket/key?X-Amz-Signature=...',
+     *   { userId: 'user-123', topicId: 'topic-456' }
+     * );
+     *
+     * if (result.success && result.data?.result.success) {
+     *   console.log('File exported:', result.data.result.size, 'bytes');
+     * }
+     * ```
+     */
+    exportFile(path: string, uploadUrl: string, context: {
+        topicId: string;
+        userId: string;
+    }): Promise<RunBuildInToolsResponse>;
 }
 
 /**
@@ -2668,4 +3009,4 @@ declare class MarketSDK extends BaseSDK {
     registerClient(request: ClientRegistrationRequest): Promise<ClientRegistrationResponse>;
 }
 
-export { type AccountMeta, type AdminListQueryParams, type AdminListResponse, type AdminPluginParams, type AgentCreateRequest, type AgentCreateResponse, type AgentDetailQuery, type AgentExtension, type AgentInstallCountRequest, type AgentInstallCountResponse, type AgentInterface, type AgentItemDetail, type AgentListQuery, type AgentListResponse, type AgentModifyRequest, type AgentModifyResponse, type AgentSecurityRequirement, type AgentSecurityScheme, type AgentSkill, type AgentStatus, type AgentStatusChangeResponse, type AgentUploadRequest, type AgentUploadResponse, type AgentUploadVersion, type AgentVersionCreateRequest, type AgentVersionCreateResponse, type AgentVersionLocalization, type AgentVersionModifyRequest, type AgentVersionModifyResponse, type AuthorizationCodeTokenRequest, type ClientRegistrationError, type ClientRegistrationRequest, type ClientRegistrationResponse, type DiscoveryDocument, MarketAdmin, MarketSDK, type MarketSDKOptions, type OAuthTokenResponse, type OwnAgentListQuery, type PluginI18nImportParams, type PluginI18nImportResponse, type PluginItem, type PluginListResponse, type PluginLocalization, type PluginQueryParams, type PluginUpdateParams, type PluginVersionCreateParams, type PluginVersionUpdateParams, type RefreshTokenRequest, type ReviewStatus, ReviewStatusEnumSchema, type SharedTokenState, StatusEnumSchema, type UnclaimedPluginItem, type UpdateUserInfoRequest, type UpdateUserInfoResponse, type UserAgentItem, type UserInfoQuery, type UserInfoResponse, type UserProfile, VisibilityEnumSchema };
+export { type AccountMeta, type AdminListQueryParams, type AdminListResponse, type AdminPluginParams, type AgentCreateRequest, type AgentCreateResponse, type AgentDetailQuery, type AgentExtension, type AgentInstallCountRequest, type AgentInstallCountResponse, type AgentInterface, type AgentItemDetail, type AgentListQuery, type AgentListResponse, type AgentModifyRequest, type AgentModifyResponse, type AgentSecurityRequirement, type AgentSecurityScheme, type AgentSkill, type AgentStatus, type AgentStatusChangeResponse, type AgentUploadRequest, type AgentUploadResponse, type AgentUploadVersion, type AgentVersionCreateRequest, type AgentVersionCreateResponse, type AgentVersionLocalization, type AgentVersionModifyRequest, type AgentVersionModifyResponse, type AuthorizationCodeTokenRequest, type ClientRegistrationError, type ClientRegistrationRequest, type ClientRegistrationResponse, type CodeInterpreterToolName, type CodeInterpreterToolParams, type DiscoveryDocument, type EditLocalFileParams, type ExecuteCodeParams, type ExportFileParams, type GetCommandOutputParams, type GlobLocalFilesParams, type GrepContentParams, type KillCommandParams, type ListLocalFilesParams, MarketAdmin, MarketSDK, type MarketSDKOptions, type MoveLocalFilesParams, type MoveOperation, type OAuthTokenResponse, type OwnAgentListQuery, type PluginI18nImportParams, type PluginI18nImportResponse, type PluginItem, type PluginListResponse, type PluginLocalization, type PluginQueryParams, type PluginUpdateParams, type PluginVersionCreateParams, type PluginVersionUpdateParams, type ProgrammingLanguage, type ReadLocalFileParams, type RefreshTokenRequest, type RenameLocalFileParams, type ReviewStatus, ReviewStatusEnumSchema, type RunBuildInToolsError, type RunBuildInToolsRequest, type RunBuildInToolsResponse, type RunBuildInToolsSuccessData, type RunCommandParams, type SearchLocalFilesParams, type SharedTokenState, StatusEnumSchema, type UnclaimedPluginItem, type UpdateUserInfoRequest, type UpdateUserInfoResponse, type UserAgentItem, type UserInfoQuery, type UserInfoResponse, type UserProfile, VisibilityEnumSchema, type WriteLocalFileParams };

package/dist/index.mjs

@@ -2221,6 +2221,155 @@ var PluginsService = class extends BaseSDK {
     });
     return result;
   }
+  // ============================================================================
+  // Code Interpreter / RunBuildInTools Methods
+  // ============================================================================
+  /**
+   * Execute a built-in tool via AWS Bedrock AgentCore Code Interpreter
+   *
+   * This method provides access to file operations, command execution, and session management
+   * tools running in an isolated sandbox environment. Sessions are automatically managed
+   * per user/topic combination.
+   *
+   * @param toolName - Name of the tool to execute
+   * @param params - Tool-specific parameters
+   * @param context - User and topic context for session isolation
+   * @param options - Optional request options
+   * @returns Promise resolving to the tool execution result
+   *
+   * @example
+   * ```typescript
+   * // Run a shell command
+   * const result = await sdk.plugins.runBuildInTool(
+   *   'runCommand',
+   *   { command: 'ls -la' },
+   *   { userId: 'user-123', topicId: 'topic-456' }
+   * );
+   *
+   * // Read a file
+   * const fileResult = await sdk.plugins.runBuildInTool(
+   *   'readLocalFile',
+   *   { path: '/tmp/example.txt' },
+   *   { userId: 'user-123', topicId: 'topic-456' }
+   * );
+   * ```
+   */
+  async runBuildInTool(toolName, params, context, options) {
+    log12("Running built-in tool: %s for user %s, topic %s", toolName, context.userId, context.topicId);
+    const result = await this.request("/v1/plugins/run-buildin-tools", {
+      body: JSON.stringify({
+        params,
+        toolName,
+        topicId: context.topicId,
+        userId: context.userId
+      }),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      ...options
+    });
+    log12("Built-in tool execution completed: %O", {
+      success: result.success,
+      toolName
+    });
+    return result;
+  }
+  /**
+   * Execute a shell command in the Code Interpreter sandbox
+   *
+   * @param command - Shell command to execute
+   * @param context - User and topic context
+   * @param options - Additional options (background, timeout)
+   * @returns Promise resolving to command execution result
+   */
+  async runCommand(command, context, options) {
+    return this.runBuildInTool("runCommand", { command, ...options }, context);
+  }
+  /**
+   * Read a file from the Code Interpreter sandbox
+   *
+   * @param path - File path to read
+   * @param context - User and topic context
+   * @param options - Line range options (startLine, endLine)
+   * @returns Promise resolving to file content
+   */
+  async readFile(path, context, options) {
+    return this.runBuildInTool("readLocalFile", { path, ...options }, context);
+  }
+  /**
+   * Write content to a file in the Code Interpreter sandbox
+   *
+   * @param path - File path to write
+   * @param content - Content to write
+   * @param context - User and topic context
+   * @param options - Additional options (createDirectories)
+   * @returns Promise resolving to write result
+   */
+  async writeFile(path, content, context, options) {
+    return this.runBuildInTool("writeLocalFile", { content, path, ...options }, context);
+  }
+  /**
+   * List files in a directory in the Code Interpreter sandbox
+   *
+   * @param directoryPath - Directory path to list
+   * @param context - User and topic context
+   * @returns Promise resolving to directory listing
+   */
+  async listFiles(directoryPath, context) {
+    return this.runBuildInTool("listLocalFiles", { directoryPath }, context);
+  }
+  /**
+   * Search for files matching a glob pattern
+   *
+   * @param pattern - Glob pattern (e.g., "**\/*.ts")
+   * @param context - User and topic context
+   * @param directory - Base directory (optional)
+   * @returns Promise resolving to matching files
+   */
+  async globFiles(pattern, context, directory) {
+    return this.runBuildInTool("globLocalFiles", { directory, pattern }, context);
+  }
+  /**
+   * Search file contents using regex pattern
+   *
+   * @param pattern - Regex pattern to search
+   * @param directory - Directory to search
+   * @param context - User and topic context
+   * @param options - Additional options (filePattern, recursive)
+   * @returns Promise resolving to grep results
+   */
+  async grepContent(pattern, directory, context, options) {
+    return this.runBuildInTool("grepContent", { directory, pattern, ...options }, context);
+  }
+  /**
+   * Export a file from the Code Interpreter sandbox to a pre-signed URL
+   *
+   * This method uploads a file from the sandbox to an external storage location
+   * via a pre-signed URL (e.g., S3 pre-signed URL). The upload is performed
+   * using Python code execution within the sandbox.
+   *
+   * @param path - File path in sandbox to export
+   * @param uploadUrl - Pre-signed URL to upload the file to
+   * @param context - User and topic context
+   * @returns Promise resolving to export result with success status and file info
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.plugins.exportFile(
+   *   './output/result.csv',
+   *   'https://s3.amazonaws.com/bucket/key?X-Amz-Signature=...',
+   *   { userId: 'user-123', topicId: 'topic-456' }
+   * );
+   *
+   * if (result.success && result.data?.result.success) {
+   *   console.log('File exported:', result.data.result.size, 'bytes');
+   * }
+   * ```
+   */
+  async exportFile(path, uploadUrl, context) {
+    return this.runBuildInTool("exportFile", { path, uploadUrl }, context);
+  }
 };
 
 // src/market/services/UserService.ts