@lobehub/market-sdk 0.23.7 → 0.23.9-beta.1

package/dist/index.mjs

@@ -1380,7 +1380,7 @@ var MarketAdmin = class extends BaseSDK {
 };
 
 // src/market/market-sdk.ts
-import debug14 from "debug";
+import debug17 from "debug";
 
 // src/market/services/AgentService.ts
 import debug9 from "debug";
@@ -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
@@ -2276,8 +2425,515 @@ var UserService = class extends BaseSDK {
   }
 };
 
+// src/market/services/UserFollowService.ts
+import debug14 from "debug";
+var log14 = debug14("lobe-market-sdk:user-follow");
+var UserFollowService = class extends BaseSDK {
+  /**
+   * Follow a user
+   *
+   * Creates a follow relationship where the authenticated user follows the target user.
+   * Requires authentication.
+   *
+   * @param followingId - The ID of the user to follow
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if already following or cannot follow yourself
+   */
+  async follow(followingId, options) {
+    log14("Following user: %d", followingId);
+    const body = { followingId };
+    const result = await this.request("/v1/user/follows", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      ...options
+    });
+    log14("Successfully followed user: %d", followingId);
+    return result;
+  }
+  /**
+   * Unfollow a user
+   *
+   * Removes the follow relationship where the authenticated user unfollows the target user.
+   * Requires authentication.
+   *
+   * @param followingId - The ID of the user to unfollow
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if follow relationship not found
+   */
+  async unfollow(followingId, options) {
+    log14("Unfollowing user: %d", followingId);
+    const body = { followingId };
+    const result = await this.request("/v1/user/follows", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "DELETE",
+      ...options
+    });
+    log14("Successfully unfollowed user: %d", followingId);
+    return result;
+  }
+  /**
+   * Check follow status
+   *
+   * Checks if the authenticated user is following the target user and if they follow each other.
+   * Requires authentication.
+   *
+   * @param targetUserId - The ID of the user to check
+   * @param options - Optional request options
+   * @returns Promise resolving to follow status (isFollowing, isMutual)
+   */
+  async checkFollowStatus(targetUserId, options) {
+    log14("Checking follow status for user: %d", targetUserId);
+    const queryString = this.buildQueryString({ targetUserId: String(targetUserId) });
+    const result = await this.request(
+      `/v1/user/follows/check${queryString}`,
+      options
+    );
+    log14("Follow status retrieved: %O", result);
+    return result;
+  }
+  /**
+   * Get following list
+   *
+   * Retrieves the list of users that a user is following.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose following list to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of following users
+   */
+  async getFollowing(userId, params = {}, options) {
+    log14("Getting following list for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/follows/${userId}/following${queryString}`,
+      options
+    );
+    log14("Following list retrieved for user: %d", userId);
+    return result;
+  }
+  /**
+   * Get followers list
+   *
+   * Retrieves the list of users who follow a user.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose followers list to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of followers
+   */
+  async getFollowers(userId, params = {}, options) {
+    log14("Getting followers list for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/follows/${userId}/followers${queryString}`,
+      options
+    );
+    log14("Followers list retrieved for user: %d", userId);
+    return result;
+  }
+};
+
+// src/market/services/UserFavoriteService.ts
+import debug15 from "debug";
+var log15 = debug15("lobe-market-sdk:user-favorite");
+var UserFavoriteService = class extends BaseSDK {
+  /**
+   * Add to favorites
+   *
+   * Adds an agent or plugin to the authenticated user's favorites.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if already in favorites
+   */
+  async addFavorite(targetType, targetId, options) {
+    log15("Adding favorite: %s %d", targetType, targetId);
+    const body = { targetId, targetType };
+    const result = await this.request("/v1/user/favorites", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      ...options
+    });
+    log15("Successfully added favorite: %s %d", targetType, targetId);
+    return result;
+  }
+  /**
+   * Remove from favorites
+   *
+   * Removes an agent or plugin from the authenticated user's favorites.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if favorite not found
+   */
+  async removeFavorite(targetType, targetId, options) {
+    log15("Removing favorite: %s %d", targetType, targetId);
+    const body = { targetId, targetType };
+    const result = await this.request("/v1/user/favorites", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "DELETE",
+      ...options
+    });
+    log15("Successfully removed favorite: %s %d", targetType, targetId);
+    return result;
+  }
+  /**
+   * Check favorite status
+   *
+   * Checks if the authenticated user has favorited a specific agent or plugin.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to favorite status
+   */
+  async checkFavorite(targetType, targetId, options) {
+    log15("Checking favorite status: %s %d", targetType, targetId);
+    const queryString = this.buildQueryString({
+      targetId: String(targetId),
+      targetType
+    });
+    const result = await this.request(
+      `/v1/user/favorites/check${queryString}`,
+      options
+    );
+    log15("Favorite status retrieved: %O", result);
+    return result;
+  }
+  /**
+   * Get my favorites
+   *
+   * Retrieves the authenticated user's favorites.
+   * Requires authentication.
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @param options - Optional request options
+   * @returns Promise resolving to list of favorites
+   */
+  async getMyFavorites(params = {}, options) {
+    log15("Getting my favorites: %O", params);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    if (params.type !== void 0) queryParams.type = params.type;
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/favorites/me${queryString}`,
+      options
+    );
+    log15("My favorites retrieved");
+    return result;
+  }
+  /**
+   * Get user's favorites
+   *
+   * Retrieves a user's favorites.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose favorites to retrieve
+   * @param params - Query parameters for filtering and pagination
+   * @param options - Optional request options
+   * @returns Promise resolving to list of favorites
+   */
+  async getUserFavorites(userId, params = {}, options) {
+    log15("Getting favorites for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    if (params.type !== void 0) queryParams.type = params.type;
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/favorites/${userId}${queryString}`,
+      options
+    );
+    log15("Favorites retrieved for user: %d", userId);
+    return result;
+  }
+  /**
+   * Get user's favorite agents with details
+   *
+   * Retrieves a user's favorite agents with full details.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose favorite agents to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of favorite agents
+   */
+  async getUserFavoriteAgents(userId, params = {}, options) {
+    log15("Getting favorite agents for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/favorites/${userId}/agents${queryString}`,
+      options
+    );
+    log15("Favorite agents retrieved for user: %d", userId);
+    return result;
+  }
+  /**
+   * Get user's favorite plugins with details
+   *
+   * Retrieves a user's favorite plugins with full details.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose favorite plugins to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of favorite plugins
+   */
+  async getUserFavoritePlugins(userId, params = {}, options) {
+    log15("Getting favorite plugins for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/favorites/${userId}/plugins${queryString}`,
+      options
+    );
+    log15("Favorite plugins retrieved for user: %d", userId);
+    return result;
+  }
+};
+
+// src/market/services/UserLikeService.ts
+import debug16 from "debug";
+var log16 = debug16("lobe-market-sdk:user-like");
+var UserLikeService = class extends BaseSDK {
+  /**
+   * Like content
+   *
+   * Likes an agent or plugin for the authenticated user.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if already liked
+   */
+  async like(targetType, targetId, options) {
+    log16("Liking: %s %d", targetType, targetId);
+    const body = { targetId, targetType };
+    const result = await this.request("/v1/user/likes", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      ...options
+    });
+    log16("Successfully liked: %s %d", targetType, targetId);
+    return result;
+  }
+  /**
+   * Unlike content
+   *
+   * Unlikes an agent or plugin for the authenticated user.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to success response
+   * @throws Error if like not found
+   */
+  async unlike(targetType, targetId, options) {
+    log16("Unliking: %s %d", targetType, targetId);
+    const body = { targetId, targetType };
+    const result = await this.request("/v1/user/likes", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "DELETE",
+      ...options
+    });
+    log16("Successfully unliked: %s %d", targetType, targetId);
+    return result;
+  }
+  /**
+   * Toggle like status
+   *
+   * Toggles the like status - likes if not liked, unlikes if already liked.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to toggle response with new like status
+   */
+  async toggleLike(targetType, targetId, options) {
+    log16("Toggling like: %s %d", targetType, targetId);
+    const body = { targetId, targetType };
+    const result = await this.request("/v1/user/likes/toggle", {
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      ...options
+    });
+    log16("Like toggled, new status: %O", result);
+    return result;
+  }
+  /**
+   * Check like status
+   *
+   * Checks if the authenticated user has liked a specific agent or plugin.
+   * Requires authentication.
+   *
+   * @param targetType - The type of target ('agent' or 'plugin')
+   * @param targetId - The ID of the target agent/plugin
+   * @param options - Optional request options
+   * @returns Promise resolving to like status
+   */
+  async checkLike(targetType, targetId, options) {
+    log16("Checking like status: %s %d", targetType, targetId);
+    const queryString = this.buildQueryString({
+      targetId: String(targetId),
+      targetType
+    });
+    const result = await this.request(
+      `/v1/user/likes/check${queryString}`,
+      options
+    );
+    log16("Like status retrieved: %O", result);
+    return result;
+  }
+  /**
+   * Get my likes
+   *
+   * Retrieves the authenticated user's likes.
+   * Requires authentication.
+   *
+   * @param params - Query parameters for filtering and pagination
+   * @param options - Optional request options
+   * @returns Promise resolving to list of likes
+   */
+  async getMyLikes(params = {}, options) {
+    log16("Getting my likes: %O", params);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    if (params.type !== void 0) queryParams.type = params.type;
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/likes/me${queryString}`,
+      options
+    );
+    log16("My likes retrieved");
+    return result;
+  }
+  /**
+   * Get user's likes
+   *
+   * Retrieves a user's likes.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose likes to retrieve
+   * @param params - Query parameters for filtering and pagination
+   * @param options - Optional request options
+   * @returns Promise resolving to list of likes
+   */
+  async getUserLikes(userId, params = {}, options) {
+    log16("Getting likes for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    if (params.type !== void 0) queryParams.type = params.type;
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/likes/${userId}${queryString}`,
+      options
+    );
+    log16("Likes retrieved for user: %d", userId);
+    return result;
+  }
+  /**
+   * Get user's liked agents with details
+   *
+   * Retrieves a user's liked agents with full details.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose liked agents to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of liked agents
+   */
+  async getUserLikedAgents(userId, params = {}, options) {
+    log16("Getting liked agents for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/likes/${userId}/agents${queryString}`,
+      options
+    );
+    log16("Liked agents retrieved for user: %d", userId);
+    return result;
+  }
+  /**
+   * Get user's liked plugins with details
+   *
+   * Retrieves a user's liked plugins with full details.
+   * This is a public endpoint - no authentication required.
+   *
+   * @param userId - The ID of the user whose liked plugins to retrieve
+   * @param params - Pagination parameters
+   * @param options - Optional request options
+   * @returns Promise resolving to list of liked plugins
+   */
+  async getUserLikedPlugins(userId, params = {}, options) {
+    log16("Getting liked plugins for user: %d", userId);
+    const queryParams = {};
+    if (params.limit !== void 0) queryParams.limit = String(params.limit);
+    if (params.offset !== void 0) queryParams.offset = String(params.offset);
+    const queryString = this.buildQueryString(queryParams);
+    const result = await this.request(
+      `/v1/user/likes/${userId}/plugins${queryString}`,
+      options
+    );
+    log16("Liked plugins retrieved for user: %d", userId);
+    return result;
+  }
+};
+
 // src/market/market-sdk.ts
-var log14 = debug14("lobe-market-sdk");
+var log17 = debug17("lobe-market-sdk");
 var MarketSDK = class extends BaseSDK {
   /**
    * Creates a new MarketSDK instance
@@ -2290,11 +2946,14 @@ var MarketSDK = class extends BaseSDK {
       tokenExpiry: void 0
     };
     super(options, void 0, sharedTokenState);
-    log14("MarketSDK instance created");
+    log17("MarketSDK instance created");
     this.agents = new AgentService(options, this.headers, sharedTokenState);
     this.auth = new AuthService(options, this.headers, sharedTokenState);
     this.plugins = new PluginsService(options, this.headers, sharedTokenState);
     this.user = new UserService(options, this.headers, sharedTokenState);
+    this.follows = new UserFollowService(options, this.headers, sharedTokenState);
+    this.favorites = new UserFavoriteService(options, this.headers, sharedTokenState);
+    this.likes = new UserLikeService(options, this.headers, sharedTokenState);
     this.discovery = new DiscoveryService(options, this.headers, sharedTokenState);
   }
   /**
@@ -2321,7 +2980,7 @@ var MarketSDK = class extends BaseSDK {
    * @deprecated Use auth.registerClient() instead
    */
   async registerClient(request) {
-    log14("Registering client (deprecated method, use auth.registerClient): %s", request.clientName);
+    log17("Registering client (deprecated method, use auth.registerClient): %s", request.clientName);
     return this.auth.registerClient(request);
   }
 };