searchSongs

Instructions

Implementation Reference

• src/index.ts:119-141 (registration)

  Tool registration/schema definition for searchSongs in the TypeScript implementation. Defines name='searchSongs', description, and inputSchema with streamerName (string), query (string, required), and limit (number, default 20).

  {
    name: "searchSongs",
    description: "Search within a streamer's song list by title or artist",
    inputSchema: {
      type: "object",
      properties: {
        streamerName: {
          type: "string",
          description: "The name of the streamer whose songs to search",
        },
        query: {
          type: "string",
          description: "Search query to match against song titles and artists",
        },
        limit: {
          type: "number",
          description: "Maximum number of results to return (default: 20)",
          default: 20,
        },
      },
      required: ["query"],
    },
  },

• src/index.ts:274-287 (handler)

  Handler implementation for searchSongs in the TypeScript version. Extracts streamerName, query, and limit from args, calls the API with a search query parameter, and returns the filtered results.

  case "searchSongs": {
    const streamerName = getEffectiveStreamer((args as any)?.streamerName);
    const query = (args as any)?.query;
    const limit = (args as any)?.limit || 20;
    const data = await makeApiRequest(`/streamers/${encodeURIComponent(streamerName)}/songs?search=${encodeURIComponent(query)}&limit=${limit}`);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(data, null, 2),
        },
      ],
    };
  }

• src/server.js:214-236 (registration)

  Tool registration/schema definition for searchSongs in the JavaScript implementation. Same schema definition with name, description, and inputSchema (streamerName optional string, query required string, limit number default 20).

  {
    name: "searchSongs",
    description: "Search within a streamer's song list by title or artist",
    inputSchema: {
      type: "object",
      properties: {
        streamerName: {
          type: "string",
          description: "The name of the streamer whose songs to search",
        },
        query: {
          type: "string",
          description: "Search query to match against song titles and artists",
        },
        limit: {
          type: "number",
          description: "Maximum number of results to return (default: 20)",
          default: 20,
        },
      },
      required: ["query"],
    },
  },

• src/server.js:435-486 (handler)

  Handler implementation for searchSongs in the JavaScript version. Fetches up to 1000 songs, filters locally by matching query against song title or artist (case-insensitive), slices to limit, and returns results.

  case "searchSongs": {
    const { streamerName = defaultStreamer, query, limit = 20 } = args;
  
    if (!streamerName) {
      throw new Error(
        "streamerName is required. Provide a streamerName or set the DEFAULT_STREAMER environment variable."
      );
    }
  
    if (!query) {
      throw new Error("query is required for song search");
    }
  
    try {
      // First get all songs, then filter locally
      const response = await fetch(`${API_BASE}/streamers/${encodeURIComponent(streamerName)}/songs?limit=1000`);
  
      if (!response.ok) {
        return {
          content: [{
            type: "text",
            text: `Error fetching songs for search: ${response.status} ${response.statusText}`
          }]
        };
      }
  
      const songsData = await response.json();
      const allSongs = songsData.items || songsData; // Handle different response formats
      const searchQuery = query.toLowerCase();
  
      // Filter songs by title or artist
      const filteredSongs = allSongs.filter(song => {
        const title = (song.title || '').toLowerCase();
        const artist = (song.artist || '').toLowerCase();
        return title.includes(searchQuery) || artist.includes(searchQuery);
      }).slice(0, limit);
  
      return {
        content: [{
          type: "text",
          text: `Found ${filteredSongs.length} songs matching "${query}":\n${JSON.stringify(filteredSongs, null, 2)}`
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
        }]
      };
    }
  }