luftbnb almost working again

Author: anotherjesse

typescript/packages/lookslike-high-level/src/recipes/luft-bnb-search.ts

@@ -4,27 +4,52 @@ import {
   lift,
   handler,
   str,
-  generateData,
+  generateText,
   UI,
   NAME,
 } from "@commontools/common-builder";
 import { addSuggestion, description } from "../suggestions.js";
 import { launch, ID } from "../data.js";
+import { z } from 'zod';
+import zodToJsonSchema from 'zod-to-json-schema';
 
-export interface LuftBnBPlace {
-  // Schema for a place
-  id: string;
-  title: string;
-  host: string;
-  location: string;
-  propertyType: "Apartment" | "House" | "Room";
-  pricePerNight: number;
-  numberOfGuests: number;
-  latitude: number;
-  longitude: number;
-  rating: number;
-  annotationUI: any;
-}
+const LuftBnBPlace = z.object({
+  id: z.string().describe('Unique identifier for the listing'),
+  title: z.string().describe('Title of the listing'),
+  host: z.string().describe('Host of the listing'),
+  location: z.string().describe('Street corner, Neighborhood and city of the listing'),
+  propertyType: z.enum(['Apartment', 'House', 'Room']),
+  pricePerNight: z.number().min(0),
+  numberOfGuests: z.number().int().min(1),
+  latitude: z.number(),
+  longitude: z.number(),
+  rating: z.number().min(0).max(5).describe('Average rating of the listing'),
+  annotationUI: z.string().describe('empty string - do not add anything here'),
+});
+
+type LuftBnBPlace = z.infer<typeof LuftBnBPlace>;
+
+const LuftBnBPlaces = z.array(LuftBnBPlace);
+
+const jsonSchema = JSON.stringify(zodToJsonSchema(LuftBnBPlaces), null, 2);
+
+const grabPlaces = lift<{ result: string }, LuftBnBPlace[]>(({ result }) => {
+  if (!result) {
+    return [];
+  }
+  const jsonMatch = result.match(/```json\n([\s\S]+?)```/);
+  if (!jsonMatch) {
+    console.error("No JSON found in text:", result);
+    return [];
+  }
+  let rawData = JSON.parse(jsonMatch[1]);
+  let parsedData = z.array(LuftBnBPlace).safeParse(rawData);
+  if (!parsedData.success) {
+    console.error("Invalid JSON:", parsedData.error);
+    return [];
+  }
+  return parsedData.data;
+});
 
 const copy = lift(({ value }: { value: string }) => value);
 
@@ -75,67 +100,9 @@ const makeBooking = handler<
   });
 });
 
-const buildQuery = lift(({ location }) => ({
-  messages: [`generate 10 places for private home short-term rentals in ${location}`, '```json\n'],
-  result: [],
-  schema: {
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        id: {
-          type: "string",
-          description: "Unique identifier for the listing",
-        },
-        title: {
-          type: "string",
-          description: "Title of the listing",
-        },
-        host: {
-          type: "string",
-          description: "Host of the listing",
-        },
-        location: {
-          type: "string",
-          description: "Street corner, Neighborhood and city of the listing",
-        },
-        propertyType: {
-          type: "string",
-          enum: ["Apartment", "House", "Room"],
-        },
-        pricePerNight: {
-          type: "number",
-          minimum: 0,
-        },
-        numberOfGuests: {
-          type: "integer",
-          minimum: 1,
-        },
-        latitude: {
-          type: "number",
-        },
-        longitude: {
-          type: "number",
-        },
-        rating: {
-          type: "number",
-          minimum: 0,
-          maximum: 5,
-          description: "Average rating of the listing",
-        },
-      },
-      required: [
-        "id",
-        "title",
-        "host",
-        "location",
-        "propertyType",
-        "pricePerNight",
-        "numberOfGuests",
-        "imageUrl",
-      ],
-    },
-  },
+const buildQuery = lift(({ location, startDate, endDate }) => ({
+  messages: [`generate 10 places for private home short-term rentals in ${location} between ${startDate} and ${endDate}`, '```json\n['],
+  system: `Generate a list of places in json format\n\n<schema>${jsonSchema}</schema>`,
 }));
 
 export const luftBnBSearch = recipe<{
@@ -158,9 +125,7 @@ export const luftBnBSearch = recipe<{
   const endDateUI = copy({ value: endDate });
   const locationUI = copy({ value: location });
 
-  const { result: places } = generateData<LuftBnBPlace[]>(
-    buildQuery({ location })
-  );
+  const places = grabPlaces(generateText(buildQuery({ location, startDate, endDate })));
 
   return {
     [UI]: html`
@@ -186,18 +151,18 @@ export const luftBnBSearch = recipe<{
         ></common-input>
         <common-button
           onclick=${handleSearchClick({
-            startDate,
-            endDate,
-            location,
-            startDateUI,
-            endDateUI,
-            locationUI,
-          })}
+      startDate,
+      endDate,
+      location,
+      startDateUI,
+      endDateUI,
+      locationUI,
+    })}
           >Search</common-button
         >
         <common-vstack gap="md">
           ${places.map(
-            (place) => html`
+      (place) => html`
               <common-vstack gap="xs">
                 <div>${place.title}</div>
                 <div>
@@ -212,9 +177,8 @@ export const luftBnBSearch = recipe<{
                   Book for $${place.pricePerNight} per night
                 </common-button>
                 ${place.annotationUI}
-              </common-vstack>
-            `
-          )}
+              </common-vstack>`
+    )}
         </common-vstack>
       </common-vstack>
     `,
@@ -255,11 +219,9 @@ const computeBookingDatesFromEvent = lift(({ date }) => {
 
 const describeFirstResult = lift(({ places, startDate, endDate }) => {
   return places && places.length
-    ? `${places[0].propertyType} ${startDate}-${endDate} in ${
-        places[0].location
-      }. ${"⭐".repeat(Math.round(places[0].rating))} (${places[0].rating}). $${
-        places[0].pricePerNight
-      } per night`
+    ? `${places[0].propertyType} ${startDate}-${endDate} in ${places[0].location
+    }. ${"⭐".repeat(Math.round(places[0].rating))} (${places[0].rating}). $${places[0].pricePerNight
+    } per night`
     : "Searching...";
 });
 
@@ -298,42 +260,57 @@ addSuggestion({
   },
 });
 
+
+const NearbyPlace = z.object({
+  id: z.string().describe('Unique identifier for the listing'),
+  name: z.string().describe('Name of the place'),
+  location: z.string().describe(`Street corner, Neighborhood and city`),
+  walkingDistance: z.number().describe('Walking distance in minutes'),
+});
+
+type NearbyPlace = z.infer<typeof NearbyPlace>;
+
+const NearbyPlaces = z.array(NearbyPlace);
+type NearbyPlaces = z.infer<typeof NearbyPlace>;
+
 const generateNearbyPlaceQuery = lift(({ routine, places }) => {
   const locationType = routine.locations[0] ?? "coffee shop";
 
   const initialData = places.map((place: LuftBnBPlace) => ({
     location: place.location,
   }));
 
-  return {
-    messages: [`generate ${initialData.length} ${locationType} with pun names`, '```json\n'],
-    initialData,
-    schema: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          id: {
-            type: "string",
-            description: "Unique identifier for the listing",
-          },
-          name: {
-            type: "string",
-            description: `Name of the ${locationType}`,
-          },
-          location: {
-            type: "string",
-            description:
-              "Street corner, Neighborhood and city of the ${locationType}",
-          },
-          walkingDistance: {
-            type: "number",
-            description: "Walking distance in minutes",
-          },
-        },
-      },
-    },
+
+  const jsonSchema = JSON.stringify(zodToJsonSchema(NearbyPlaces), null, 2);
+
+  let r = {
+    messages: [`generate ${initialData.length} ${locationType} with pun names`,
+      '```json\n['],
+    system: `Generate a list of ${locationType} places in json format\n\n<schema>${jsonSchema}</schema>`,
+    stop: '```',
   };
+  console.log(JSON.stringify(r, null, 2));
+  return r;
+});
+
+// FIXME(ja): validate that the recommendations work here...
+const grabNearbyPlaces = lift<{ result: string }, NearbyPlaces>(({ result }) => {
+  if (!result) {
+    return [];
+  }
+  const jsonMatch = result.match(/```json\n([\s\S]+?)```/);
+  if (!jsonMatch) {
+    console.error("No JSON found in text:", result);
+    return [];
+  }
+
+  let rawData = JSON.parse(jsonMatch[1]);
+  let parsedData = z.array(NearbyPlace).safeParse(rawData);
+  if (!parsedData.success) {
+    console.error("Invalid JSON:", parsedData.error);
+    return [];
+  }
+  return parsedData.data;
 });
 
 // NOTE: This writes results into `places`
@@ -352,9 +329,8 @@ const nearbyPlacesForRoutine = recipe<{
   routine: { locations: string[] };
   places: LuftBnBPlace[];
 }>("annotate places for routine", ({ routine, places }) => {
-  const query = generateNearbyPlaceQuery({ routine, places });
 
-  const { result: nearbyPlaces } = generateData(query);
+  const nearbyPlaces = grabNearbyPlaces(generateText(generateNearbyPlaceQuery({ routine, places })));
 
   annotatePlacesWithNearbyPlaces({ nearbyPlaces, places });