One Agent for Many Units

import { z } from 'zod/v4';
import { defineManifest } from '@runflow-ai/sdk';

const hotel = z.object({
  name: z.string().min(1).meta({ title: 'Name' }),
  channelIds: z
    .array(z.string())
    .meta({ title: 'WhatsApp numbers', description: 'Phone number ids (from the Meta app) that serve this hotel' }),
  checkIn: z.string().default('14:00').meta({ title: 'Check-in' }),
  checkOut: z.string().default('12:00').meta({ title: 'Check-out' }),
  amenities: z
    .object({
      pool: z.boolean().default(false).meta({ title: 'Pool' }),
      parking: z.boolean().default(false).meta({ title: 'Parking' }),
      parkingNotes: z
        .string()
        .optional()
        .meta({ title: 'Parking notes', visibleWhen: { field: 'parking', equals: true } }),
    })
    .meta({ title: 'Amenities' }),
  pms: z
    .object({
      propertyCode: z.string().min(1).meta({ title: 'Property code' }),
      chainCode: z.string().default('ATR').meta({ title: 'Chain code' }),
    })
    .meta({ title: 'PMS' }),
  payment: z
    .object({
      merchantId: z.string().min(1).meta({ title: 'Merchant ID' }),
      linkExpiryHours: z.number().int().min(1).max(168).default(24).meta({ title: 'Link expiry', unit: 'h' }),
    })
    .meta({ title: 'Payment' }),
  handoff: z
    .object({
      queue: z.string().default('front-desk').meta({ title: 'Queue' }),
      topics: z.array(z.string()).default(['complaint', 'refund']).meta({ title: 'Topics that go to a human' }),
    })
    .meta({ title: 'Handoff' }),
  notes: z
    .string()
    .max(4000)
    .optional()
    .meta({ title: 'Extra instructions', description: 'Added to the prompt', ui: { widget: 'textarea' } }),
});

export const configSchema = z.object({
  tone: z
    .enum(['formal', 'casual'])
    .default('formal')
    .meta({ title: 'Tone', ui: { labels: { formal: 'Formal', casual: 'Casual' } } }),
  hotels: z
    .record(z.string(), hotel)
    .default({})
    .meta({
      title: 'Hotels',
      description: 'One item per hotel',
      ui: { itemLabel: 'name', itemName: 'hotel', itemSubtitle: 'pms.propertyCode' },
    }),
});

export default defineManifest({
  config: configSchema,
  playground: {
    schema: z.object({ phoneNumberId: z.string().meta({ title: 'WhatsApp phone number id' }) }),
    fixtures: [
      { name: 'Hotel Copacabana', metadata: { phoneNumberId: '100000000000001' } },
      { name: 'Number without a hotel', metadata: { phoneNumberId: '100000000000999' } },
    ],
  },
});

import { Agent, openai, config, configInfo, readMetadata } from '@runflow-ai/sdk';
import type { z } from 'zod/v4';
import { configSchema } from './manifest';

type Config = z.infer<typeof configSchema>;
type Hotel = Config['hotels'][string];

function numberOf(input): string | undefined {
  const fromTester = readMetadata<{ phoneNumberId?: string }>(input).phoneNumberId;
  return fromTester ?? input.request?.body?.phoneNumberId;
}

function hotelFor(cfg: Config, phoneNumberId: string | undefined) {
  if (!phoneNumberId) return null;
  const match = Object.entries(cfg.hotels).find(([, h]) => h.channelIds.includes(phoneNumberId));
  return match ? { id: match[0], hotel: match[1] } : null;
}

function instructionsFor(cfg: Config, hotel: Hotel): string {
  const parking = hotel.amenities.parking ? hotel.amenities.parkingNotes ?? 'available' : 'not available';
  return [
    `You are the WhatsApp assistant of ${hotel.name}. Use a ${cfg.tone} tone.`,
    `Check-in from ${hotel.checkIn}, check-out until ${hotel.checkOut}.`,
    `Pool: ${hotel.amenities.pool ? 'yes' : 'no'}. Parking: ${parking}.`,
    `Hand the conversation to the "${hotel.handoff.queue}" queue when the topic is: ${hotel.handoff.topics.join(', ')}.`,
    hotel.notes ?? '',
  ]
    .filter(Boolean)
    .join('\n');
}

export async function main(input) {
  const cfg = config<Config>();
  const phoneNumberId = numberOf(input);
  const match = hotelFor(cfg, phoneNumberId);

  if (!match) {
    return {
      message: 'Thanks for your message! A member of our team will reply shortly.',
      handoff: true,
      reason: `no hotel configured for number ${phoneNumberId ?? '(none)'}`,
    };
  }

  const agent = new Agent({
    name: `Concierge ${match.hotel.name}`,
    model: openai('gpt-4o'),
    instructions: instructionsFor(cfg, match.hotel),
  });

  const output = await agent.process(input);
  return { ...output, hotelId: match.id, config: configInfo() };
}

{
  "hotels": {
    "hotel-centro": {
      "name": "Hotel Centro",
      "channelIds": ["100000000000002"],
      "amenities": { "pool": false, "parking": true, "parkingNotes": "Valet, R$ 40/day" },
      "pms": { "propertyCode": "CTR01" },
      "payment": { "merchantId": "merchant-ctr" }
    }
  }
}