search_sitters

Instructions

Implementation Reference

• src/browser.ts:160-242 (handler)

  The core implementation of search_sitters - navigates to Rover search URL, scrapes sitter cards from the page using Playwright, and returns structured sitter results with name, location, rating, reviews, price, and profile URL.

  async searchSitters(params: SitterSearchParams): Promise<SitterResult[]> {
    const page = this.ensurePage();
    const serviceMap: Record<string, string> = {
      boarding: "boarding",
      house_sitting: "house-sitting",
      drop_in: "drop-in-visits",
      doggy_day_care: "doggy-day-care",
      dog_walking: "dog-walking",
    };
    const service = serviceMap[params.serviceType] || "boarding";
    const encodedLocation = encodeURIComponent(params.location);
    let url = `${this.BASE_URL}/search/results/?service_type=${service}&location=${encodedLocation}`;
  
    if (params.startDate) url += `&start_date=${params.startDate}`;
    if (params.endDate) url += `&end_date=${params.endDate}`;
    if (params.petCount) url += `&dog_count=${params.petCount}`;
  
    await page.goto(url);
    await page.waitForLoadState("networkidle");
  
    const sitters = await page.evaluate(() => {
      const results: Array<{
        id: string;
        name: string;
        location: string;
        rating: number;
        reviewCount: number;
        price: number;
        priceUnit: string;
        services: string[];
        profileUrl: string;
        avatarUrl: string | undefined;
        summary: string | undefined;
      }> = [];
  
      const cards = document.querySelectorAll(
        '[data-testid="sitter-card"], .sitter-card, article[class*="sitter"], [class*="SearchResult"]'
      );
  
      cards.forEach((card, index) => {
        if (index >= 20) return;
        const nameEl = card.querySelector(
          '[class*="sitter-name"], [class*="SitterName"], h3, h2'
        );
        const ratingEl = card.querySelector(
          '[class*="rating"], [aria-label*="rating"], [class*="Rating"]'
        );
        const reviewEl = card.querySelector('[class*="review"], [class*="Review"]');
        const priceEl = card.querySelector('[class*="price"], [class*="Price"]');
        const locationEl = card.querySelector('[class*="location"], [class*="Location"]');
        const linkEl = card.querySelector("a[href*='/sitters/'], a[href*='/dog-boarding/']");
        const imgEl = card.querySelector("img");
        const summaryEl = card.querySelector('[class*="summary"], [class*="Summary"], p');
  
        const ratingText = ratingEl?.textContent?.trim() || "0";
        const reviewText = reviewEl?.textContent?.replace(/[^\d]/g, "") || "0";
        const priceText = priceEl?.textContent?.replace(/[^\d.]/g, "") || "0";
  
        if (nameEl?.textContent?.trim()) {
          results.push({
            id: `sitter-${index}`,
            name: nameEl.textContent.trim(),
            location: locationEl?.textContent?.trim() || "",
            rating: parseFloat(ratingText) || 0,
            reviewCount: parseInt(reviewText, 10) || 0,
            price: parseFloat(priceText) || 0,
            priceUnit: "night",
            services: [],
            profileUrl: (linkEl as HTMLAnchorElement)?.href || "",
            avatarUrl: (imgEl as HTMLImageElement)?.src,
            summary: summaryEl?.textContent?.trim(),
          });
        }
      });
  
      return results;
    });
  
    return sitters.map((s, i) => ({
      ...s,
      id: s.id || `sitter-${i}`,
    }));
  }

• src/index.ts:397-423 (handler)

  The MCP tool handler for 'search_sitters' - validates input with SearchSittersSchema, calls browser.searchSitters(), and formats the results as markdown text content for the response.

  case "search_sitters": {
    const params = SearchSittersSchema.parse(args);
    const sitters = await browser.searchSitters(params);
    if (sitters.length === 0) {
      return {
        content: [{ type: "text", text: "No sitters found for the given criteria." }],
      };
    }
    const formatted = sitters
      .map(
        (s, i) =>
          `${i + 1}. **${s.name}** — ${s.location}\n` +
          `   Rating: ${s.rating}/5 (${s.reviewCount} reviews)\n` +
          `   Price: $${s.price}/${s.priceUnit}\n` +
          `   Profile: ${s.profileUrl}` +
          (s.summary ? `\n   "${s.summary}"` : "")
      )
      .join("\n\n");
    return {
      content: [
        {
          type: "text",
          text: `Found ${sitters.length} sitters in ${params.location}:\n\n${formatted}`,
        },
      ],
    };
  }

• src/index.ts:299-306 (schema)

  Zod validation schema for search_sitters parameters - defines required location and serviceType fields, plus optional date range, petCount, and petSize fields.

  const SearchSittersSchema = z.object({
    location: z.string().min(1),
    serviceType: z.enum(["boarding", "house_sitting", "drop_in", "doggy_day_care", "dog_walking"]),
    startDate: z.string().optional(),
    endDate: z.string().optional(),
    petCount: z.number().optional(),
    petSize: z.enum(["small", "medium", "large", "giant"]).optional(),
  });

• src/index.ts:37-72 (registration)

  Tool registration for 'search_sitters' in the tools array - defines name, description, and JSON Schema inputSchema with all properties and required fields.

  {
    name: "search_sitters",
    description:
      "Search for pet sitters on Rover by location and service type. Returns a list of available sitters with ratings and pricing.",
    inputSchema: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "City, neighborhood, or zip code to search in (e.g. 'Seattle, WA' or '98101')",
        },
        serviceType: {
          type: "string",
          enum: ["boarding", "house_sitting", "drop_in", "doggy_day_care", "dog_walking"],
          description: "Type of pet care service",
        },
        startDate: {
          type: "string",
          description: "Start date in YYYY-MM-DD format",
        },
        endDate: {
          type: "string",
          description: "End date in YYYY-MM-DD format",
        },
        petCount: {
          type: "number",
          description: "Number of pets",
        },
        petSize: {
          type: "string",
          enum: ["small", "medium", "large", "giant"],
          description: "Size of your pet",
        },
      },
      required: ["location", "serviceType"],
    },

• src/browser.ts:9-32 (schema)

  TypeScript interface definitions for SitterSearchParams (input) and SitterResult (output) - defines the shape of parameters and results for the search_sitters tool.

  export interface SitterSearchParams {
    location: string;
    serviceType: "boarding" | "house_sitting" | "drop_in" | "doggy_day_care" | "dog_walking";
    startDate?: string;
    endDate?: string;
    petCount?: number;
    petSize?: "small" | "medium" | "large" | "giant";
  }
  
  export interface SitterResult {
    id: string;
    name: string;
    location: string;
    rating: number;
    reviewCount: number;
    price: number;
    priceUnit: string;
    services: string[];
    profileUrl: string;
    avatarUrl?: string;
    repeatClientCount?: number;
    yearsExperience?: number;
    summary?: string;
  }