log_unmet_request

Instructions

Implementation Reference

• src/services/requests.ts:70-107 (handler)

  Core handler that inserts an unmet request into the database. Validates raw_query, normalizes fields (channel, language, city, etc.), and writes to concierge_unmet_requests table. Returns request_id, status, and created_at.

  export async function logUnmetRequest(
    supabase: SupabaseClient,
    input: LogUnmetRequestInput,
  ): Promise<UnmetRequestResult> {
    const rawQuery = String(input.raw_query || "").trim();
    if (!rawQuery) {
      throw new NightlifeError("INVALID_REQUEST", "raw_query cannot be blank.");
    }
  
    const payload = {
      channel: normalizeChannel(input.channel),
      language: normalizeLanguage(input.language),
      city: normalizeCity(input.city),
      raw_query: rawQuery.slice(0, 4000),
      normalized_intent: normalizeIntent(input.intent),
      suggested_filters: normalizeSuggestedFilters(input.suggested_filters),
      user_hash: normalizeUserHash(input.user_hash),
      status: "open",
    };
  
    const { data, error } = await supabase
      .from("concierge_unmet_requests")
      .insert(payload)
      .select("id,status,created_at")
      .single<UnmetRequestRow>();
  
    if (error || !data) {
      throw new NightlifeError("REQUEST_WRITE_FAILED", "Failed to log unmet request.", {
        cause: error?.message || "Unknown insert error",
      });
    }
  
    return {
      request_id: data.id,
      status: data.status,
      created_at: data.created_at,
    };
  }

• src/services/requests.ts:5-13 (schema)

  Input type definition for logUnmetRequest. Fields: channel, language, city, raw_query (required), intent, suggested_filters, user_hash.

  export type LogUnmetRequestInput = {
    channel?: string;
    language?: string;
    city?: string;
    raw_query: string;
    intent?: string;
    suggested_filters?: Record<string, unknown>;
    user_hash?: string;
  };

• src/types.ts:196-200 (schema)

  Return type interface for logUnmetRequest result.

  export interface UnmetRequestResult {
    request_id: string;
    status: string;
    created_at: string;
  }

• src/tools/requests.ts:16-20 (schema)

  Zod output schema used for runtime validation of the tool output (request_id, status, created_at).

  const unmetRequestOutputSchema = z.object({
    request_id: z.string(),
    status: z.string(),
    created_at: z.string(),
  });

• src/tools/requests.ts:79-101 (registration)

  Registration of the log_unmet_request MCP tool on the server. Defines description, inputSchema (channel, language, city, raw_query, intent, suggested_filters, user_hash), outputSchema, and the handler callback that invokes logUnmetRequest service.

  export function registerRequestTools(server: McpServer, deps: ToolDeps): void {
    server.registerTool(
      "log_unmet_request",
      {
        description:
          "Log unmet user intent when no good nightlife answer is available, for product follow-up.",
        inputSchema: {
          channel: z.string().optional(),
          language: z.string().optional(),
          city: z.string().optional(),
          raw_query: z.string().min(1),
          intent: z.string().optional(),
          suggested_filters: z.record(z.string(), z.unknown()).optional(),
          user_hash: z.string().optional(),
        },
        outputSchema: unmetRequestOutputSchema,
      },
      async (args) => runTool(
        "log_unmet_request",
        unmetRequestOutputSchema,
        async () => logUnmetRequest(deps.supabase, args),
      ),
    );