@voicethere/agent 0.5.4 → 0.5.6

package/templates/recording-consent/conversation.ts

@@ -0,0 +1,300 @@
+/**
+ * Pure conversation state machine for the recording-consent template.
+ * Tests import this module directly — no defineAgent dependency.
+ */
+
+export const CONSENT_PROMPT =
+  "This call may be recorded for quality purposes. Is that OK?";
+
+export const NAME_PROMPT = "May I have your name please?";
+
+export const BIRTHDATE_PROMPT = "And your date of birth?";
+
+export const RECORDING_DISABLED_SKIP_MESSAGE =
+  "Conversation recording is not enabled for this project.";
+
+export type ConversationPhase =
+  "awaitingConsent" | "awaitingName" | "awaitingBirthdate" | "complete";
+
+export type RecordingAction = "pause" | "stop" | "start" | "resume" | null;
+
+export interface ConversationState {
+  phase: ConversationPhase;
+  recordingAvailable: boolean;
+  consent?: boolean;
+  /** True when consent was skipped because project recording is off. */
+  consentSkipped: boolean;
+  name?: string;
+  birthdate?: string;
+}
+
+export interface OutboundMessage {
+  type: "chat_reply" | "agent_event";
+  text?: string;
+  event?: string;
+  sessionId?: string;
+}
+
+export interface ConversationTurnResult {
+  state: ConversationState;
+  speakLines: string[];
+  messages: OutboundMessage[];
+  recordingAction: RecordingAction;
+  /** When true, agent should warn that project recording is disabled. */
+  warnRecordingDisabled?: boolean;
+}
+
+export function createInitialState(
+  recordingAvailable: boolean,
+): ConversationState {
+  if (recordingAvailable) {
+    return {
+      phase: "awaitingConsent",
+      recordingAvailable,
+      consentSkipped: false,
+    };
+  }
+  return {
+    phase: "awaitingName",
+    recordingAvailable,
+    consentSkipped: true,
+  };
+}
+
+function speakAndChat(text: string): {
+  speakLines: string[];
+  messages: OutboundMessage[];
+} {
+  return {
+    speakLines: [text],
+    messages: [{ type: "chat_reply", text }],
+  };
+}
+
+export function beginSession(
+  recordingAvailable: boolean,
+): ConversationTurnResult {
+  const state = createInitialState(recordingAvailable);
+  if (recordingAvailable) {
+    const prompt = speakAndChat(CONSENT_PROMPT);
+    return {
+      state,
+      speakLines: prompt.speakLines,
+      messages: prompt.messages,
+      recordingAction: null,
+    };
+  }
+  const skip = speakAndChat(RECORDING_DISABLED_SKIP_MESSAGE);
+  const name = speakAndChat(NAME_PROMPT);
+  return {
+    state,
+    speakLines: [...skip.speakLines, ...name.speakLines],
+    messages: [...skip.messages, ...name.messages],
+    recordingAction: null,
+    warnRecordingDisabled: true,
+  };
+}
+
+export function isConsentNo(utterance: string): boolean {
+  const lower = utterance.toLowerCase().trim();
+  if (/\bnot\s+ok(?:ay)?\b/i.test(lower)) return true;
+  const noPhrases = [
+    "no",
+    "nope",
+    "nah",
+    "don't",
+    "do not",
+    "decline",
+    "refuse",
+  ];
+  if (noPhrases.some((p) => lower === p || lower.startsWith(`${p} `))) {
+    return true;
+  }
+  return /\b(no|nope|nah)\b/i.test(utterance) && !/\bknow\b/i.test(utterance);
+}
+
+export function isConsentYes(utterance: string): boolean {
+  if (isConsentNo(utterance)) return false;
+  const lower = utterance.toLowerCase().trim();
+  const yesPhrases = [
+    "yes",
+    "yeah",
+    "yep",
+    "sure",
+    "ok",
+    "okay",
+    "that's fine",
+    "that is fine",
+    "go ahead",
+    "fine",
+    "absolutely",
+  ];
+  if (yesPhrases.some((p) => lower === p || lower.startsWith(`${p} `))) {
+    return true;
+  }
+  return /\b(yes|yeah|yep|sure|ok|okay)\b/i.test(utterance);
+}
+
+export function extractName(utterance: string): string | null {
+  const trimmed = utterance.trim();
+  const patterns = [/(?:my name is|i'm|i am|call me)\s+(.+)/i];
+  for (const pattern of patterns) {
+    const match = trimmed.match(pattern);
+    if (match?.[1]) {
+      return sanitizeToken(match[1], 40);
+    }
+  }
+  if (trimmed.length > 0 && trimmed.length <= 60) {
+    return sanitizeToken(trimmed, 40);
+  }
+  return null;
+}
+
+export function extractBirthdate(utterance: string): string | null {
+  const trimmed = utterance.trim();
+  const iso = trimmed.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+  if (iso?.[1]) return iso[1];
+  const slash = trimmed.match(/\b(\d{1,2}\/\d{1,2}\/\d{2,4})\b/);
+  if (slash?.[1]) return slash[1];
+  const spoken = trimmed.match(
+    /\b(january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{1,2}(?:st|nd|rd|th)?,?\s+\d{4}\b/i,
+  );
+  if (spoken?.[0]) return spoken[0];
+  if (trimmed.length >= 4 && trimmed.length <= 40) {
+    return sanitizeToken(trimmed, 40);
+  }
+  return null;
+}
+
+function sanitizeToken(raw: string, maxLen: number): string {
+  let value = raw
+    .trim()
+    .replace(/[.,!?;:]+$/g, "")
+    .trim();
+  if (value.length > maxLen) {
+    value = value.slice(0, maxLen).trim();
+  }
+  return value;
+}
+
+function askNameAgain(state: ConversationState): ConversationTurnResult {
+  const prompt = speakAndChat(
+    "Sorry, I didn't catch your name. May I have your name please?",
+  );
+  return {
+    state,
+    speakLines: prompt.speakLines,
+    messages: prompt.messages,
+    recordingAction: null,
+  };
+}
+
+function askBirthdateAgain(state: ConversationState): ConversationTurnResult {
+  const prompt = speakAndChat(
+    "Sorry, I didn't catch your date of birth. Could you repeat it?",
+  );
+  return {
+    state,
+    speakLines: prompt.speakLines,
+    messages: prompt.messages,
+    recordingAction: null,
+  };
+}
+
+function finishAfterPii(state: ConversationState): ConversationTurnResult {
+  const next: ConversationState = { ...state, phase: "complete" };
+  const thankYou = speakAndChat(
+    `Thank you, ${state.name}. We have your date of birth on file.`,
+  );
+  let recordingAction: RecordingAction = null;
+  if (state.consent === true && state.recordingAvailable) {
+    recordingAction = "resume";
+  }
+  return {
+    state: next,
+    speakLines: thankYou.speakLines,
+    messages: thankYou.messages,
+    recordingAction,
+  };
+}
+
+export function handleUtterance(
+  state: ConversationState,
+  utterance: string,
+): ConversationTurnResult {
+  switch (state.phase) {
+    case "awaitingConsent": {
+      if (isConsentNo(utterance)) {
+        const next: ConversationState = {
+          ...state,
+          phase: "awaitingName",
+          consent: false,
+        };
+        const name = speakAndChat(NAME_PROMPT);
+        return {
+          state: next,
+          speakLines: name.speakLines,
+          messages: name.messages,
+          recordingAction: "stop",
+        };
+      }
+      if (isConsentYes(utterance)) {
+        const next: ConversationState = {
+          ...state,
+          phase: "awaitingName",
+          consent: true,
+        };
+        const name = speakAndChat(NAME_PROMPT);
+        return {
+          state: next,
+          speakLines: name.speakLines,
+          messages: name.messages,
+          recordingAction: "pause",
+        };
+      }
+      const retry = speakAndChat(
+        "Please say yes or no — may we record this conversation?",
+      );
+      return {
+        state,
+        speakLines: retry.speakLines,
+        messages: retry.messages,
+        recordingAction: null,
+      };
+    }
+    case "awaitingName": {
+      const name = extractName(utterance);
+      if (!name) {
+        return askNameAgain(state);
+      }
+      const next: ConversationState = {
+        ...state,
+        phase: "awaitingBirthdate",
+        name,
+      };
+      const birthdate = speakAndChat(BIRTHDATE_PROMPT);
+      return {
+        state: next,
+        speakLines: birthdate.speakLines,
+        messages: birthdate.messages,
+        recordingAction: null,
+      };
+    }
+    case "awaitingBirthdate": {
+      const birthdate = extractBirthdate(utterance);
+      if (!birthdate) {
+        return askBirthdateAgain(state);
+      }
+      return finishAfterPii({ ...state, birthdate });
+    }
+    case "complete": {
+      const done = speakAndChat("We are all set. How can I help you today?");
+      return {
+        state,
+        speakLines: done.speakLines,
+        messages: done.messages,
+        recordingAction: null,
+      };
+    }
+  }
+}

package/templates/voice-showcase/conversation.ts

@@ -8,6 +8,7 @@ import { pickFunFact } from "./fun-facts.js";
 import {
   formatWeatherSpeech,
   lookupWeather,
+  matchCountryName,
   parseLocationUtterance,
   type FetchFn,
   type WeatherResult,
@@ -400,8 +401,19 @@ export function handleUtterance(
 
     case "weatherAwaitingLocation": {
       const parsed = parseLocationUtterance(text);
-      const city = parsed?.city ?? state.weatherCity;
-      const country = parsed?.country ?? state.weatherCountry;
+      let city = parsed?.city || state.weatherCity;
+      let country = parsed?.country || state.weatherCountry;
+
+      // Country-only follow-up: "Thailand" must not overwrite a stored ZIP as city.
+      if (state.weatherCity && !country) {
+        const followUp =
+          matchCountryName(text) ??
+          (parsed?.city ? matchCountryName(parsed.city) : null);
+        if (followUp) {
+          city = state.weatherCity;
+          country = followUp;
+        }
+      }
 
       if (!city) {
         const ask = speakAndChat(
@@ -414,7 +426,7 @@ export function handleUtterance(
         };
       }
 
-      if (!country && !parsed?.country && !state.weatherCountry) {
+      if (!country) {
         return {
           state: {
             ...state,
@@ -428,12 +440,11 @@ export function handleUtterance(
         };
       }
 
-      const resolvedCountry = country ?? state.weatherCountry;
       return {
-        state: { ...state, weatherCity: city, weatherCountry: resolvedCountry },
+        state: { ...state, weatherCity: city, weatherCountry: country },
         speakLines: [],
         messages: [],
-        pendingWeather: { city, country: resolvedCountry },
+        pendingWeather: { city, country },
       };
     }
 

package/templates/voice-showcase/weather.ts

@@ -20,6 +20,163 @@ export interface WeatherResult {
 
 export type FetchFn = typeof fetch;
 
+export type ParsedLocation = {
+  city?: string;
+  country?: string;
+};
+
+const DIGIT_WORDS: Record<string, string> = {
+  zero: "0",
+  oh: "0",
+  o: "0",
+  one: "1",
+  two: "2",
+  three: "3",
+  four: "4",
+  five: "5",
+  six: "6",
+  seven: "7",
+  eight: "8",
+  nine: "9",
+};
+
+/** Lowercase aliases → Open-Meteo-friendly country names. */
+const COUNTRY_ALIASES: Record<string, string> = {
+  thailand: "Thailand",
+  us: "United States",
+  usa: "United States",
+  america: "United States",
+  "united states": "United States",
+  "united states of america": "United States",
+  uk: "United Kingdom",
+  britain: "United Kingdom",
+  england: "United Kingdom",
+  "united kingdom": "United Kingdom",
+  "great britain": "United Kingdom",
+  germany: "Germany",
+  france: "France",
+  spain: "Spain",
+  italy: "Italy",
+  japan: "Japan",
+  china: "China",
+  india: "India",
+  australia: "Australia",
+  canada: "Canada",
+  brazil: "Brazil",
+  mexico: "Mexico",
+  netherlands: "Netherlands",
+  holland: "Netherlands",
+  "the netherlands": "Netherlands",
+  belgium: "Belgium",
+  switzerland: "Switzerland",
+  sweden: "Sweden",
+  norway: "Norway",
+  denmark: "Denmark",
+  finland: "Finland",
+  poland: "Poland",
+  portugal: "Portugal",
+  greece: "Greece",
+  turkey: "Turkey",
+  egypt: "Egypt",
+  "south africa": "South Africa",
+  "new zealand": "New Zealand",
+  ireland: "Ireland",
+  singapore: "Singapore",
+  malaysia: "Malaysia",
+  indonesia: "Indonesia",
+  vietnam: "Vietnam",
+  philippines: "Philippines",
+  "south korea": "South Korea",
+  korea: "South Korea",
+  taiwan: "Taiwan",
+  "hong kong": "Hong Kong",
+  israel: "Israel",
+  uae: "United Arab Emirates",
+  "united arab emirates": "United Arab Emirates",
+  "saudi arabia": "Saudi Arabia",
+  pakistan: "Pakistan",
+  bangladesh: "Bangladesh",
+  nigeria: "Nigeria",
+  kenya: "Kenya",
+  argentina: "Argentina",
+  chile: "Chile",
+  colombia: "Colombia",
+  peru: "Peru",
+  austria: "Austria",
+  "czech republic": "Czechia",
+  czechia: "Czechia",
+  romania: "Romania",
+  hungary: "Hungary",
+  ukraine: "Ukraine",
+};
+
+export function matchCountryName(text: string): string | null {
+  const key = text
+    .trim()
+    .toLowerCase()
+    .replace(/[.,!?]+$/g, "")
+    .replace(/\s+/g, " ");
+  if (!key) return null;
+  return COUNTRY_ALIASES[key] ?? null;
+}
+
+/** "eight four three two zero" → "84320" (4–6 digits). */
+export function spokenDigitsToPostal(text: string): string | null {
+  const tokens = text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+  const digits: string[] = [];
+  for (const token of tokens) {
+    if (/^\d$/.test(token)) {
+      digits.push(token);
+      continue;
+    }
+    const mapped = DIGIT_WORDS[token];
+    if (mapped) {
+      digits.push(mapped);
+    }
+    // Skip STT filler ("welcome", "down", "there", …).
+  }
+  if (digits.length >= 4 && digits.length <= 6) {
+    return digits.join("");
+  }
+  return null;
+}
+
+function splitTrailingCountry(
+  text: string,
+): { rest: string; country: string } | null {
+  const words = text.trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return null;
+  for (let n = Math.min(3, words.length - 1); n >= 1; n -= 1) {
+    const tail = words.slice(-n).join(" ");
+    const country = matchCountryName(tail);
+    if (country) {
+      return { rest: words.slice(0, -n).join(" "), country };
+    }
+  }
+  return null;
+}
+
+function cityFromRemainder(rest: string): string | null {
+  const trimmed = rest
+    .trim()
+    .replace(/[.,!?;:]+$/g, "")
+    .replace(/\s+(?:in the|in|of)$/i, "")
+    .trim();
+  if (!trimmed) return null;
+  if (/^\d{4,6}(-\d{4})?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const spoken = spokenDigitsToPostal(trimmed);
+  if (spoken) return spoken;
+  if (trimmed.length >= 2 && trimmed.length <= 60) {
+    return trimmed;
+  }
+  return null;
+}
+
 /** Map WMO weather_code to a short English phrase. */
 export function wmoCodeToPhrase(code: number): string {
   if (code === 0) return "clear sky";
@@ -43,20 +200,36 @@ export function formatWeatherSpeech(result: WeatherResult): string {
 /** Parse city/zip and country from a single utterance when possible. */
 export function parseLocationUtterance(
   utterance: string,
-): { city: string; country?: string } | null {
+): ParsedLocation | null {
   const text = utterance.trim();
   if (!text) return null;
 
+  const countryOnly = matchCountryName(text);
+  if (countryOnly) {
+    return { country: countryOnly };
+  }
+
+  const trailing = splitTrailingCountry(text);
+  if (trailing) {
+    const city = cityFromRemainder(trailing.rest);
+    if (city) {
+      return { city, country: trailing.country };
+    }
+    return { country: trailing.country };
+  }
+
   const inMatch = text.match(
     /^(?:in\s+)?(.+?)\s+in\s+([a-zA-Z][\w\s.-]{1,40})$/i,
   );
   if (inMatch) {
-    return { city: inMatch[1]!.trim(), country: inMatch[2]!.trim() };
+    const country = matchCountryName(inMatch[2]!) ?? inMatch[2]!.trim();
+    return { city: inMatch[1]!.trim(), country };
   }
 
   const commaMatch = text.match(/^(.+?),\s*([a-zA-Z][\w\s.-]{1,40})$/);
   if (commaMatch) {
-    return { city: commaMatch[1]!.trim(), country: commaMatch[2]!.trim() };
+    const country = matchCountryName(commaMatch[2]!) ?? commaMatch[2]!.trim();
+    return { city: commaMatch[1]!.trim(), country };
   }
 
   const countryMatch = text.match(
@@ -64,16 +237,22 @@ export function parseLocationUtterance(
   );
   if (countryMatch && countryMatch[2]!.split(/\s+/).length <= 3) {
     const city = countryMatch[1]!.trim();
-    const country = countryMatch[2]!.trim();
+    const countryRaw = countryMatch[2]!.trim();
+    const country = matchCountryName(countryRaw) ?? countryRaw;
     if (city.length >= 2 && country.length >= 2) {
       return { city, country };
     }
   }
 
-  if (/^\d{5}(-\d{4})?$/.test(text)) {
+  if (/^\d{4,6}(-\d{4})?$/.test(text)) {
     return { city: text };
   }
 
+  const spokenPostal = spokenDigitsToPostal(text);
+  if (spokenPostal) {
+    return { city: spokenPostal };
+  }
+
   if (text.length >= 2 && text.length <= 60) {
     return { city: text };
   }